#include <string.h>
#include <deflt.h>
#include <tsol/label.h>
#include <bsm/devices.h>
#include <bsm/devalloc.h>
#include <utime.h>
#include <sys/param.h>
#include <bsm/libbsm.h>
#include <zone.h>
#include "devfsadm_impl.h"
extern void _reset_devalloc(int);
extern void _update_devalloc_db(devlist_t *, int, int, char *, char *);
extern int _da_check_for_usb(char *, char *);
static int file_mods = TRUE;
static int cleanup = FALSE;
static int devlinks_debug = FALSE;
int system_labeled = FALSE;
static int devalloc_flag = 0;
static int devalloc_is_on = 0;
static int update_devdb = 0;
static char *devalloc_list[10] = {DDI_NT_AUDIO, DDI_NT_CD, DDI_NT_CD_CHAN,
DDI_NT_FD, DDI_NT_TAPE, DDI_NT_BLOCK_CHAN,
DDI_NT_UGEN, DDI_NT_USB_ATTACHMENT_POINT,
DDI_NT_SCSI_NEXUS, NULL};
static devlist_t devlist;
static int single_drv = FALSE;
static char *driver = NULL;
static int load_attach_drv = TRUE;
static int update_all_drivers = FALSE;
static int daemon_mode = FALSE;
int event_driven = FALSE;
static int logflag = FALSE;
static int build_dev = TRUE;
static int build_devices = TRUE;
static int flush_path_to_inst_enable = TRUE;
static int inst_count = 0;
static mutex_t count_lock;
static cond_t cv;
static mutex_t minor_fini_mutex;
static int minor_fini_canceled = TRUE;
static int minor_fini_delayed = FALSE;
static cond_t minor_fini_cv;
static int minor_fini_timeout = MINOR_FINI_TIMEOUT_DEFAULT;
static sema_t dev_sema;
static char *prog;
static create_list_t *create_head = NULL;
static remove_list_t *remove_head = NULL;
static char **classes = NULL;
static int num_classes = 0;
static int num_verbose = 0;
static char **verbose = NULL;
static struct mperm *minor_perms = NULL;
static driver_alias_t *driver_aliases = NULL;
static char *root_dir = "";
static char *devices_dir = DEVICES;
static char *dev_dir = DEV;
static char *etc_dev_dir = ETCDEV;
static char *attr_root = NULL;
static char *inst_file = INSTANCE_FILE;
static char *module_dirs = MODULE_DIRS;
static uid_t root_uid;
static gid_t sys_gid;
static char *devlinktab_file = NULL;
static char *enumerate_file = ENUMERATE_RESERVED;
static enumerate_file_t *enumerate_reserved = NULL;
static int linknew = TRUE;
static devlinktab_list_t *devlinktab_list = NULL;
static unsigned int devlinktab_line = 0;
static numeral_set_t *head_numeral_set = NULL;
static module_t *module_head = NULL;
static n2m_t *n2m_list = NULL;
static linkhead_t *headlinkhead = NULL;
static int hold_dev_lock = FALSE;
static int hold_daemon_lock = FALSE;
static int dev_lock_fd;
static int daemon_lock_fd;
static char dev_lockfile[PATH_MAX + 1];
static char daemon_lockfile[PATH_MAX + 1];
static di_node_t lnode;
static di_minor_t lminor;
static char lphy_path[PATH_MAX + 1] = {""};
static di_devlink_handle_t devlink_cache;
static int update_database = FALSE;
static struct login_dev *login_dev_cache = NULL;
static int login_dev_enable = FALSE;
static int use_snapshot_cache = FALSE;
static item_t **nfp_hash;
static mutex_t nfp_mutex = DEFAULTMUTEX;
static char *sticky_dirs[] =
{"dsk", "rdsk", "term", "lofi", "rlofi", NULL};
static int lookup_door_fd = -1;
static char *lookup_door_path;
static void load_dev_acl(void);
static void update_drvconf(major_t, int);
static void check_reconfig_state(void);
static int s_stat(const char *, struct stat *);
static int is_blank(char *);
static mutex_t syseventq_mutex = DEFAULTMUTEX;
static syseventq_t *syseventq_front;
static syseventq_t *syseventq_back;
static void process_syseventq();
static di_node_t devi_root_node = DI_NODE_NIL;
int
main(int argc, char *argv[])
{
struct passwd *pw;
struct group *gp;
pid_t pid;
(void) setlocale(LC_ALL, "");
(void) textdomain(TEXT_DOMAIN);
if ((prog = strrchr(argv[0], '/')) == NULL) {
prog = argv[0];
} else {
prog++;
}
if (getuid() != 0) {
err_print(MUST_BE_ROOT);
devfsadm_exit(1);
}
if (getzoneid() != GLOBAL_ZONEID) {
err_print(MUST_BE_GLOBAL_ZONE);
devfsadm_exit(1);
}
closefrom(3);
if ((pw = getpwnam(DEFAULT_DEV_USER)) != NULL) {
root_uid = pw->pw_uid;
} else {
err_print(CANT_FIND_USER, DEFAULT_DEV_USER);
root_uid = (uid_t)0;
}
if ((gp = getgrnam(DEFAULT_DEV_GROUP)) != NULL) {
sys_gid = gp->gr_gid;
} else {
err_print(CANT_FIND_GROUP, DEFAULT_DEV_GROUP);
sys_gid = (gid_t)3;
}
(void) umask(0);
system_labeled = is_system_labeled();
if (system_labeled == FALSE) {
if (defopen("/etc/system") == 0) {
if (defread("set sys_labeling=1") != NULL)
system_labeled = TRUE;
(void) defopen(NULL);
}
}
devalloc_is_on = (da_is_on() == 1) ? 1 : 0;
#ifdef DEBUG
if (system_labeled == FALSE) {
struct stat tx_stat;
system_labeled = is_system_labeled_debug(&tx_stat);
}
#endif
parse_args(argc, argv);
(void) sema_init(&dev_sema, 1, USYNC_THREAD, NULL);
devlist.audio = devlist.cd = devlist.floppy = devlist.tape =
devlist.rmdisk = NULL;
if (daemon_mode == TRUE) {
if (getenv(RECONFIG_BOOT) != NULL && root_dir[0] != '\0') {
vprint(INFO_MID, CONFIGURING);
load_dev_acl();
update_drvconf((major_t)-1, 0);
process_devinfo_tree();
(void) modctl(MODSETMINIROOT);
}
if (fork() != 0) {
devfsadm_exit(0);
}
if (chdir("/") == -1) {
err_print(CHROOT_FAILED, strerror(errno));
}
if ((pid = enter_daemon_lock()) == getpid()) {
detachfromtty();
(void) cond_init(&cv, USYNC_THREAD, 0);
(void) mutex_init(&count_lock, USYNC_THREAD, 0);
if (thr_create(NULL, 0,
(void *(*)(void *))instance_flush_thread,
NULL, THR_DETACHED, NULL) != 0) {
err_print(CANT_CREATE_THREAD, "daemon",
strerror(errno));
devfsadm_exit(1);
}
(void) mutex_init(&minor_fini_mutex, USYNC_THREAD, 0);
(void) cond_init(&minor_fini_cv, USYNC_THREAD, 0);
if (thr_create(NULL, 0, minor_fini_thread,
NULL, THR_DETACHED, NULL)) {
err_print(CANT_CREATE_THREAD, "minor_fini",
strerror(errno));
devfsadm_exit(1);
}
if (root_dir[0] == '\0')
login_dev_enable = TRUE;
daemon_update();
devfsadm_exit(0);
} else {
err_print(DAEMON_RUNNING, pid);
devfsadm_exit(1);
}
} else {
if (devalloc_flag == DA_OFF) {
read_minor_perm_file();
}
process_devinfo_tree();
if (devalloc_flag != 0)
_reset_devalloc(devalloc_flag);
}
return (0);
}
static void
update_drvconf(major_t major, int flags)
{
if (modctl(MODLOADDRVCONF, major, flags) != 0)
err_print(gettext("update_drvconf failed for major %d\n"),
major);
}
static void
load_dev_acl()
{
if (load_devpolicy() != 0)
err_print(gettext("device policy load failed\n"));
load_minor_perm_file();
}
static void
check_reconfig_state()
{
struct stat sb;
if (s_stat("/reconfigure", &sb) == 0) {
(void) modctl(MODDEVNAME, MODDEVNAME_RECONFIG, 0);
}
}
static void
modctl_sysavail()
{
(void) modctl(MODDEVNAME, MODDEVNAME_SYSAVAIL, 0);
}
static void
set_lock_root(void)
{
struct stat sb;
char *lock_root;
size_t len;
lock_root = attr_root ? attr_root : root_dir;
len = strlen(lock_root) + strlen(ETCDEV) + 1;
etc_dev_dir = s_malloc(len);
(void) snprintf(etc_dev_dir, len, "%s%s", lock_root, ETCDEV);
if (s_stat(etc_dev_dir, &sb) != 0) {
s_mkdirp(etc_dev_dir, S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH);
} else if (!S_ISDIR(sb.st_mode)) {
err_print(NOT_DIR, etc_dev_dir);
devfsadm_exit(1);
}
}
static void
parse_args(int argc, char *argv[])
{
int opt;
char get_linkcompat_opts = FALSE;
char *compat_class;
int num_aliases = 0;
int len;
int retval;
int config = TRUE;
int bind = FALSE;
int force_flag = FALSE;
struct aliases *ap = NULL;
struct aliases *a_head = NULL;
struct aliases *a_tail = NULL;
struct modconfig mc;
(void) bzero(&mc, sizeof (mc));
if (strcmp(prog, DISKS) == 0) {
compat_class = "disk";
get_linkcompat_opts = TRUE;
} else if (strcmp(prog, TAPES) == 0) {
compat_class = "tape";
get_linkcompat_opts = TRUE;
} else if (strcmp(prog, PORTS) == 0) {
compat_class = "port";
get_linkcompat_opts = TRUE;
} else if (strcmp(prog, AUDLINKS) == 0) {
compat_class = "audio";
get_linkcompat_opts = TRUE;
} else if (strcmp(prog, DEVLINKS) == 0) {
devlinktab_file = DEVLINKTAB_FILE;
build_devices = FALSE;
load_attach_drv = FALSE;
while ((opt = getopt(argc, argv, "dnr:st:vV:")) != EOF) {
switch (opt) {
case 'd':
file_mods = FALSE;
flush_path_to_inst_enable = FALSE;
devlinks_debug = TRUE;
break;
case 'n':
load_attach_drv = FALSE;
break;
case 'r':
set_root_devices_dev_dir(optarg);
if (zone_pathcheck(root_dir) !=
DEVFSADM_SUCCESS)
devfsadm_exit(1);
break;
case 's':
file_mods = FALSE;
flush_path_to_inst_enable = FALSE;
break;
case 't':
devlinktab_file = optarg;
break;
case 'v':
add_verbose_id(VERBOSE_MID);
break;
case 'V':
add_verbose_id(optarg);
break;
default:
usage();
break;
}
}
if (optind < argc) {
usage();
}
} else if (strcmp(prog, DRVCONFIG) == 0) {
int update_only = 0;
build_dev = FALSE;
while ((opt =
getopt(argc, argv, "a:bc:dfi:m:np:R:r:suvV:x")) != EOF) {
switch (opt) {
case 'a':
ap = calloc(sizeof (struct aliases), 1);
ap->a_name = dequote(optarg);
len = strlen(ap->a_name) + 1;
if (len > MAXMODCONFNAME) {
err_print(ALIAS_TOO_LONG,
MAXMODCONFNAME, ap->a_name);
devfsadm_exit(1);
}
ap->a_len = len;
if (a_tail == NULL) {
a_head = ap;
} else {
a_tail->a_next = ap;
}
a_tail = ap;
num_aliases++;
bind = TRUE;
break;
case 'b':
bind = TRUE;
break;
case 'c':
(void) strcpy(mc.drvclass, optarg);
break;
case 'd':
break;
case 'f':
force_flag = TRUE;
break;
case 'i':
single_drv = TRUE;
(void) strcpy(mc.drvname, optarg);
driver = s_strdup(optarg);
break;
case 'm':
mc.major = atoi(optarg);
break;
case 'n':
load_attach_drv = FALSE;
break;
case 'p':
inst_file = s_strdup(optarg);
break;
case 'R':
root_dir = s_strdup(optarg);
if (zone_pathcheck(root_dir) !=
DEVFSADM_SUCCESS)
devfsadm_exit(devfsadm_copy());
break;
case 'r':
devices_dir = s_strdup(optarg);
if (zone_pathcheck(devices_dir) !=
DEVFSADM_SUCCESS)
devfsadm_exit(1);
break;
case 's':
file_mods = FALSE;
flush_path_to_inst_enable = FALSE;
break;
case 'u':
config = FALSE;
break;
case 'v':
add_verbose_id(VERBOSE_MID);
break;
case 'V':
add_verbose_id(optarg);
break;
case 'x':
update_only = 1;
break;
default:
usage();
}
}
if (optind < argc) {
usage();
}
if (bind == TRUE) {
if ((mc.major == -1) || (mc.drvname[0] == '\0')) {
err_print(MAJOR_AND_B_FLAG);
devfsadm_exit(1);
}
mc.flags = 0;
if (force_flag)
mc.flags |= MOD_UNBIND_OVERRIDE;
if (update_only)
mc.flags |= MOD_ADDMAJBIND_UPDATE;
mc.num_aliases = num_aliases;
mc.ap = a_head;
retval = modctl((config == TRUE) ? MODADDMAJBIND :
MODREMDRVALIAS, NULL, (caddr_t)&mc);
if (retval < 0) {
err_print((config == TRUE) ? MODCTL_ADDMAJBIND :
MODCTL_REMMAJBIND);
}
devfsadm_exit(retval);
}
} else if ((strcmp(prog, DEVFSADM) == 0) ||
(strcmp(prog, DEVFSADMD) == 0)) {
char *zonename = NULL;
int init_drvconf = 0;
int init_perm = 0;
int public_mode = 0;
int init_sysavail = 0;
if (strcmp(prog, DEVFSADMD) == 0) {
daemon_mode = TRUE;
}
devlinktab_file = DEVLINKTAB_FILE;
while ((opt = getopt(argc, argv,
"a:Cc:deIi:l:np:PR:r:sSt:uvV:x:")) != EOF) {
if (opt == 'I' || opt == 'P' || opt == 'S') {
if (public_mode)
usage();
} else {
if (init_perm || init_drvconf || init_sysavail)
usage();
public_mode = 1;
}
switch (opt) {
case 'a':
attr_root = s_strdup(optarg);
break;
case 'C':
cleanup = TRUE;
break;
case 'c':
num_classes++;
classes = s_realloc(classes,
num_classes * sizeof (char *));
classes[num_classes - 1] = optarg;
break;
case 'd':
if (daemon_mode == FALSE) {
devalloc_flag = DA_OFF;
build_dev = FALSE;
}
break;
case 'e':
if (daemon_mode == FALSE) {
devalloc_flag = DA_ON;
build_dev = FALSE;
}
break;
case 'I':
if (daemon_mode == TRUE)
usage();
init_drvconf = 1;
break;
case 'i':
single_drv = TRUE;
driver = s_strdup(optarg);
break;
case 'l':
module_dirs = s_strdup(optarg);
break;
case 'n':
load_attach_drv = FALSE;
break;
case 'p':
inst_file = s_strdup(optarg);
break;
case 'P':
if (daemon_mode == TRUE)
usage();
init_perm = 1;
break;
case 'R':
root_dir = s_strdup(optarg);
devfsadm_exit(devfsadm_copy());
break;
case 'r':
set_root_devices_dev_dir(optarg);
break;
case 's':
file_mods = FALSE;
flush_path_to_inst_enable = FALSE;
break;
case 'S':
if (daemon_mode == TRUE)
usage();
init_sysavail = 1;
break;
case 't':
devlinktab_file = optarg;
break;
case 'u':
if (daemon_mode == TRUE)
usage();
update_all_drivers = TRUE;
break;
case 'v':
add_verbose_id(VERBOSE_MID);
break;
case 'V':
add_verbose_id(optarg);
break;
case 'x':
if (strcmp(optarg, "update_devlinksdb") == 0) {
update_database = TRUE;
} else if (strcmp(optarg, "no_dev") == 0) {
build_dev = FALSE;
} else if (strcmp(optarg, "no_devices") == 0) {
build_devices = FALSE;
} else if (strcmp(optarg, "no_p2i") == 0) {
flush_path_to_inst_enable = FALSE;
} else if (strcmp(optarg, "use_dicache") == 0) {
use_snapshot_cache = TRUE;
} else {
usage();
}
break;
default:
usage();
break;
}
}
if (optind < argc) {
usage();
}
if (zonename == NULL) {
if (zone_pathcheck(root_dir) != DEVFSADM_SUCCESS)
devfsadm_exit(1);
}
if (init_drvconf || init_perm || init_sysavail) {
if (init_perm) {
check_reconfig_state();
load_dev_acl();
}
if (init_drvconf)
update_drvconf((major_t)-1, 0);
if (init_sysavail)
modctl_sysavail();
devfsadm_exit(0);
}
}
if (get_linkcompat_opts == TRUE) {
build_devices = FALSE;
load_attach_drv = FALSE;
num_classes++;
classes = s_realloc(classes, num_classes *
sizeof (char *));
classes[num_classes - 1] = compat_class;
while ((opt = getopt(argc, argv, "Cnr:svV:")) != EOF) {
switch (opt) {
case 'C':
cleanup = TRUE;
break;
case 'n':
load_attach_drv = FALSE;
break;
case 'r':
set_root_devices_dev_dir(optarg);
if (zone_pathcheck(root_dir) !=
DEVFSADM_SUCCESS)
devfsadm_exit(1);
break;
case 's':
file_mods = FALSE;
flush_path_to_inst_enable = FALSE;
break;
case 'v':
add_verbose_id(VERBOSE_MID);
break;
case 'V':
add_verbose_id(optarg);
break;
default:
usage();
}
}
if (optind < argc) {
usage();
}
}
set_lock_root();
}
void
usage(void)
{
if (strcmp(prog, DEVLINKS) == 0) {
err_print(DEVLINKS_USAGE);
} else if (strcmp(prog, DRVCONFIG) == 0) {
err_print(DRVCONFIG_USAGE);
} else if ((strcmp(prog, DEVFSADM) == 0) ||
(strcmp(prog, DEVFSADMD) == 0)) {
err_print(DEVFSADM_USAGE);
} else {
err_print(COMPAT_LINK_USAGE);
}
devfsadm_exit(1);
}
static void
devi_tree_walk(struct dca_impl *dcip, int flags, char *ev_subclass)
{
char *msg, *name;
struct mlist mlist = {0};
di_node_t node;
vprint(CHATTY_MID, "devi_tree_walk: root=%s, minor=%s, driver=%s,"
" error=%d, flags=%u\n", dcip->dci_root,
dcip->dci_minor ? dcip->dci_minor : "<NULL>",
dcip->dci_driver ? dcip->dci_driver : "<NULL>", dcip->dci_error,
dcip->dci_flags);
assert(dcip->dci_root);
if (dcip->dci_flags & DCA_LOAD_DRV) {
node = di_init_driver(dcip->dci_driver, flags);
msg = DRIVER_FAILURE;
name = dcip->dci_driver;
} else {
node = di_init(dcip->dci_root, flags);
msg = DI_INIT_FAILED;
name = dcip->dci_root;
}
if (node == DI_NODE_NIL) {
dcip->dci_error = errno;
if (!(errno == ENXIO && (dcip->dci_flags & DCA_HOT_PLUG)))
err_print(msg, name, strerror(dcip->dci_error));
return;
}
if (dcip->dci_flags & DCA_FLUSH_PATHINST)
flush_path_to_inst();
dcip->dci_arg = &mlist;
devi_root_node = node;
vprint(CHATTY_MID, "walking device tree\n");
(void) di_walk_minor(node, NULL, DI_CHECK_ALIAS, dcip,
check_minor_type);
process_deferred_links(dcip, DCA_CREATE_LINK);
dcip->dci_arg = NULL;
if (ev_subclass)
build_and_enq_event(EC_DEV_ADD, ev_subclass, dcip->dci_root,
node, dcip->dci_minor);
if (system_labeled && update_devdb) {
_update_devalloc_db(&devlist, 0, DA_ADD, NULL, root_dir);
update_devdb = 0;
}
devi_root_node = DI_NODE_NIL;
di_fini(node);
}
static void
process_deferred_links(struct dca_impl *dcip, int flags)
{
struct mlist *dep;
struct minor *mp, *smp;
vprint(CHATTY_MID, "processing deferred links\n");
dep = dcip->dci_arg;
dcip->dci_arg = NULL;
assert(dep);
assert((dep->head == NULL) ^ (dep->tail != NULL));
assert(flags == DCA_FREE_LIST || flags == DCA_CREATE_LINK);
for (smp = NULL, mp = dep->head; mp; mp = mp->next) {
if (flags == DCA_CREATE_LINK)
(void) check_minor_type(mp->node, mp->minor, dcip);
free(smp);
smp = mp;
}
free(smp);
}
void
process_devinfo_tree()
{
uint_t flags;
struct dca_impl dci;
char name[MAXNAMELEN];
char *fcn = "process_devinfo_tree: ";
vprint(CHATTY_MID, "%senter\n", fcn);
dca_impl_init("/", NULL, &dci);
lock_dev();
if (update_all_drivers || load_attach_drv) {
update_drvconf((major_t)-1,
update_all_drivers ? MOD_LOADDRVCONF_RECONF : 0);
}
if (single_drv == TRUE) {
if (load_attach_drv == FALSE)
err_print(DRV_LOAD_REQD);
vprint(CHATTY_MID, "%sattaching driver (%s)\n", fcn, driver);
dci.dci_flags |= DCA_LOAD_DRV;
(void) snprintf(name, sizeof (name), "%s", driver);
dci.dci_driver = name;
flags = DINFOCPYALL | DINFOPATH;
} else if (load_attach_drv == TRUE) {
if (use_snapshot_cache == TRUE) {
flags = DINFOCACHE;
vprint(CHATTY_MID, "%susing snapshot cache\n", fcn);
} else {
vprint(CHATTY_MID, "%sattaching all drivers\n", fcn);
flags = DI_CACHE_SNAPSHOT_FLAGS;
if (cleanup) {
flags |= DINFOCLEANUP;
}
}
} else {
vprint(CHATTY_MID, "%staking snapshot of active devices\n",
fcn);
flags = DINFOCPYALL;
}
if (((load_attach_drv == TRUE) || (single_drv == TRUE)) &&
(build_devices == TRUE)) {
dci.dci_flags |= DCA_FLUSH_PATHINST;
}
pre_and_post_cleanup(RM_PRE);
devi_tree_walk(&dci, flags, NULL);
if (dci.dci_error) {
devfsadm_exit(1);
}
pre_and_post_cleanup(RM_POST);
unlock_dev(SYNC_STATE);
}
static void
print_cache_signal(int signo)
{
if (signal(SIGUSR1, print_cache_signal) == SIG_ERR) {
err_print("signal SIGUSR1 failed: %s\n", strerror(errno));
devfsadm_exit(1);
}
}
static void
revoke_lookup_door(void)
{
if (lookup_door_fd != -1) {
if (door_revoke(lookup_door_fd) == -1) {
err_print("door_revoke of %s failed - %s\n",
lookup_door_path, strerror(errno));
}
}
}
static void
catch_exit(int signo)
{
revoke_lookup_door();
}
static void
daemon_update(void)
{
int fd;
char *fcn = "daemon_update: ";
char door_file[MAXPATHLEN];
const char *subclass_list;
sysevent_handle_t *sysevent_hp;
vprint(CHATTY_MID, "%senter\n", fcn);
if (signal(SIGUSR1, print_cache_signal) == SIG_ERR) {
err_print("signal SIGUSR1 failed: %s\n", strerror(errno));
devfsadm_exit(1);
}
if (signal(SIGTERM, catch_exit) == SIG_ERR) {
err_print("signal SIGTERM failed: %s\n", strerror(errno));
devfsadm_exit(1);
}
if (snprintf(door_file, sizeof (door_file),
"%s%s", attr_root ? attr_root : root_dir, DEVFSADM_SERVICE_DOOR)
>= sizeof (door_file)) {
err_print("update_daemon failed to open sysevent service "
"door\n");
devfsadm_exit(1);
}
if ((sysevent_hp = sysevent_open_channel_alt(
door_file)) == NULL) {
err_print(CANT_CREATE_DOOR,
door_file, strerror(errno));
devfsadm_exit(1);
}
if (sysevent_bind_subscriber(sysevent_hp, event_handler) != 0) {
err_print(CANT_CREATE_DOOR,
door_file, strerror(errno));
(void) sysevent_close_channel(sysevent_hp);
devfsadm_exit(1);
}
subclass_list = EC_SUB_ALL;
if (sysevent_register_event(sysevent_hp, EC_ALL, &subclass_list, 1)
!= 0) {
err_print(CANT_CREATE_DOOR,
door_file, strerror(errno));
(void) sysevent_unbind_subscriber(sysevent_hp);
(void) sysevent_close_channel(sysevent_hp);
devfsadm_exit(1);
}
if (snprintf(door_file, sizeof (door_file), "%s/%s",
etc_dev_dir, DEVFSADM_SYNCH_DOOR) >= sizeof (door_file)) {
err_print(CANT_CREATE_DOOR, DEVFSADM_SYNCH_DOOR,
strerror(ENAMETOOLONG));
devfsadm_exit(1);
}
(void) s_unlink(door_file);
if ((fd = open(door_file, O_RDWR | O_CREAT, SYNCH_DOOR_PERMS)) == -1) {
err_print(CANT_CREATE_DOOR, door_file, strerror(errno));
devfsadm_exit(1);
}
(void) close(fd);
if ((fd = door_create(sync_handler, NULL,
DOOR_REFUSE_DESC | DOOR_NO_CANCEL)) == -1) {
err_print(CANT_CREATE_DOOR, door_file, strerror(errno));
(void) s_unlink(door_file);
devfsadm_exit(1);
}
if (fattach(fd, door_file) == -1) {
err_print(CANT_CREATE_DOOR, door_file, strerror(errno));
(void) s_unlink(door_file);
devfsadm_exit(1);
}
if (snprintf(door_file, sizeof (door_file), "%s/%s",
etc_dev_dir, DEVNAME_LOOKUP_DOOR) >= sizeof (door_file)) {
err_print(CANT_CREATE_DOOR, DEVNAME_LOOKUP_DOOR,
strerror(ENAMETOOLONG));
devfsadm_exit(1);
}
(void) s_unlink(door_file);
if ((fd = open(door_file, O_RDWR | O_CREAT, S_IRUSR|S_IWUSR)) == -1) {
err_print(CANT_CREATE_DOOR, door_file, strerror(errno));
devfsadm_exit(1);
}
(void) close(fd);
if ((fd = door_create(devname_lookup_handler, NULL,
DOOR_REFUSE_DESC)) == -1) {
err_print(CANT_CREATE_DOOR, door_file, strerror(errno));
(void) s_unlink(door_file);
devfsadm_exit(1);
}
(void) fdetach(door_file);
lookup_door_path = s_strdup(door_file);
retry:
if (fattach(fd, door_file) == -1) {
if (errno == EBUSY)
goto retry;
err_print(CANT_CREATE_DOOR, door_file, strerror(errno));
(void) s_unlink(door_file);
devfsadm_exit(1);
}
lookup_door_fd = fd;
if (devname_kcall(MODDEVNAME_LOOKUPDOOR, (void *)door_file) != 0)
err_print(DEVNAME_CONTACT_FAILED, strerror(errno));
vprint(CHATTY_MID, "%spausing\n", fcn);
for (;;) {
(void) pause();
}
}
static void
sync_handler(void *cookie, char *ap, size_t asize,
door_desc_t *dp, uint_t ndesc)
{
door_cred_t dcred;
struct dca_off *dcp, rdca;
struct dca_impl dci;
if (door_cred(&dcred) != 0 || dcred.dc_euid != 0) {
dcp = ⤷
dcp->dca_error = EPERM;
goto out;
}
assert(ap);
assert(asize == sizeof (*dcp));
dcp = (void *)ap;
assert(dcp->dca_root == 0);
dci.dci_root = &dcp->dca_name[dcp->dca_root];
dci.dci_minor = dcp->dca_minor ? &dcp->dca_name[dcp->dca_minor] : NULL;
dci.dci_driver =
dcp->dca_driver ? &dcp->dca_name[dcp->dca_driver] : NULL;
dci.dci_error = 0;
dci.dci_flags = dcp->dca_flags | (dci.dci_driver ? DCA_LOAD_DRV : 0);
dci.dci_arg = NULL;
lock_dev();
devi_tree_walk(&dci, DINFOCPYALL, NULL);
dcp->dca_error = dci.dci_error;
if (dcp->dca_flags & DCA_DEVLINK_SYNC)
unlock_dev(SYNC_STATE);
else
unlock_dev(CACHE_STATE);
out: (void) door_return((char *)dcp, sizeof (*dcp), NULL, 0);
}
static void
lock_dev(void)
{
vprint(CHATTY_MID, "lock_dev(): entered\n");
if (build_dev == FALSE)
return;
while (sema_wait(&dev_sema) != 0)
;
if (enter_dev_lock() != getpid()) {
invalidate_enumerate_cache();
rm_all_links_from_cache();
(void) di_devlink_close(&devlink_cache, DI_LINK_ERROR);
process_syseventq();
}
if (devlink_cache == NULL)
devlink_cache = di_devlink_open(root_dir, 0);
if (module_head == NULL) {
load_modules();
read_minor_perm_file();
read_driver_aliases_file();
read_devlinktab_file();
read_logindevperm_file();
read_enumerate_file();
}
if (module_head != NULL)
return;
if (strcmp(prog, DEVLINKS) == 0) {
if (devlinktab_list == NULL) {
err_print(NO_LINKTAB, devlinktab_file);
err_print(NO_MODULES, module_dirs);
err_print(ABORTING);
devfsadm_exit(1);
}
} else {
err_print(NO_MODULES, module_dirs);
if (strcmp(prog, DEVFSADM) == 0) {
err_print(MODIFY_PATH);
}
}
}
static void
unlock_dev(int flag)
{
assert(flag == SYNC_STATE || flag == CACHE_STATE);
vprint(CHATTY_MID, "unlock_dev(): entered\n");
if (flag == SYNC_STATE) {
(void) mutex_lock(&minor_fini_mutex);
minor_fini_canceled = TRUE;
minor_fini_delayed = FALSE;
(void) mutex_unlock(&minor_fini_mutex);
}
if (build_dev == FALSE)
return;
if (devlink_cache == NULL) {
err_print(NO_DEVLINK_CACHE);
}
assert(devlink_cache);
if (flag == SYNC_STATE) {
unload_modules();
if (update_database)
(void) di_devlink_update(devlink_cache);
(void) di_devlink_close(&devlink_cache, 0);
process_syseventq();
}
exit_dev_lock(0);
(void) mutex_lock(&minor_fini_mutex);
if (flag == SYNC_STATE) {
minor_fini_canceled = TRUE;
minor_fini_delayed = FALSE;
} else {
minor_fini_canceled = FALSE;
minor_fini_delayed = TRUE;
(void) cond_signal(&minor_fini_cv);
}
(void) mutex_unlock(&minor_fini_mutex);
(void) sema_post(&dev_sema);
}
static int
zone_pathcheck(char *checkpath)
{
void *dlhdl = NULL;
char *name;
char root[MAXPATHLEN];
char zroot[MAXPATHLEN];
char rzroot[MAXPATHLEN];
char tmp[MAXPATHLEN];
FILE *cookie;
int err = DEVFSADM_SUCCESS;
if (checkpath[0] == '\0')
return (DEVFSADM_SUCCESS);
if ((dlhdl = dlopen(LIBZONECFG_PATH, RTLD_LAZY)) == NULL) {
return (DEVFSADM_SUCCESS);
}
bzero(root, sizeof (root));
if (resolvepath(checkpath, root, sizeof (root) - 1) == -1) {
(void) strlcpy(root, checkpath, sizeof (root));
}
if (strlen(root) > 0 && (root[strlen(root) - 1] != '/')) {
(void) snprintf(tmp, sizeof (tmp), "%s/", root);
(void) strlcpy(root, tmp, sizeof (root));
}
cookie = setzoneent();
while ((name = getzoneent(cookie)) != NULL) {
if (strcmp(name, GLOBAL_ZONENAME) == 0) {
free(name);
continue;
}
if (zone_get_zonepath(name, zroot, sizeof (zroot)) != Z_OK) {
free(name);
continue;
}
bzero(rzroot, sizeof (rzroot));
if (resolvepath(zroot, rzroot, sizeof (rzroot) - 1) == -1) {
(void) strlcpy(rzroot, zroot, sizeof (rzroot));
}
if (strlen(rzroot) > 0 && (rzroot[strlen(rzroot) - 1] != '/')) {
(void) snprintf(tmp, sizeof (tmp), "%s/", rzroot);
(void) strlcpy(rzroot, tmp, sizeof (rzroot));
}
if (strncmp(rzroot, root, strlen(rzroot)) == 0) {
err_print(ZONE_PATHCHECK, root, name);
err = DEVFSADM_FAILURE;
free(name);
break;
}
free(name);
}
endzoneent(cookie);
(void) dlclose(dlhdl);
return (err);
}
static void
event_handler(sysevent_t *ev)
{
char *path;
char *minor;
char *subclass;
char *dev_ev_subclass;
char *driver_name;
nvlist_t *attr_list = NULL;
int err = 0;
int instance;
int branch_event = 0;
event_driven = TRUE;
subclass = sysevent_get_subclass_name(ev);
vprint(EVENT_MID, "event_handler: %s id:0X%llx\n",
subclass, sysevent_get_seq(ev));
if (strcmp(subclass, ESC_DEVFS_START) == 0) {
return;
}
if (strcmp(subclass, ESC_DEVFS_INSTANCE_MOD) == 0) {
devfs_instance_mod();
return;
}
if (sysevent_get_attr_list(ev, &attr_list) != 0) {
vprint(EVENT_MID, "event_handler: can not get attr list\n");
return;
}
if (strcmp(subclass, ESC_DEVFS_DEVI_ADD) == 0 ||
strcmp(subclass, ESC_DEVFS_DEVI_REMOVE) == 0 ||
strcmp(subclass, ESC_DEVFS_MINOR_CREATE) == 0 ||
strcmp(subclass, ESC_DEVFS_MINOR_REMOVE) == 0) {
if ((err = nvlist_lookup_string(attr_list, DEVFS_PATHNAME,
&path)) != 0)
goto out;
if (nvlist_lookup_string(attr_list, DEVFS_DEVI_CLASS,
&dev_ev_subclass) != 0)
dev_ev_subclass = NULL;
if (nvlist_lookup_string(attr_list, DEVFS_DRIVER_NAME,
&driver_name) != 0)
driver_name = NULL;
if (nvlist_lookup_int32(attr_list, DEVFS_INSTANCE,
&instance) != 0)
instance = -1;
if (nvlist_lookup_int32(attr_list, DEVFS_BRANCH_EVENT,
&branch_event) != 0)
branch_event = 0;
if (nvlist_lookup_string(attr_list, DEVFS_MINOR_NAME,
&minor) != 0)
minor = NULL;
lock_dev();
if (strcmp(ESC_DEVFS_DEVI_ADD, subclass) == 0) {
add_minor_pathname(path, NULL, dev_ev_subclass);
if (branch_event) {
build_and_enq_event(EC_DEV_BRANCH,
ESC_DEV_BRANCH_ADD, path, DI_NODE_NIL,
NULL);
}
} else if (strcmp(ESC_DEVFS_MINOR_CREATE, subclass) == 0) {
add_minor_pathname(path, minor, dev_ev_subclass);
} else if (strcmp(ESC_DEVFS_MINOR_REMOVE, subclass) == 0) {
hot_cleanup(path, minor, dev_ev_subclass, driver_name,
instance);
} else {
hot_cleanup(path, NULL, dev_ev_subclass,
driver_name, instance);
if (branch_event) {
build_and_enq_event(EC_DEV_BRANCH,
ESC_DEV_BRANCH_REMOVE, path, DI_NODE_NIL,
NULL);
}
}
unlock_dev(CACHE_STATE);
} else if (strcmp(subclass, ESC_DEVFS_BRANCH_ADD) == 0 ||
strcmp(subclass, ESC_DEVFS_BRANCH_REMOVE) == 0) {
if ((err = nvlist_lookup_string(attr_list,
DEVFS_PATHNAME, &path)) != 0)
goto out;
if (strcmp(subclass, ESC_DEVFS_BRANCH_ADD) == 0)
dev_ev_subclass = ESC_DEV_BRANCH_ADD;
else
dev_ev_subclass = ESC_DEV_BRANCH_REMOVE;
lock_dev();
build_and_enq_event(EC_DEV_BRANCH, dev_ev_subclass, path,
DI_NODE_NIL, NULL);
unlock_dev(CACHE_STATE);
} else
err_print(UNKNOWN_EVENT, subclass);
out:
if (err)
err_print(EVENT_ATTR_LOOKUP_FAILED, strerror(err));
nvlist_free(attr_list);
}
static void
dca_impl_init(char *root, char *minor, struct dca_impl *dcip)
{
assert(root);
dcip->dci_root = root;
dcip->dci_minor = minor;
dcip->dci_driver = NULL;
dcip->dci_error = 0;
dcip->dci_flags = 0;
dcip->dci_arg = NULL;
}
void
add_minor_pathname(char *node, char *minor, char *ev_subclass)
{
struct dca_impl dci;
vprint(CHATTY_MID, "add_minor_pathname: node_path=%s minor=%s\n",
node, minor ? minor : "NULL");
dca_impl_init(node, minor, &dci);
if (single_drv == TRUE) {
dci.dci_driver = driver;
}
dci.dci_flags = DCA_HOT_PLUG | DCA_CHECK_TYPE;
devi_tree_walk(&dci, DINFOPROP|DINFOMINOR, ev_subclass);
}
static di_node_t
find_clone_node()
{
static di_node_t clone_node = DI_NODE_NIL;
if (clone_node == DI_NODE_NIL)
clone_node = di_init("/pseudo/clone@0", DINFOPROP);
return (clone_node);
}
static int
is_descendent_of(di_node_t node, char *driver)
{
while (node != DI_NODE_NIL) {
char *drv = di_driver_name(node);
if (strcmp(drv, driver) == 0)
return (1);
node = di_parent_node(node);
}
return (0);
}
static int
check_minor_type(di_node_t node, di_minor_t minor, void *arg)
{
ddi_minor_type minor_type;
di_node_t clone_node;
char *mn;
char *nt;
struct mlist *dep;
struct dca_impl *dcip = arg;
assert(dcip);
dep = dcip->dci_arg;
mn = di_minor_name(minor);
if (dep &&
((dcip->dci_driver && !is_descendent_of(node, dcip->dci_driver)) ||
(dcip->dci_minor && strcmp(mn, dcip->dci_minor)))) {
return (DI_WALK_CONTINUE);
}
if ((dcip->dci_flags & DCA_CHECK_TYPE) &&
(nt = di_minor_nodetype(minor)) &&
(strcmp(nt, DDI_NT_NET) == 0)) {
dcip->dci_flags &= ~DCA_CHECK_TYPE;
}
minor_type = di_minor_type(minor);
if (minor_type == DDM_MINOR) {
minor_process(node, minor, dep);
} else if (minor_type == DDM_ALIAS) {
struct mlist *cdep, clone_del = {0};
clone_node = find_clone_node();
if (clone_node == DI_NODE_NIL) {
err_print(DI_INIT_FAILED, "clone", strerror(errno));
return (DI_WALK_CONTINUE);
}
cdep = dep ? &clone_del : NULL;
minor_process(clone_node, minor, cdep);
if (cdep != NULL && cdep->head != NULL) {
assert(cdep->tail != NULL);
cache_deferred_minor(dep, node, minor);
dcip->dci_arg = cdep;
process_deferred_links(dcip, DCA_FREE_LIST);
dcip->dci_arg = dep;
}
}
return (DI_WALK_CONTINUE);
}
static void
minor_process(di_node_t node, di_minor_t minor, struct mlist *dep)
{
create_list_t *create;
int defer;
vprint(CHATTY_MID, "minor_process: node=%s, minor=%s\n",
di_node_name(node), di_minor_name(minor));
if (dep != NULL) {
if (build_devices == TRUE) {
reset_node_permissions(node, minor);
}
if (build_dev == FALSE) {
return;
}
if (process_devlink_compat(minor, node) == TRUE) {
return;
}
} else {
vprint(CHATTY_MID, "minor_process: deferred processing\n");
}
defer = 0;
for (create = create_head; create != NULL; create = create->next) {
if ((minor_matches_rule(node, minor, create) == TRUE) &&
class_ok(create->create->device_class) ==
DEVFSADM_SUCCESS) {
if (call_minor_init(create->modptr) ==
DEVFSADM_FAILURE) {
continue;
}
if (dep && ((create->create->flags & CREATE_MASK) ==
CREATE_DEFER)) {
defer = 1;
continue;
} else if (dep == NULL &&
((create->create->flags & CREATE_MASK) !=
CREATE_DEFER)) {
continue;
}
if ((*(create->create->callback_fcn))
(minor, node) == DEVFSADM_TERMINATE) {
break;
}
}
}
if (defer)
cache_deferred_minor(dep, node, minor);
}
static void
cache_deferred_minor(
struct mlist *dep,
di_node_t node,
di_minor_t minor)
{
struct minor *mp;
const char *fcn = "cache_deferred_minor";
vprint(CHATTY_MID, "%s node=%s, minor=%s\n", fcn,
di_node_name(node), di_minor_name(minor));
if (dep == NULL) {
vprint(CHATTY_MID, "%s: cannot cache during "
"deferred processing. Ignoring minor\n", fcn);
return;
}
mp = (struct minor *)s_zalloc(sizeof (struct minor));
mp->node = node;
mp->minor = minor;
mp->next = NULL;
assert(dep->head == NULL || dep->tail != NULL);
if (dep->head == NULL) {
dep->head = mp;
} else {
dep->tail->next = mp;
}
dep->tail = mp;
}
static int
minor_matches_rule(di_node_t node, di_minor_t minor, create_list_t *create)
{
char *m_nodetype, *m_drvname;
if (create->create->node_type != NULL) {
m_nodetype = di_minor_nodetype(minor);
assert(m_nodetype != NULL);
switch (create->create->flags & TYPE_MASK) {
case TYPE_EXACT:
if (strcmp(create->create->node_type, m_nodetype) !=
0) {
return (FALSE);
}
break;
case TYPE_PARTIAL:
if (strncmp(create->create->node_type, m_nodetype,
strlen(create->create->node_type)) != 0) {
return (FALSE);
}
break;
case TYPE_RE:
if (regexec(&(create->node_type_comp), m_nodetype,
0, NULL, 0) != 0) {
return (FALSE);
}
break;
}
}
if (create->create->drv_name != NULL) {
m_drvname = di_driver_name(node);
switch (create->create->flags & DRV_MASK) {
case DRV_EXACT:
if (strcmp(create->create->drv_name, m_drvname) != 0) {
return (FALSE);
}
break;
case DRV_RE:
if (regexec(&(create->drv_name_comp), m_drvname,
0, NULL, 0) != 0) {
return (FALSE);
}
break;
}
}
return (TRUE);
}
static int
class_ok(char *class)
{
int i;
if (num_classes == 0) {
return (DEVFSADM_SUCCESS);
}
if (class == NULL) {
return (DEVFSADM_FAILURE);
}
for (i = 0; i < num_classes; i++) {
if (strcmp(class, classes[i]) == 0) {
return (DEVFSADM_SUCCESS);
}
}
return (DEVFSADM_FAILURE);
}
static void
unload_modules(void)
{
module_t *module_free;
create_list_t *create_free;
remove_list_t *remove_free;
while (create_head != NULL) {
create_free = create_head;
create_head = create_head->next;
if ((create_free->create->flags & TYPE_RE) == TYPE_RE) {
regfree(&(create_free->node_type_comp));
}
if ((create_free->create->flags & DRV_RE) == DRV_RE) {
regfree(&(create_free->drv_name_comp));
}
free(create_free);
}
while (remove_head != NULL) {
remove_free = remove_head;
remove_head = remove_head->next;
free(remove_free);
}
while (module_head != NULL) {
if ((module_head->minor_fini != NULL) &&
((module_head->flags & MODULE_ACTIVE) == MODULE_ACTIVE)) {
(void) (*(module_head->minor_fini))();
}
vprint(MODLOAD_MID, "unloading module %s\n", module_head->name);
free(module_head->name);
(void) dlclose(module_head->dlhandle);
module_free = module_head;
module_head = module_head->next;
free(module_free);
}
}
static void
load_modules(void)
{
DIR *mod_dir;
struct dirent *entp;
char cdir[PATH_MAX + 1];
char *last;
char *mdir = module_dirs;
char *fcn = "load_modules: ";
while (*mdir != '\0') {
while (*mdir == ':') {
mdir++;
}
if (*mdir == '\0') {
continue;
}
last = strchr(mdir, ':');
if (last == NULL) {
last = mdir + strlen(mdir);
}
(void) strncpy(cdir, mdir, last - mdir);
cdir[last - mdir] = '\0';
mdir += strlen(cdir);
if ((mod_dir = opendir(cdir)) == NULL) {
vprint(MODLOAD_MID, "%sopendir(%s): %s\n",
fcn, cdir, strerror(errno));
continue;
}
while ((entp = readdir(mod_dir)) != NULL) {
if ((strcmp(entp->d_name, ".") == 0) ||
(strcmp(entp->d_name, "..") == 0)) {
continue;
}
load_module(entp->d_name, cdir);
}
s_closedir(mod_dir);
}
}
static void
load_module(char *mname, char *cdir)
{
_devfsadm_create_reg_t *create_reg;
_devfsadm_remove_reg_V1_t *remove_reg;
create_list_t *create_list_element;
create_list_t **create_list_next;
remove_list_t *remove_list_element;
remove_list_t **remove_list_next;
char epath[PATH_MAX + 1], *end;
char *fcn = "load_module: ";
char *dlerrstr;
void *dlhandle;
module_t *module;
int flags;
int n;
int i;
if ((end = strstr(mname, MODULE_SUFFIX)) != NULL) {
if (end[strlen(MODULE_SUFFIX)] != '\0') {
return;
}
} else {
return;
}
(void) snprintf(epath, sizeof (epath), "%s/%s", cdir, mname);
if ((dlhandle = dlopen(epath, RTLD_LAZY)) == NULL) {
dlerrstr = dlerror();
err_print(DLOPEN_FAILED, epath,
dlerrstr ? dlerrstr : "unknown error");
return;
}
if (NULL == (create_reg = (_devfsadm_create_reg_t *)
dlsym(dlhandle, _DEVFSADM_CREATE_REG))) {
vprint(MODLOAD_MID, "dlsym(%s, %s): symbol not found\n", epath,
_DEVFSADM_CREATE_REG);
} else {
vprint(MODLOAD_MID, "%sdlsym(%s, %s) succeeded\n",
fcn, epath, _DEVFSADM_CREATE_REG);
}
if (NULL == (remove_reg = (_devfsadm_remove_reg_V1_t *)
dlsym(dlhandle, _DEVFSADM_REMOVE_REG))) {
vprint(MODLOAD_MID, "dlsym(%s,\n\t%s): symbol not found\n",
epath, _DEVFSADM_REMOVE_REG);
} else {
vprint(MODLOAD_MID, "dlsym(%s, %s): succeeded\n",
epath, _DEVFSADM_REMOVE_REG);
}
vprint(MODLOAD_MID, "module %s loaded\n", epath);
module = (module_t *)s_malloc(sizeof (module_t));
module->name = s_strdup(epath);
module->dlhandle = dlhandle;
module->minor_fini = (int (*)())dlsym(dlhandle, MINOR_FINI);
module->minor_init = (int (*)())dlsym(dlhandle, MINOR_INIT);
module->flags = 0;
if (create_reg != NULL) {
for (i = 0; i < create_reg->count; i++) {
int flags = create_reg->tblp[i].flags;
create_list_element = (create_list_t *)
s_malloc(sizeof (create_list_t));
create_list_element->create = &(create_reg->tblp[i]);
create_list_element->modptr = module;
if (((flags & CREATE_MASK) != 0) &&
((flags & CREATE_MASK) != CREATE_DEFER)) {
free(create_list_element);
err_print("illegal flag combination in "
"module create\n");
err_print(IGNORING_ENTRY, i, epath);
continue;
}
if (((flags & TYPE_MASK) == 0) ^
(create_reg->tblp[i].node_type == NULL)) {
free(create_list_element);
err_print("flags value incompatible with "
"node_type value in module create\n");
err_print(IGNORING_ENTRY, i, epath);
continue;
}
if (((flags & TYPE_MASK) != 0) &&
((flags & TYPE_MASK) != TYPE_EXACT) &&
((flags & TYPE_MASK) != TYPE_RE) &&
((flags & TYPE_MASK) != TYPE_PARTIAL)) {
free(create_list_element);
err_print("illegal TYPE_* flag combination in "
"module create\n");
err_print(IGNORING_ENTRY, i, epath);
continue;
}
if ((flags & TYPE_RE) == TYPE_RE) {
if ((n = regcomp(&(create_list_element->
node_type_comp),
create_reg->tblp[i].node_type,
REG_EXTENDED)) != 0) {
free(create_list_element);
err_print(REGCOMP_FAILED,
create_reg->tblp[i].node_type, n);
err_print(IGNORING_ENTRY, i, epath);
continue;
}
}
if (((flags & DRV_MASK) == 0) ^
(create_reg->tblp[i].drv_name == NULL)) {
if ((flags & TYPE_RE) == TYPE_RE) {
regfree(&(create_list_element->
node_type_comp));
}
free(create_list_element);
err_print("flags value incompatible with "
"drv_name value in module create\n");
err_print(IGNORING_ENTRY, i, epath);
continue;
}
if (((flags & DRV_MASK) != 0) &&
((flags & DRV_MASK) != DRV_EXACT) &&
((flags & DRV_MASK) != DRV_RE)) {
if ((flags & TYPE_RE) == TYPE_RE) {
regfree(&(create_list_element->
node_type_comp));
}
free(create_list_element);
err_print("illegal DRV_* flag combination in "
"module create\n");
err_print(IGNORING_ENTRY, i, epath);
continue;
}
if ((create_reg->tblp[i].flags & DRV_RE) == DRV_RE) {
if ((n = regcomp(&(create_list_element->
drv_name_comp),
create_reg->tblp[i].drv_name,
REG_EXTENDED)) != 0) {
if ((flags & TYPE_RE) == TYPE_RE) {
regfree(&(create_list_element->
node_type_comp));
}
free(create_list_element);
err_print(REGCOMP_FAILED,
create_reg->tblp[i].drv_name, n);
err_print(IGNORING_ENTRY, i, epath);
continue;
}
}
for (create_list_next = &(create_head);
(*create_list_next != NULL) &&
(*create_list_next)->create->interpose_lvl >=
create_list_element->create->interpose_lvl;
create_list_next = &((*create_list_next)->next))
;
create_list_element->next = *create_list_next;
*create_list_next = create_list_element;
}
}
flags = 0;
if (remove_reg != NULL) {
if (remove_reg->version < DEVFSADM_V1)
flags |= RM_NOINTERPOSE;
for (i = 0; i < remove_reg->count; i++) {
remove_list_element = (remove_list_t *)
s_malloc(sizeof (remove_list_t));
remove_list_element->remove = &(remove_reg->tblp[i]);
remove_list_element->remove->flags |= flags;
remove_list_element->modptr = module;
for (remove_list_next = &(remove_head);
(*remove_list_next != NULL) &&
(*remove_list_next)->remove->interpose_lvl >=
remove_list_element->remove->interpose_lvl;
remove_list_next = &((*remove_list_next)->next))
;
remove_list_element->next = *remove_list_next;
*remove_list_next = remove_list_element;
}
}
module->next = module_head;
module_head = module;
}
static void *
minor_fini_thread(void *arg __unused)
{
timestruc_t abstime;
vprint(INITFINI_MID, "minor_fini_thread starting\n");
(void) mutex_lock(&minor_fini_mutex);
for (;;) {
abstime.tv_sec = time(NULL) + minor_fini_timeout;
abstime.tv_nsec = 0;
(void) cond_timedwait(&minor_fini_cv,
&minor_fini_mutex, &abstime);
if (minor_fini_canceled == TRUE)
continue;
if (minor_fini_delayed == TRUE) {
minor_fini_delayed = FALSE;
continue;
}
(void) mutex_unlock(&minor_fini_mutex);
lock_dev();
unlock_dev(SYNC_STATE);
vprint(INITFINI_MID, "minor_fini sync done\n");
(void) mutex_lock(&minor_fini_mutex);
}
return (NULL);
}
static int
call_minor_init(module_t *module)
{
char *fcn = "call_minor_init: ";
if ((module->flags & MODULE_ACTIVE) == MODULE_ACTIVE) {
return (DEVFSADM_SUCCESS);
}
vprint(INITFINI_MID, "%smodule %s. current state: inactive\n",
fcn, module->name);
if (module->minor_init == NULL) {
module->flags |= MODULE_ACTIVE;
vprint(INITFINI_MID, "minor_init not defined\n");
return (DEVFSADM_SUCCESS);
}
if ((*(module->minor_init))() == DEVFSADM_FAILURE) {
err_print(FAILED_FOR_MODULE, MINOR_INIT, module->name);
return (DEVFSADM_FAILURE);
}
vprint(INITFINI_MID, "minor_init() returns DEVFSADM_SUCCESS. "
"new state: active\n");
module->flags |= MODULE_ACTIVE;
return (DEVFSADM_SUCCESS);
}
int
devfsadm_mklink(char *link, di_node_t node, di_minor_t minor, int flags)
{
char rcontents[PATH_MAX];
char devlink[PATH_MAX];
char phy_path[PATH_MAX];
char *acontents;
char *dev_path;
int numslashes;
int rv;
int i, link_exists;
int last_was_slash = FALSE;
if ((node == lnode) && (minor == lminor)) {
acontents = lphy_path;
} else if (di_minor_type(minor) == DDM_ALIAS) {
(void) snprintf(phy_path, sizeof (phy_path),
"/pseudo/clone@0:%s",
di_driver_name(di_minor_devinfo(minor)));
acontents = phy_path;
} else {
if ((dev_path = di_devfs_path(node)) == NULL) {
err_print(DI_DEVFS_PATH_FAILED, strerror(errno));
devfsadm_exit(1);
}
(void) snprintf(phy_path, sizeof (phy_path), "%s:%s",
dev_path, di_minor_name(minor));
di_devfs_path_free(dev_path);
acontents = phy_path;
}
(void) strlcpy(devlink, dev_dir, sizeof (devlink));
(void) strlcat(devlink, "/", sizeof (devlink));
(void) strlcat(devlink, link, sizeof (devlink));
for (i = 0; link[i] == '/'; i++)
;
for (numslashes = 0; link[i] != '\0'; i++) {
if (link[i] == '/') {
if (last_was_slash == FALSE) {
numslashes++;
last_was_slash = TRUE;
}
} else {
last_was_slash = FALSE;
}
}
if (link[i-1] == '/') {
numslashes--;
}
rcontents[0] = '\0';
do {
(void) strlcat(rcontents, "../", sizeof (rcontents));
} while (numslashes-- != 0);
(void) strlcat(rcontents, "devices", sizeof (rcontents));
(void) strlcat(rcontents, acontents, sizeof (rcontents));
if (devlinks_debug == TRUE) {
vprint(INFO_MID, "adding link %s ==> %s\n", devlink, rcontents);
}
if ((rv = create_link_common(devlink, rcontents, &link_exists))
== DEVFSADM_SUCCESS) {
linknew = TRUE;
add_link_to_cache(link, acontents);
} else {
linknew = FALSE;
}
if (link_exists == TRUE) {
(void) di_devlink_add_link(devlink_cache, link, rcontents,
DI_PRIMARY_LINK);
if (system_labeled && (flags & DA_ADD)) {
int instance = di_instance(node);
if ((flags & DA_CD) &&
(_da_check_for_usb(devlink, root_dir) == 1)) {
(void) da_add_list(&devlist, devlink, instance,
DA_ADD|DA_RMDISK);
update_devdb = DA_RMDISK;
} else if (linknew == TRUE) {
(void) da_add_list(&devlist, devlink, instance,
flags);
update_devdb = flags;
}
}
}
return (rv);
}
int
devfsadm_secondary_link(char *link, char *primary_link, int flags)
{
char contents[PATH_MAX + 1];
char devlink[PATH_MAX + 1];
int rv, link_exists;
char *fpath;
char *tpath;
char *op;
(void) strcpy(devlink, dev_dir);
(void) strcat(devlink, "/");
(void) strcat(devlink, link);
fpath = link;
tpath = primary_link;
op = contents;
while (*fpath == *tpath && *fpath != '\0') {
fpath++, tpath++;
}
while (*fpath != '\0') {
if (*fpath == '/') {
(void) strcpy(op, "../");
op += 3;
}
fpath++;
}
while (tpath != primary_link && *(tpath-1) != '/') {
tpath--;
}
(void) strcpy(op, tpath);
if (devlinks_debug == TRUE) {
vprint(INFO_MID, "adding extra link %s ==> %s\n",
devlink, contents);
}
if ((rv = create_link_common(devlink, contents, &link_exists))
== DEVFSADM_SUCCESS) {
add_link_to_cache(link, lphy_path);
linknew = TRUE;
if (system_labeled &&
((flags & DA_AUDIO) && (flags & DA_ADD))) {
int instance = 0;
op = strrchr(contents, '/');
op++;
(void) sscanf(op, "%d", &instance);
(void) da_add_list(&devlist, devlink, instance, flags);
update_devdb = flags;
}
} else {
linknew = FALSE;
}
if (link_exists == TRUE) {
(void) di_devlink_add_link(devlink_cache, link, contents,
DI_SECONDARY_LINK);
}
return (rv);
}
char *
devfsadm_get_devices_dir()
{
return (devices_dir);
}
static int
create_link_common(char *devlink, char *contents, int *exists)
{
int try;
int linksize;
int max_tries = 0;
static int prev_link_existed = TRUE;
char checkcontents[PATH_MAX + 1];
char *hide;
*exists = FALSE;
if (file_mods == FALSE) {
linksize = readlink(devlink, checkcontents, PATH_MAX);
if (linksize > 0) {
checkcontents[linksize] = '\0';
if (strcmp(checkcontents, contents) != 0) {
vprint(CHATTY_MID, REMOVING_LINK,
devlink, checkcontents);
return (DEVFSADM_SUCCESS);
} else {
vprint(CHATTY_MID, "link exists and is correct:"
" %s -> %s\n", devlink, contents);
return (DEVFSADM_FAILURE);
}
} else {
vprint(VERBOSE_MID, CREATING_LINK, devlink, contents);
return (DEVFSADM_SUCCESS);
}
}
if (prev_link_existed == FALSE) {
try = CREATE_LINK;
} else {
try = READ_LINK;
}
while (++max_tries <= 3) {
switch (try) {
case CREATE_LINK:
if (symlink(contents, devlink) == 0) {
vprint(VERBOSE_MID, CREATING_LINK, devlink,
contents);
prev_link_existed = FALSE;
*exists = TRUE;
set_logindev_perms(devlink);
return (DEVFSADM_SUCCESS);
} else {
switch (errno) {
case ENOENT:
hide = strrchr(devlink, '/');
*hide = '\0';
s_mkdirp(devlink, S_IRWXU|S_IRGRP|
S_IXGRP|S_IROTH|S_IXOTH);
*hide = '/';
break;
case EEXIST:
try = READ_LINK;
break;
default:
err_print(SYMLINK_FAILED, devlink,
contents, strerror(errno));
return (DEVFSADM_FAILURE);
}
}
break;
case READ_LINK:
linksize = readlink(devlink, checkcontents, PATH_MAX);
if (linksize >= 0) {
checkcontents[linksize] = '\0';
if (strcmp(checkcontents, contents) != 0) {
s_unlink(devlink);
vprint(VERBOSE_MID, REMOVING_LINK,
devlink, checkcontents);
try = CREATE_LINK;
} else {
prev_link_existed = TRUE;
vprint(CHATTY_MID,
"link exists and is correct:"
" %s -> %s\n", devlink, contents);
*exists = TRUE;
return (DEVFSADM_FAILURE);
}
} else {
switch (errno) {
case EINVAL:
s_unlink(devlink);
default:
try = CREATE_LINK;
break;
}
}
break;
}
}
err_print(MAX_ATTEMPTS, devlink, contents);
return (DEVFSADM_FAILURE);
}
static void
set_logindev_perms(char *devlink)
{
struct login_dev *newdev;
struct passwd pwd, *resp;
char pwd_buf[PATH_MAX];
int rv;
struct stat sb;
char *devfs_path = NULL;
if (login_dev_enable != TRUE)
return;
for (newdev = login_dev_cache; newdev; newdev = newdev->ldev_next) {
vprint(FILES_MID, "matching %s with %s\n", devlink,
newdev->ldev_device);
if (regexec(&newdev->ldev_device_regex, devlink, 0,
NULL, 0) == 0) {
vprint(FILES_MID, "matched %s with %s\n", devlink,
newdev->ldev_device);
break;
}
}
if (newdev == NULL)
return;
(void) resolve_link(devlink, NULL, NULL, &devfs_path, 0);
if (devfs_path) {
di_node_t node;
char *drv;
struct driver_list *list;
char *p;
(void) strcpy(pwd_buf, devfs_path);
p = strrchr(pwd_buf, ':');
if (p == NULL) {
free(devfs_path);
return;
}
*p = '\0';
vprint(FILES_MID, "link=%s->physpath=%s\n",
devlink, pwd_buf);
node = di_init(pwd_buf, DINFOMINOR);
drv = NULL;
if (node) {
drv = di_driver_name(node);
if (drv) {
vprint(FILES_MID, "%s: driver is %s\n",
devlink, drv);
}
}
list = newdev->ldev_driver_list;
if ((drv != NULL) && (list != NULL)) {
while (list) {
if (strcmp(list->driver_name,
drv) == 0) {
vprint(FILES_MID,
"driver %s match!\n", drv);
break;
}
list = list->next;
}
if (list == NULL) {
vprint(FILES_MID, "no driver match!\n");
free(devfs_path);
return;
}
}
free(devfs_path);
di_fini(node);
} else {
return;
}
vprint(FILES_MID, "changing permissions of %s\n", devlink);
if (stat(newdev->ldev_console, &sb) == -1) {
vprint(VERBOSE_MID, STAT_FAILED, newdev->ldev_console,
strerror(errno));
return;
}
resp = NULL;
rv = getpwuid_r(sb.st_uid, &pwd, pwd_buf, sizeof (pwd_buf), &resp);
if (rv || resp == NULL) {
rv = rv ? rv : EINVAL;
vprint(VERBOSE_MID, GID_FAILED, sb.st_uid,
strerror(rv));
return;
}
assert(&pwd == resp);
sb.st_gid = resp->pw_gid;
if (chmod(devlink, newdev->ldev_perms) == -1) {
vprint(VERBOSE_MID, CHMOD_FAILED, devlink,
strerror(errno));
return;
}
if (chown(devlink, sb.st_uid, sb.st_gid) == -1) {
vprint(VERBOSE_MID, CHOWN_FAILED, devlink,
strerror(errno));
}
}
static void
reset_node_permissions(di_node_t node, di_minor_t minor)
{
int spectype;
char phy_path[PATH_MAX + 1];
mode_t mode;
dev_t dev;
uid_t uid;
gid_t gid;
struct stat sb;
char *dev_path, *aminor = NULL;
if ((dev_path = di_devfs_path(node)) == NULL) {
err_print(DI_DEVFS_PATH_FAILED, strerror(errno));
devfsadm_exit(1);
}
(void) strcpy(lphy_path, dev_path);
di_devfs_path_free(dev_path);
(void) strcat(lphy_path, ":");
if (di_minor_type(minor) == DDM_ALIAS) {
char *driver;
aminor = di_minor_name(minor);
driver = di_driver_name(di_minor_devinfo(minor));
(void) strcat(lphy_path, driver);
} else
(void) strcat(lphy_path, di_minor_name(minor));
(void) strcpy(phy_path, devices_dir);
(void) strcat(phy_path, lphy_path);
lnode = node;
lminor = minor;
vprint(CHATTY_MID, "reset_node_permissions: phy_path=%s lphy_path=%s\n",
phy_path, lphy_path);
dev = di_minor_devt(minor);
spectype = di_minor_spectype(minor);
getattr(phy_path, aminor, spectype, dev, &mode, &uid, &gid);
if ((stat(phy_path, &sb) == -1) || (sb.st_rdev != dev)) {
vprint(VERBOSE_MID, NO_DEVFS_NODE, phy_path);
return;
}
if (sb.st_atime != 0) {
int i;
char *nt;
if ((devalloc_flag == 0) && (devalloc_is_on != 1))
return;
nt = di_minor_nodetype(minor);
if (nt == NULL)
return;
for (i = 0; devalloc_list[i]; i++) {
if (strcmp(nt, devalloc_list[i]) == 0)
break;
}
if (devalloc_list[i] == NULL)
return;
}
if (file_mods == FALSE) {
vprint(VERBOSE_MID, PERM_MSG, phy_path, uid, gid, mode);
return;
}
if ((devalloc_flag == DA_ON) ||
((devalloc_is_on == 1) && (devalloc_flag != DA_OFF))) {
mode = DEALLOC_MODE;
uid = DA_UID;
gid = DA_GID;
}
if ((devalloc_is_on == 1) || (devalloc_flag == DA_ON) ||
(sb.st_mode != mode)) {
if (chmod(phy_path, mode) == -1)
vprint(VERBOSE_MID, CHMOD_FAILED,
phy_path, strerror(errno));
}
if ((devalloc_is_on == 1) || (devalloc_flag == DA_ON) ||
(sb.st_uid != uid || sb.st_gid != gid)) {
if (chown(phy_path, uid, gid) == -1)
vprint(VERBOSE_MID, CHOWN_FAILED,
phy_path, strerror(errno));
}
vprint(VERBOSE_MID, PERM_MSG, phy_path, uid, gid, mode);
}
static void
devfsadm_rm_work(char *file, int recurse, int file_type)
{
char *fcn = "devfsadm_rm_work: ";
int linksize;
char contents[PATH_MAX + 1];
char nextfile[PATH_MAX + 1];
char newfile[PATH_MAX + 1];
char *ptr;
vprint(REMOVE_MID, "%s%s\n", fcn, file);
if (file_type != TYPE_LINK) {
return;
}
(void) strcpy(newfile, dev_dir);
(void) strcat(newfile, "/");
(void) strcat(newfile, file);
if ((recurse == TRUE) &&
((linksize = readlink(newfile, contents, PATH_MAX)) > 0)) {
contents[linksize] = '\0';
if (is_minor_node(contents, &ptr) != DEVFSADM_TRUE) {
if (strncmp(contents, DEV "/", strlen(DEV) + 1) == 0) {
devfsadm_rm_work(&contents[strlen(DEV) + 1],
TRUE, TYPE_LINK);
} else {
if ((ptr = strrchr(file, '/')) != NULL) {
*ptr = '\0';
(void) strcpy(nextfile, file);
*ptr = '/';
(void) strcat(nextfile, "/");
} else {
(void) strcpy(nextfile, "");
}
(void) strcat(nextfile, contents);
devfsadm_rm_work(nextfile, TRUE, TYPE_LINK);
}
}
}
vprint(VERBOSE_MID, DEVFSADM_UNLINK, newfile);
if (file_mods == TRUE) {
rm_link_from_cache(file);
s_unlink(newfile);
rm_parent_dir_if_empty(newfile);
invalidate_enumerate_cache();
(void) di_devlink_rm_link(devlink_cache, file);
}
}
void
devfsadm_rm_link(char *file)
{
devfsadm_rm_work(file, FALSE, TYPE_LINK);
}
void
devfsadm_rm_all(char *file)
{
devfsadm_rm_work(file, TRUE, TYPE_LINK);
}
static int
s_rmdir(char *path)
{
int i;
char *rpath, *dir;
const char *fcn = "s_rmdir";
vprint(REMOVE_MID, "%s: checking if %s is sticky\n", fcn, path);
rpath = path + strlen(dev_dir) + 1;
for (i = 0; (dir = sticky_dirs[i]) != NULL; i++) {
if (*rpath == *dir) {
if (strcmp(rpath, dir) == 0) {
vprint(REMOVE_MID, "%s: skipping sticky dir: "
"%s\n", fcn, path);
errno = EEXIST;
return (-1);
}
}
}
return (rmdir(path));
}
static void
rm_parent_dir_if_empty(char *pathname)
{
char *ptr, path[PATH_MAX + 1];
char *fcn = "rm_parent_dir_if_empty: ";
vprint(REMOVE_MID, "%schecking %s if empty\n", fcn, pathname);
(void) strcpy(path, pathname);
for (;;) {
if ((ptr = strrchr(path, '/')) == NULL) {
return;
}
*ptr = '\0';
if (finddev_emptydir(path)) {
if (s_rmdir(path) == 0) {
vprint(REMOVE_MID,
"%sremoving empty dir %s\n", fcn, path);
} else if (errno == EEXIST) {
vprint(REMOVE_MID,
"%sfailed to remove dir: %s\n", fcn, path);
return;
}
} else {
vprint(REMOVE_MID, "%sdir not empty: %s\n", fcn, path);
return;
}
}
}
void
devfsadm_rm_stale_links(char *dir_re, char *valid_link, di_node_t node,
di_minor_t minor)
{
link_t *link;
linkhead_t *head;
char phy_path[PATH_MAX + 1];
char *valid_link_contents;
char *dev_path;
char rmlink[PATH_MAX + 1];
if ((node == lnode) && (minor == lminor)) {
valid_link_contents = lphy_path;
} else {
if ((dev_path = di_devfs_path(node)) == NULL) {
err_print(DI_DEVFS_PATH_FAILED, strerror(errno));
devfsadm_exit(1);
}
(void) strcpy(phy_path, dev_path);
di_devfs_path_free(dev_path);
(void) strcat(phy_path, ":");
(void) strcat(phy_path, di_minor_name(minor));
valid_link_contents = phy_path;
}
if (linknew == FALSE) {
return;
}
head = get_cached_links(dir_re);
assert(head->nextlink == NULL);
for (link = head->link; link != NULL; link = head->nextlink) {
head->nextlink = link->next;
if ((strcmp(link->contents, valid_link_contents) == 0) &&
(strcmp(link->devlink, valid_link) != 0)) {
vprint(CHATTY_MID, "removing %s -> %s\n"
"valid link is: %s -> %s\n",
link->devlink, link->contents,
valid_link, valid_link_contents);
(void) snprintf(rmlink, sizeof (rmlink), "%s",
link->devlink);
devfsadm_rm_link(rmlink);
}
}
}
static linkhead_t *
get_cached_links(char *dir_re)
{
recurse_dev_t rd;
linkhead_t *linkhead;
int n;
vprint(BUILDCACHE_MID, "get_cached_links: %s\n", dir_re);
for (linkhead = headlinkhead; linkhead != NULL;
linkhead = linkhead->nexthead) {
if (strcmp(linkhead->dir_re, dir_re) == 0) {
return (linkhead);
}
}
linkhead = s_malloc(sizeof (linkhead_t));
linkhead->nexthead = headlinkhead;
headlinkhead = linkhead;
linkhead->dir_re = s_strdup(dir_re);
if ((n = regcomp(&(linkhead->dir_re_compiled), dir_re,
REG_EXTENDED)) != 0) {
err_print(REGCOMP_FAILED, dir_re, n);
}
linkhead->nextlink = NULL;
linkhead->link = NULL;
rd.fcn = build_devlink_list;
rd.data = (void *)linkhead;
vprint(BUILDCACHE_MID, "get_cached_links: calling recurse_dev_re\n");
if (dir_re[0] == '/') {
recurse_dev_re("/", &dir_re[1], &rd);
} else {
recurse_dev_re(dev_dir, dir_re, &rd);
}
return (linkhead);
}
static void
build_devlink_list(char *devlink, void *data)
{
char *fcn = "build_devlink_list: ";
char *ptr;
char *r_contents;
char *r_devlink;
char contents[PATH_MAX + 1];
char newlink[PATH_MAX + 1];
char stage_link[PATH_MAX + 1];
int linksize;
linkhead_t *linkhead = (linkhead_t *)data;
link_t *link;
int i = 0;
vprint(BUILDCACHE_MID, "%scheck_link: %s\n", fcn, devlink);
(void) strcpy(newlink, devlink);
do {
linksize = readlink(newlink, contents, PATH_MAX);
if (linksize <= 0) {
if (linksize < 0 && (i || errno != EINVAL))
err_print(READLINK_FAILED, "build_devlink_list",
newlink, strerror(errno));
return;
}
contents[linksize] = '\0';
i = 1;
if (is_minor_node(contents, &r_contents) == DEVFSADM_FALSE) {
if (strncmp(contents, DEV "/",
strlen(DEV) + strlen("/")) != 0) {
if ((ptr = strrchr(newlink, '/')) == NULL) {
vprint(REMOVE_MID, "%s%s -> %s invalid "
"link. missing '/'\n", fcn,
newlink, contents);
return;
}
*ptr = '\0';
(void) strcpy(stage_link, newlink);
*ptr = '/';
(void) strcat(stage_link, "/");
(void) strcat(stage_link, contents);
(void) strcpy(newlink, stage_link);
} else {
(void) strcpy(newlink, dev_dir);
(void) strcat(newlink, "/");
(void) strcat(newlink,
&contents[strlen(DEV) + strlen("/")]);
}
} else {
newlink[0] = '\0';
}
} while (newlink[0] != '\0');
if (strncmp(devlink, dev_dir, strlen(dev_dir)) != 0) {
vprint(BUILDCACHE_MID, "%sinvalid link: %s\n", fcn, devlink);
return;
}
r_devlink = devlink + strlen(dev_dir);
if (r_devlink[0] != '/')
return;
link = s_malloc(sizeof (link_t));
r_devlink += 1;
vprint(BUILDCACHE_MID, "%scaching link: %s\n", fcn, r_devlink);
link->devlink = s_strdup(r_devlink);
link->contents = s_strdup(r_contents);
link->next = linkhead->link;
linkhead->link = link;
}
static void
add_link_to_cache(char *devlink, char *physpath)
{
linkhead_t *linkhead;
link_t *link;
int added = 0;
if (file_mods == FALSE) {
return;
}
vprint(CACHE_MID, "add_link_to_cache: %s -> %s ",
devlink, physpath);
for (linkhead = headlinkhead; linkhead != NULL;
linkhead = linkhead->nexthead) {
if (regexec(&(linkhead->dir_re_compiled), devlink, 0, NULL, 0)
== 0) {
added++;
link = s_malloc(sizeof (link_t));
link->devlink = s_strdup(devlink);
link->contents = s_strdup(physpath);
link->next = linkhead->link;
linkhead->link = link;
}
}
vprint(CACHE_MID,
" %d %s\n", added, added == 0 ? "NOT ADDED" : "ADDED");
}
static void
rm_link_from_cache(char *devlink)
{
linkhead_t *linkhead;
link_t **linkp;
link_t *save;
vprint(CACHE_MID, "rm_link_from_cache enter: %s\n", devlink);
for (linkhead = headlinkhead; linkhead != NULL;
linkhead = linkhead->nexthead) {
if (regexec(&(linkhead->dir_re_compiled), devlink, 0, NULL, 0)
== 0) {
for (linkp = &(linkhead->link); *linkp != NULL; ) {
if ((strcmp((*linkp)->devlink, devlink) == 0)) {
save = *linkp;
*linkp = (*linkp)->next;
if (linkhead->nextlink == save)
linkhead->nextlink = *linkp;
free(save->devlink);
free(save->contents);
free(save);
vprint(CACHE_MID, " %s FREED FROM "
"CACHE\n", devlink);
} else {
linkp = &((*linkp)->next);
}
}
}
}
}
static void
rm_all_links_from_cache()
{
linkhead_t *linkhead;
linkhead_t *nextlinkhead;
link_t *link;
link_t *nextlink;
vprint(CACHE_MID, "rm_all_links_from_cache\n");
for (linkhead = headlinkhead; linkhead != NULL;
linkhead = nextlinkhead) {
nextlinkhead = linkhead->nexthead;
assert(linkhead->nextlink == NULL);
for (link = linkhead->link; link != NULL; link = nextlink) {
nextlink = link->next;
free(link->devlink);
free(link->contents);
free(link);
}
regfree(&(linkhead->dir_re_compiled));
free(linkhead->dir_re);
free(linkhead);
}
headlinkhead = NULL;
}
static void
devfs_instance_mod(void)
{
char *fcn = "devfs_instance_mod: ";
vprint(PATH2INST_MID, "%senter\n", fcn);
(void) mutex_lock(&count_lock);
inst_count++;
(void) cond_signal(&cv);
(void) mutex_unlock(&count_lock);
}
static void
instance_flush_thread(void)
{
int i;
int idle;
for (;;) {
(void) mutex_lock(&count_lock);
while (inst_count == 0) {
(void) cond_wait(&cv, &count_lock);
}
inst_count = 0;
vprint(PATH2INST_MID, "signaled to flush path_to_inst."
" Enter delay loop\n");
for (idle = 0, i = 0; i < MAX_DELAY; i++) {
(void) mutex_unlock(&count_lock);
(void) sleep(1);
(void) mutex_lock(&count_lock);
if (inst_count == 0) {
idle++;
if (idle > MAX_IDLE_DELAY) {
break;
}
} else {
inst_count = idle = 0;
}
}
(void) mutex_unlock(&count_lock);
flush_path_to_inst();
}
}
static int
do_inst_sync(char *filename, char *instfilename)
{
void (*sigsaved)(int);
int err = 0, flags = INST_SYNC_IF_REQUIRED;
struct stat sb;
if (stat(instfilename, &sb) == -1 && errno == ENOENT)
flags = INST_SYNC_ALWAYS;
vprint(INSTSYNC_MID, "do_inst_sync: about to flush %s\n", filename);
sigsaved = sigset(SIGSYS, SIG_IGN);
if (inst_sync(filename, flags) == -1)
err = errno;
(void) sigset(SIGSYS, sigsaved);
switch (err) {
case 0:
return (DEVFSADM_SUCCESS);
case EALREADY:
return (EALREADY);
case ENOSYS:
err_print(CANT_LOAD_SYSCALL);
break;
case EPERM:
err_print(SUPER_TO_SYNC);
break;
default:
err_print(INSTSYNC_FAILED, filename, strerror(err));
break;
}
return (DEVFSADM_FAILURE);
}
static void
flush_path_to_inst(void)
{
char *new_inst_file = NULL;
char *old_inst_file = NULL;
char *old_inst_file_npid = NULL;
FILE *inst_file_fp = NULL;
FILE *old_inst_file_fp = NULL;
struct stat sb;
int err = 0;
int c;
int inst_strlen;
vprint(PATH2INST_MID, "flush_path_to_inst: %s\n",
(flush_path_to_inst_enable == TRUE) ? "ENABLED" : "DISABLED");
if (flush_path_to_inst_enable == FALSE) {
return;
}
inst_strlen = strlen(inst_file);
new_inst_file = s_malloc(inst_strlen + PID_STR_LEN + 2);
old_inst_file = s_malloc(inst_strlen + PID_STR_LEN + 6);
old_inst_file_npid = s_malloc(inst_strlen +
sizeof (INSTANCE_FILE_SUFFIX));
(void) snprintf(new_inst_file, inst_strlen + PID_STR_LEN + 2,
"%s.%ld", inst_file, getpid());
if (stat(new_inst_file, &sb) == 0) {
s_unlink(new_inst_file);
}
err = do_inst_sync(new_inst_file, inst_file);
if (err != DEVFSADM_SUCCESS) {
goto out;
}
if ((inst_file_fp = fopen(inst_file, "r")) == NULL) {
if ((err = rename(new_inst_file, inst_file)) != 0)
err_print(RENAME_FAILED, inst_file, strerror(errno));
goto out;
}
(void) snprintf(old_inst_file, inst_strlen + PID_STR_LEN + 6,
"%s.old.%ld", inst_file, getpid());
if (stat(old_inst_file, &sb) == 0) {
s_unlink(old_inst_file);
}
if ((old_inst_file_fp = fopen(old_inst_file, "w")) == NULL) {
err_print(CANT_UPDATE, old_inst_file);
err = DEVFSADM_FAILURE;
goto out;
}
err = 0;
while ((c = getc(inst_file_fp)) != EOF) {
if ((err = putc(c, old_inst_file_fp)) == EOF) {
break;
}
}
if (fclose(old_inst_file_fp) == EOF || err == EOF) {
vprint(INFO_MID, CANT_UPDATE, old_inst_file);
err = DEVFSADM_FAILURE;
goto out;
}
(void) chmod(old_inst_file, 0444);
(void) snprintf(old_inst_file_npid,
inst_strlen + sizeof (INSTANCE_FILE_SUFFIX),
"%s%s", inst_file, INSTANCE_FILE_SUFFIX);
if ((err = rename(old_inst_file, old_inst_file_npid)) != 0) {
err_print(RENAME_FAILED, old_inst_file_npid,
strerror(errno));
} else if ((err = rename(new_inst_file, inst_file)) != 0) {
err_print(RENAME_FAILED, inst_file, strerror(errno));
}
out:
if (inst_file_fp != NULL) {
if (fclose(inst_file_fp) == EOF) {
err_print(FCLOSE_FAILED, inst_file, strerror(errno));
}
}
if (stat(new_inst_file, &sb) == 0) {
s_unlink(new_inst_file);
}
free(new_inst_file);
if (stat(old_inst_file, &sb) == 0) {
s_unlink(old_inst_file);
}
free(old_inst_file);
free(old_inst_file_npid);
if (err != 0 && err != EALREADY) {
err_print(FAILED_TO_UPDATE, inst_file);
}
}
void
detachfromtty()
{
(void) setsid();
if (DEVFSADM_DEBUG_ON == TRUE) {
return;
}
(void) close(0);
(void) close(1);
(void) close(2);
(void) open("/dev/null", O_RDWR, 0);
(void) dup(0);
(void) dup(0);
openlog(DEVFSADMD, LOG_PID, LOG_DAEMON);
(void) setlogmask(LOG_UPTO(LOG_INFO));
logflag = TRUE;
}
pid_t
enter_dev_lock()
{
struct flock lock;
int n;
pid_t pid;
pid_t last_owner_pid;
if (file_mods == FALSE) {
return (0);
}
(void) snprintf(dev_lockfile, sizeof (dev_lockfile),
"%s/%s", etc_dev_dir, DEV_LOCK_FILE);
vprint(LOCK_MID, "enter_dev_lock: lock file %s\n", dev_lockfile);
dev_lock_fd = open(dev_lockfile, O_CREAT|O_RDWR, 0644);
if (dev_lock_fd < 0) {
err_print(OPEN_FAILED, dev_lockfile, strerror(errno));
devfsadm_exit(1);
}
lock.l_type = F_WRLCK;
lock.l_whence = SEEK_SET;
lock.l_start = 0;
lock.l_len = 0;
if (fcntl(dev_lock_fd, F_SETLK, &lock) == -1) {
if ((errno == EACCES) || (errno == EAGAIN)) {
pid = 0;
n = read(dev_lock_fd, &pid, sizeof (pid_t));
vprint(LOCK_MID, "waiting for PID %d to complete\n",
(int)pid);
if (lseek(dev_lock_fd, 0, SEEK_SET) == (off_t)-1) {
err_print(LSEEK_FAILED, dev_lockfile,
strerror(errno));
devfsadm_exit(1);
}
(void) di_devlink_close(&devlink_cache, 0);
process_syseventq();
if (fcntl(dev_lock_fd, F_SETLKW, &lock) == -1) {
err_print(LOCK_FAILED, dev_lockfile,
strerror(errno));
devfsadm_exit(1);
}
}
}
hold_dev_lock = TRUE;
pid = 0;
n = read(dev_lock_fd, &pid, sizeof (pid_t));
if (n == sizeof (pid_t) && pid == getpid()) {
return (pid);
}
last_owner_pid = pid;
if (lseek(dev_lock_fd, 0, SEEK_SET) == (off_t)-1) {
err_print(LSEEK_FAILED, dev_lockfile, strerror(errno));
devfsadm_exit(1);
}
pid = getpid();
n = write(dev_lock_fd, &pid, sizeof (pid_t));
if (n != sizeof (pid_t)) {
err_print(WRITE_FAILED, dev_lockfile, strerror(errno));
devfsadm_exit(1);
}
return (last_owner_pid);
}
void
exit_dev_lock(int exiting)
{
struct flock unlock;
if (hold_dev_lock == FALSE) {
return;
}
vprint(LOCK_MID, "exit_dev_lock: lock file %s, exiting = %d\n",
dev_lockfile, exiting);
unlock.l_type = F_UNLCK;
unlock.l_whence = SEEK_SET;
unlock.l_start = 0;
unlock.l_len = 0;
if (fcntl(dev_lock_fd, F_SETLK, &unlock) == -1) {
err_print(UNLOCK_FAILED, dev_lockfile, strerror(errno));
}
hold_dev_lock = FALSE;
if (close(dev_lock_fd) == -1) {
err_print(CLOSE_FAILED, dev_lockfile, strerror(errno));
if (!exiting)
devfsadm_exit(1);
}
}
pid_t
enter_daemon_lock(void)
{
struct flock lock;
(void) snprintf(daemon_lockfile, sizeof (daemon_lockfile),
"%s/%s", etc_dev_dir, DAEMON_LOCK_FILE);
vprint(LOCK_MID, "enter_daemon_lock: lock file %s\n", daemon_lockfile);
daemon_lock_fd = open(daemon_lockfile, O_CREAT|O_RDWR, 0644);
if (daemon_lock_fd < 0) {
err_print(OPEN_FAILED, daemon_lockfile, strerror(errno));
devfsadm_exit(1);
}
lock.l_type = F_WRLCK;
lock.l_whence = SEEK_SET;
lock.l_start = 0;
lock.l_len = 0;
if (fcntl(daemon_lock_fd, F_SETLK, &lock) == -1) {
if (errno == EAGAIN || errno == EDEADLK) {
if (fcntl(daemon_lock_fd, F_GETLK, &lock) == -1) {
err_print(LOCK_FAILED, daemon_lockfile,
strerror(errno));
devfsadm_exit(1);
}
return (lock.l_pid);
}
}
hold_daemon_lock = TRUE;
return (getpid());
}
void
exit_daemon_lock(int exiting)
{
struct flock lock;
if (hold_daemon_lock == FALSE) {
return;
}
vprint(LOCK_MID, "exit_daemon_lock: lock file %s, exiting = %d\n",
daemon_lockfile, exiting);
lock.l_type = F_UNLCK;
lock.l_whence = SEEK_SET;
lock.l_start = 0;
lock.l_len = 0;
if (fcntl(daemon_lock_fd, F_SETLK, &lock) == -1) {
err_print(UNLOCK_FAILED, daemon_lockfile, strerror(errno));
}
if (close(daemon_lock_fd) == -1) {
err_print(CLOSE_FAILED, daemon_lockfile, strerror(errno));
if (!exiting)
devfsadm_exit(1);
}
}
static void
pre_and_post_cleanup(int flags)
{
remove_list_t *rm;
recurse_dev_t rd;
cleanup_data_t cleanup_data;
char *fcn = "pre_and_post_cleanup: ";
if (build_dev == FALSE)
return;
vprint(CHATTY_MID, "attempting %s-cleanup\n",
flags == RM_PRE ? "pre" : "post");
vprint(REMOVE_MID, "%sflags = %d\n", fcn, flags);
rd.fcn = matching_dev;
rd.data = (void *)&cleanup_data;
cleanup_data.flags = flags;
(void) mutex_lock(&nfp_mutex);
nfphash_create();
for (rm = remove_head; rm != NULL; rm = rm->next) {
if ((flags & rm->remove->flags) == flags) {
cleanup_data.rm = rm;
vprint(REMOVE_MID, "%scleanup: PRE or POST\n", fcn);
if (clean_ok(rm->remove) == DEVFSADM_SUCCESS) {
vprint(REMOVE_MID, "cleanup: cleanup OK\n");
recurse_dev_re(dev_dir,
rm->remove->dev_dirs_re, &rd);
}
}
}
nfphash_destroy();
(void) mutex_unlock(&nfp_mutex);
}
static int
clean_ok(devfsadm_remove_V1_t *remove)
{
int i;
if (single_drv == TRUE) {
return (DEVFSADM_FAILURE);
}
if (load_attach_drv == FALSE && strcmp(prog, DISKS) != 0) {
return (DEVFSADM_FAILURE);
}
if ((cleanup == FALSE) && ((remove->flags & RM_ALWAYS) == 0)) {
return (DEVFSADM_FAILURE);
}
if (num_classes == 0) {
return (DEVFSADM_SUCCESS);
}
for (i = 0; i < num_classes; i++) {
if (strcmp(remove->device_class, classes[i]) == 0) {
return (DEVFSADM_SUCCESS);
}
}
return (DEVFSADM_FAILURE);
}
void
hot_cleanup(char *node_path, char *minor_name, char *ev_subclass,
char *driver_name, int instance)
{
link_t *link;
linkhead_t *head;
remove_list_t *rm;
char *fcn = "hot_cleanup: ";
char path[PATH_MAX + 1];
int path_len;
char rmlink[PATH_MAX + 1];
nvlist_t *nvl = NULL;
int skip;
int ret;
if (ev_subclass != NULL)
nvl = build_event_attributes(EC_DEV_REMOVE, ev_subclass,
node_path, DI_NODE_NIL, driver_name, instance, minor_name);
(void) strcpy(path, node_path);
(void) strcat(path, ":");
(void) strcat(path, minor_name == NULL ? "" : minor_name);
path_len = strlen(path);
vprint(REMOVE_MID, "%spath=%s\n", fcn, path);
(void) mutex_lock(&nfp_mutex);
nfphash_create();
for (rm = remove_head; rm != NULL; rm = rm->next) {
if ((RM_HOT & rm->remove->flags) == RM_HOT) {
head = get_cached_links(rm->remove->dev_dirs_re);
assert(head->nextlink == NULL);
for (link = head->link;
link != NULL; link = head->nextlink) {
head->nextlink = link->next;
if (nfphash_lookup(link->devlink) != NULL)
continue;
if (minor_name)
skip = strcmp(link->contents, path);
else
skip = strncmp(link->contents, path,
path_len);
if (skip ||
(call_minor_init(rm->modptr) ==
DEVFSADM_FAILURE))
continue;
vprint(REMOVE_MID,
"%sremoving %s -> %s\n", fcn,
link->devlink, link->contents);
(void) snprintf(rmlink, sizeof (rmlink),
"%s", link->devlink);
if (rm->remove->flags & RM_NOINTERPOSE) {
(void)
(rm->remove->callback_fcn)(rmlink);
} else {
ret =
(rm->remove->callback_fcn)(rmlink);
if (ret == DEVFSADM_TERMINATE)
nfphash_insert(rmlink);
}
}
}
}
nfphash_destroy();
(void) mutex_unlock(&nfp_mutex);
if (system_labeled) {
int devtype = 0;
if (strstr(path, DA_SOUND_NAME))
devtype = DA_AUDIO;
else if (strstr(path, "storage"))
devtype = DA_RMDISK;
else if (strstr(path, "disk"))
devtype = DA_RMDISK;
else if (strstr(path, "floppy"))
devtype = DA_RMDISK;
else
goto out;
(void) _update_devalloc_db(&devlist, devtype, DA_REMOVE,
node_path, root_dir);
}
out:
if (nvl) {
log_event(EC_DEV_REMOVE, ev_subclass, nvl);
free(nvl);
}
}
static void
recurse_dev_re(char *current_dir, char *path_re, recurse_dev_t *rd)
{
regex_t re1;
char *slash;
char new_path[PATH_MAX + 1];
char *anchored_path_re;
size_t len;
finddevhdl_t fhandle;
const char *fp;
vprint(RECURSEDEV_MID, "recurse_dev_re: curr = %s path=%s\n",
current_dir, path_re);
if (finddev_readdir(current_dir, &fhandle) != 0)
return;
len = strlen(path_re);
if ((slash = strchr(path_re, '/')) != NULL) {
len = (slash - path_re);
}
anchored_path_re = s_malloc(len + 3);
(void) sprintf(anchored_path_re, "^%.*s$", len, path_re);
if (regcomp(&re1, anchored_path_re, REG_EXTENDED) != 0) {
free(anchored_path_re);
goto out;
}
free(anchored_path_re);
while ((fp = finddev_next(fhandle)) != NULL) {
if (regexec(&re1, fp, 0, NULL, 0) == 0) {
(void) strcpy(new_path, current_dir);
(void) strcat(new_path, "/");
(void) strcat(new_path, fp);
vprint(RECURSEDEV_MID, "recurse_dev_re: match, new "
"path = %s\n", new_path);
if (slash != NULL) {
recurse_dev_re(new_path, slash + 1, rd);
} else {
vprint(RECURSEDEV_MID,
"recurse_dev_re: calling fcn\n");
(*(rd->fcn))(new_path, rd->data);
}
}
}
regfree(&re1);
out:
finddev_close(fhandle);
}
static void
matching_dev(char *devpath, void *data)
{
cleanup_data_t *cleanup_data = data;
int norm_len = strlen(dev_dir) + strlen("/");
int ret;
char *fcn = "matching_dev: ";
vprint(RECURSEDEV_MID, "%sexamining devpath = '%s'\n", fcn,
devpath);
if (nfphash_lookup(devpath + norm_len) != NULL)
return;
if (resolve_link(devpath, NULL, NULL, NULL, 1) == TRUE) {
if (call_minor_init(cleanup_data->rm->modptr) ==
DEVFSADM_FAILURE) {
return;
}
devpath += norm_len;
vprint(RECURSEDEV_MID, "%scalling callback %s\n", fcn, devpath);
if (cleanup_data->rm->remove->flags & RM_NOINTERPOSE)
(void)
(cleanup_data->rm->remove->callback_fcn)(devpath);
else {
ret =
(cleanup_data->rm->remove->callback_fcn)(devpath);
if (ret == DEVFSADM_TERMINATE) {
nfphash_insert(devpath);
}
}
}
}
int
devfsadm_read_link(di_node_t anynode, char *link, char **devfs_path)
{
char devlink[PATH_MAX];
char *path;
*devfs_path = NULL;
(void) strcpy(devlink, dev_dir);
(void) strcat(devlink, "/");
(void) strcat(devlink, link);
path = NULL;
(void) resolve_link(devlink, NULL, NULL, &path, 0);
if (path != NULL) {
*devfs_path = di_alias2curr(anynode, path);
free(path);
}
return (*devfs_path ? DEVFSADM_SUCCESS : DEVFSADM_FAILURE);
}
int
devfsadm_link_valid(di_node_t anynode, char *link)
{
struct stat sb;
char devlink[PATH_MAX + 1], *contents, *raw_contents;
int rv, type;
int instance = 0;
(void) strcpy(devlink, dev_dir);
(void) strcat(devlink, "/");
(void) strcat(devlink, link);
if (!device_exists(devlink) || lstat(devlink, &sb) != 0) {
return (DEVFSADM_FALSE);
}
raw_contents = NULL;
type = 0;
if (resolve_link(devlink, &raw_contents, &type, NULL, 1) == TRUE) {
rv = DEVFSADM_FALSE;
} else {
rv = DEVFSADM_TRUE;
}
contents = raw_contents;
if (type == DI_PRIMARY_LINK) {
contents = di_alias2curr(anynode, raw_contents);
free(raw_contents);
}
(void) di_devlink_add_link(devlink_cache, link, contents, type);
if (system_labeled && (rv == DEVFSADM_TRUE) &&
strstr(devlink, DA_AUDIO_NAME) && contents) {
(void) sscanf(contents, "%*[a-z]%d", &instance);
(void) da_add_list(&devlist, devlink, instance,
DA_ADD|DA_AUDIO);
_update_devalloc_db(&devlist, 0, DA_ADD, NULL, root_dir);
}
free(contents);
return (rv);
}
static int
resolve_link(char *devpath, char **content_p, int *type_p, char **devfs_path,
int dangle)
{
char contents[PATH_MAX + 1];
char stage_link[PATH_MAX + 1];
char *fcn = "resolve_link: ";
char *ptr;
int linksize;
int rv = TRUE;
struct stat sb;
linksize = readlink(devpath, contents, PATH_MAX);
if (linksize <= 0) {
return (FALSE);
} else {
contents[linksize] = '\0';
}
vprint(REMOVE_MID, "%s %s -> %s\n", fcn, devpath, contents);
if (content_p) {
*content_p = s_strdup(contents);
}
if (is_minor_node(contents, &ptr) == DEVFSADM_FALSE) {
if (type_p) {
*type_p = DI_SECONDARY_LINK;
}
if (strncmp(contents, DEV "/", strlen(DEV) + 1) == 0) {
(void) strcpy(stage_link, dev_dir);
(void) strcat(stage_link, "/");
(void) strcpy(stage_link,
&contents[strlen(DEV) + strlen("/")]);
} else {
if ((ptr = strrchr(devpath, '/')) == NULL) {
vprint(REMOVE_MID, "%s%s -> %s invalid link. "
"missing '/'\n", fcn, devpath, contents);
return (TRUE);
}
*ptr = '\0';
(void) strcpy(stage_link, devpath);
*ptr = '/';
(void) strcat(stage_link, "/");
(void) strcat(stage_link, contents);
}
return (resolve_link(stage_link, NULL, NULL, devfs_path,
dangle));
}
if (type_p) {
*type_p = DI_PRIMARY_LINK;
}
if (devfs_path)
*devfs_path = s_strdup(ptr);
rv = FALSE;
if (dangle)
rv = (stat(ptr - strlen(DEVICES), &sb) == -1);
vprint(REMOVE_MID, "%slink=%s, returning %s\n", fcn,
devpath, ((rv == TRUE) ? "TRUE" : "FALSE"));
return (rv);
}
static char *
alloc_cmp_str(const char *path, devfsadm_enumerate_t *dep)
{
uint_t match;
char *np, *ap, *mp;
char *cmp_str = NULL;
char at[] = "@";
char *fcn = "alloc_cmp_str";
np = ap = mp = NULL;
match = (dep->flags & MATCH_MASK);
vprint(ENUM_MID, "%s: enumeration match type: 0x%x"
" path: %s\n", fcn, match, path);
if (match == MATCH_CALLBACK) {
if (dep->sel_fcn == NULL) {
vprint(ENUM_MID, "%s: invalid enumerate"
" callback: path: %s\n", fcn, path);
return (NULL);
}
cmp_str = dep->sel_fcn(path, dep->cb_arg);
return (cmp_str);
}
cmp_str = s_strdup(path);
if (match == MATCH_ALL) {
return (cmp_str);
}
if ((mp = strrchr(cmp_str, ':')) == NULL) {
vprint(ENUM_MID, "%s: invalid path: %s\n",
fcn, path);
goto err;
}
if (match == MATCH_MINOR) {
if (get_component(mp + 1, dep->match_arg) == NULL) {
vprint(ENUM_MID, "%s: invalid minor component:"
" path: %s\n", fcn, path);
goto err;
}
return (cmp_str);
}
if ((np = strrchr(cmp_str, '/')) == NULL) {
vprint(ENUM_MID, "%s: invalid path: %s\n", fcn, path);
goto err;
}
if (match == MATCH_PARENT) {
if (strcmp(cmp_str, "/") == 0) {
vprint(ENUM_MID, "%s: invalid path: %s\n",
fcn, path);
goto err;
}
if (np == cmp_str) {
*(np + 1) = '\0';
} else {
*np = '\0';
}
return (cmp_str);
}
ap = strchr(np+1, '@');
*mp = '\0';
if (match == MATCH_NODE) {
if (ap)
*ap = '\0';
return (cmp_str);
} else if (match == MATCH_ADDR) {
if (ap == NULL) {
ap = at;
}
if (get_component(ap + 1, dep->match_arg) == NULL) {
vprint(ENUM_MID, "%s: invalid leaf addr. component:"
" path: %s\n", fcn, path);
goto err;
}
return (cmp_str);
}
vprint(ENUM_MID, "%s: invalid enumeration flags: 0x%x"
" path: %s\n", fcn, dep->flags, path);
err:
free(cmp_str);
return (NULL);
}
static char *
get_component(char *str, const char *comp_str)
{
long comp;
char *cp;
if (str == NULL) {
return (NULL);
}
if (comp_str == NULL) {
return (str);
}
errno = 0;
comp = strtol(comp_str, &cp, 10);
if (errno != 0 || *cp != '\0' || comp < 0) {
return (NULL);
}
if (comp == 0)
return (str);
for (cp = str; ; cp++) {
if (*cp == ',' || *cp == '\0')
comp--;
if (*cp == '\0' || comp <= 0) {
break;
}
}
if (comp == 0) {
*cp = '\0';
} else {
str = NULL;
}
return (str);
}
int
devfsadm_enumerate_int(char *devfs_path, int index, char **buf,
devfsadm_enumerate_t rules[], int nrules)
{
return (find_enum_id(rules, nrules,
devfs_path, index, "0", INTEGER, buf, 0));
}
int
ctrl_enumerate_int(char *devfs_path, int index, char **buf,
devfsadm_enumerate_t rules[], int nrules, int multiple,
boolean_t scsi_vhci)
{
return (find_enum_id(rules, nrules,
devfs_path, index, scsi_vhci ? "0" : "1", INTEGER, buf, multiple));
}
static int
devfsadm_enumerate_int_start(char *devfs_path, int index, char **buf,
devfsadm_enumerate_t rules[], int nrules, char *start)
{
return (find_enum_id(rules, nrules,
devfs_path, index, start, INTEGER, buf, 0));
}
int
devfsadm_enumerate_char(char *devfs_path, int index, char **buf,
devfsadm_enumerate_t rules[], int nrules)
{
return (find_enum_id(rules, nrules,
devfs_path, index, "a", LETTER, buf, 0));
}
int
devfsadm_enumerate_char_start(char *devfs_path, int index, char **buf,
devfsadm_enumerate_t rules[], int nrules, char *start)
{
return (find_enum_id(rules, nrules,
devfs_path, index, start, LETTER, buf, 0));
}
static int
find_enum_id(devfsadm_enumerate_t rules[], int nrules,
char *devfs_path, int index, char *min, int type, char **buf,
int multiple)
{
numeral_t *matchnp;
numeral_t *numeral;
int matchcount = 0;
char *cmp_str;
char *fcn = "find_enum_id";
numeral_set_t *set;
if (rules == NULL) {
vprint(ENUM_MID, "%s: no rules. path: %s\n",
fcn, devfs_path ? devfs_path : "<NULL path>");
return (DEVFSADM_FAILURE);
}
if (devfs_path == NULL) {
vprint(ENUM_MID, "%s: NULL path\n", fcn);
return (DEVFSADM_FAILURE);
}
if (nrules <= 0 || index < 0 || index >= nrules || buf == NULL) {
vprint(ENUM_MID, "%s: invalid arguments. path: %s\n",
fcn, devfs_path);
return (DEVFSADM_FAILURE);
}
*buf = NULL;
cmp_str = alloc_cmp_str(devfs_path, &rules[index]);
if (cmp_str == NULL) {
return (DEVFSADM_FAILURE);
}
if ((set = get_enum_cache(rules, nrules)) == NULL) {
free(cmp_str);
return (DEVFSADM_FAILURE);
}
assert(nrules == set->re_count);
matchcount = lookup_enum_cache(set, cmp_str, rules, index,
&matchnp);
if (matchcount < 0 || matchcount > 1) {
free(cmp_str);
if (multiple && matchcount > 1)
return (DEVFSADM_MULTIPLE);
else
return (DEVFSADM_FAILURE);
}
if (matchcount == 1) {
vprint(ENUM_MID, "%s: 1 match w/ ID: %s\n", fcn, matchnp->id);
assert(matchnp->flags == 0);
*buf = s_strdup(matchnp->id);
free(cmp_str);
return (DEVFSADM_SUCCESS);
}
numeral = s_malloc(sizeof (numeral_t));
numeral->id = new_id(set->headnumeral, type, min);
numeral->full_path = s_strdup(devfs_path);
numeral->rule_index = index;
numeral->cmp_str = cmp_str;
cmp_str = NULL;
numeral->flags = 0;
vprint(RSRV_MID, "%s: alloc new_id: %s numeral flags = %d\n",
fcn, numeral->id, numeral->flags);
numeral->next = set->headnumeral;
set->headnumeral = numeral;
*buf = s_strdup(numeral->id);
return (DEVFSADM_SUCCESS);
}
static int
lookup_enum_cache(numeral_set_t *set, char *cmp_str,
devfsadm_enumerate_t rules[], int index, numeral_t **matchnpp)
{
int matchcount = 0, rv = -1;
int uncached;
numeral_t *np;
char *fcn = "lookup_enum_cache";
char *cp;
*matchnpp = NULL;
assert(index < set->re_count);
if (cmp_str == NULL) {
return (-1);
}
uncached = 0;
if ((rules[index].flags & MATCH_UNCACHED) == MATCH_UNCACHED) {
uncached = 1;
}
for (np = set->headnumeral; np != NULL; np = np->next) {
if (np->flags & NUMERAL_RESERVED) {
vprint(RSRV_MID, "lookup_enum_cache: "
"Cannot Match with reserved ID (%s), "
"skipping\n", np->id);
assert(np->flags == NUMERAL_RESERVED);
continue;
} else {
vprint(RSRV_MID, "lookup_enum_cache: "
"Attempting match with numeral ID: %s"
" numeral flags = %d\n", np->id, np->flags);
assert(np->flags == 0);
}
if (np->cmp_str == NULL) {
vprint(ENUM_MID, "%s: invalid entry in enumerate"
" cache. path: %s\n", fcn, np->full_path);
return (-1);
}
if (uncached) {
vprint(CHATTY_MID, "%s: bypassing enumerate cache."
" path: %s\n", fcn, cmp_str);
cp = alloc_cmp_str(np->full_path,
&rules[np->rule_index]);
if (cp == NULL)
return (-1);
rv = strcmp(cmp_str, cp);
free(cp);
} else {
rv = strcmp(cmp_str, np->cmp_str);
}
if (rv == 0) {
if (matchcount++ != 0) {
break;
}
*matchnpp = np;
}
}
return (matchcount);
}
#ifdef DEBUG
static void
dump_enum_cache(numeral_set_t *setp)
{
int i;
numeral_t *np;
char *fcn = "dump_enum_cache";
vprint(ENUM_MID, "%s: re_count = %d\n", fcn, setp->re_count);
for (i = 0; i < setp->re_count; i++) {
vprint(ENUM_MID, "%s: re[%d] = %s\n", fcn, i, setp->re[i]);
}
for (np = setp->headnumeral; np != NULL; np = np->next) {
vprint(ENUM_MID, "%s: id: %s\n", fcn, np->id);
vprint(ENUM_MID, "%s: full_path: %s\n", fcn, np->full_path);
vprint(ENUM_MID, "%s: rule_index: %d\n", fcn, np->rule_index);
vprint(ENUM_MID, "%s: cmp_str: %s\n", fcn, np->cmp_str);
vprint(ENUM_MID, "%s: flags: %d\n", fcn, np->flags);
}
}
#endif
static numeral_set_t *
get_enum_cache(devfsadm_enumerate_t rules[], int nrules)
{
numeral_set_t *setp;
int i;
int ret;
char *path_left;
enumerate_file_t *entry;
char *fcn = "get_enum_cache";
for (setp = head_numeral_set; setp != NULL; setp = setp->next) {
if (nrules != setp->re_count) {
continue;
}
for (i = 0; i < nrules; i++) {
if (strcmp(setp->re[i], rules[i].re) != 0) {
break;
}
}
if (i == nrules) {
return (setp);
}
}
for (i = 0; i < nrules; i++) {
if ((rules[i].flags & MATCH_UNCACHED) == MATCH_UNCACHED) {
vprint(ENUM_MID, "%s: invalid enumeration flags: "
"0x%x\n", fcn, rules[i].flags);
return (NULL);
}
}
setp = s_malloc(sizeof (numeral_set_t));
setp->re = s_malloc(sizeof (char *) * nrules);
for (i = 0; i < nrules; i++) {
setp->re[i] = s_strdup(rules[i].re);
}
setp->re_count = nrules;
setp->headnumeral = NULL;
setp->next = head_numeral_set;
head_numeral_set = setp;
for (entry = enumerate_reserved; entry; entry = entry->er_next) {
vprint(RSRV_MID, "parsing rstring: %s\n", entry->er_file);
for (i = 0; i < nrules; i++) {
path_left = s_strdup(setp->re[i]);
vprint(RSRV_MID, "parsing rule RE: %s\n", path_left);
ret = enumerate_parse(entry->er_file, path_left,
setp, rules, i);
free(path_left);
if (ret == 1) {
vprint(RSRV_MID, "found rsv ID: rstring: %s "
"rule RE: %s\n", entry->er_file, path_left);
break;
}
}
}
for (i = 0; i < nrules; i++) {
path_left = s_strdup(setp->re[i]);
enumerate_recurse(dev_dir, path_left, setp, rules, i);
free(path_left);
}
#ifdef DEBUG
dump_enum_cache(setp);
#endif
return (setp);
}
int
get_stat_info(char *namebuf, struct stat *sb)
{
char *cp;
finddevhdl_t fhandle;
const char *fp;
if (lstat(namebuf, sb) < 0) {
(void) err_print(LSTAT_FAILED, namebuf, strerror(errno));
return (DEVFSADM_FAILURE);
}
if ((sb->st_mode & S_IFMT) == S_IFLNK) {
return (DEVFSADM_SUCCESS);
}
if ((sb->st_mode & S_IFMT) == S_IFDIR) {
if (finddev_readdir(namebuf, &fhandle) != 0) {
return (DEVFSADM_FAILURE);
}
while ((fp = finddev_next(fhandle)) != NULL) {
cp = namebuf + strlen(namebuf);
if ((strlcat(namebuf, "/", PATH_MAX) >= PATH_MAX) ||
(strlcat(namebuf, fp, PATH_MAX) >= PATH_MAX)) {
*cp = '\0';
finddev_close(fhandle);
return (DEVFSADM_FAILURE);
}
if (get_stat_info(namebuf, sb) == DEVFSADM_SUCCESS) {
finddev_close(fhandle);
return (DEVFSADM_SUCCESS);
}
*cp = '\0';
}
finddev_close(fhandle);
}
return (DEVFSADM_FAILURE);
}
char *
new_id(numeral_t *numeral, int type, char *min)
{
int imin;
temp_t *temp;
temp_t *ptr;
temp_t **previous;
temp_t *head = NULL;
char *retval;
static char tempbuff[8];
numeral_t *np;
if (type == LETTER) {
char letter[26], i;
if (numeral == NULL) {
return (s_strdup(min));
}
for (i = 0; i < 26; i++) {
letter[i] = 0;
}
for (np = numeral; np != NULL; np = np->next) {
assert(np->flags == 0 ||
np->flags == NUMERAL_RESERVED);
letter[*np->id - 'a']++;
}
imin = *min - 'a';
for (i = imin; i < 26; i++) {
if (letter[i] == 0) {
retval = s_malloc(2);
retval[0] = 'a' + i;
retval[1] = '\0';
return (retval);
}
}
return (s_strdup(""));
}
if (type == INTEGER) {
if (numeral == NULL) {
return (s_strdup(min));
}
imin = atoi(min);
for (np = numeral; np != NULL; np = np->next) {
assert(np->flags == 0 ||
np->flags == NUMERAL_RESERVED);
temp = s_malloc(sizeof (temp_t));
temp->integer = atoi(np->id);
temp->next = NULL;
previous = &head;
for (ptr = head; ptr != NULL; ptr = ptr->next) {
if (temp->integer < ptr->integer) {
temp->next = ptr;
*previous = temp;
break;
}
previous = &(ptr->next);
}
if (ptr == NULL) {
*previous = temp;
}
}
for (ptr = head; ptr != NULL; ptr = ptr->next) {
if (imin == ptr->integer) {
imin++;
} else {
if (imin < ptr->integer) {
break;
}
}
}
for (ptr = head; ptr != NULL; ) {
temp = ptr;
ptr = ptr->next;
free(temp);
}
(void) sprintf(tempbuff, "%d", imin);
return (s_strdup(tempbuff));
}
return (s_strdup(""));
}
static int
enumerate_parse(char *rsvstr, char *path_left, numeral_set_t *setp,
devfsadm_enumerate_t rules[], int index)
{
char *slash1 = NULL;
char *slash2 = NULL;
char *numeral_id;
char *path_left_save;
char *rsvstr_save;
int ret = 0;
static int warned = 0;
rsvstr_save = rsvstr;
path_left_save = path_left;
if (rsvstr == NULL || rsvstr[0] == '\0' || rsvstr[0] == '/') {
if (!warned) {
err_print("invalid reserved filepath: %s\n",
rsvstr ? rsvstr : "<NULL>");
warned = 1;
}
return (0);
}
vprint(RSRV_MID, "processing rule: %s, rstring: %s\n",
path_left, rsvstr);
for (;;) {
while (*rsvstr == '/') {
rsvstr++;
}
while (*path_left == '/') {
path_left++;
}
if (slash1 = strchr(path_left, '/')) {
*slash1 = '\0';
}
if (slash2 = strchr(rsvstr, '/')) {
*slash2 = '\0';
}
if ((slash1 != NULL) ^ (slash2 != NULL)) {
ret = 0;
vprint(RSRV_MID, "mismatch in # of path components\n");
goto out;
}
numeral_id = NULL;
if (match_path_component(path_left, rsvstr, &numeral_id,
slash1 ? 0 : rules[index].subexp)) {
if (slash1 == NULL) {
vprint(RSRV_MID, "match and last component\n");
create_reserved_numeral(setp, numeral_id);
if (numeral_id != NULL) {
free(numeral_id);
}
ret = 1;
goto out;
} else {
*slash1 = '/';
*slash2 = '/';
path_left = slash1 + 1;
rsvstr = slash2 + 1;
vprint(RSRV_MID,
"match and NOT last component\n");
continue;
}
} else {
ret = 0;
vprint(RSRV_MID, "No match: rule RE = %s, "
"rstring = %s\n", path_left, rsvstr);
goto out;
}
}
out:
if (slash1)
*slash1 = '/';
if (slash2)
*slash2 = '/';
if (ret == 1) {
vprint(RSRV_MID, "match: rule RE: %s, rstring: %s\n",
path_left_save, rsvstr_save);
} else {
vprint(RSRV_MID, "NO match: rule RE: %s, rstring: %s\n",
path_left_save, rsvstr_save);
}
return (ret);
}
static void
enumerate_recurse(char *current_dir, char *path_left, numeral_set_t *setp,
devfsadm_enumerate_t rules[], int index)
{
char *slash;
char *new_path;
char *numeral_id;
finddevhdl_t fhandle;
const char *fp;
if (finddev_readdir(current_dir, &fhandle) != 0) {
return;
}
while (*path_left == '/') {
path_left++;
}
if (slash = strchr(path_left, '/')) {
*slash = '\0';
}
while ((fp = finddev_next(fhandle)) != NULL) {
numeral_id = NULL;
if (match_path_component(path_left, (char *)fp, &numeral_id,
slash ? 0 : rules[index].subexp)) {
new_path = s_malloc(strlen(current_dir) +
strlen(fp) + 2);
(void) strcpy(new_path, current_dir);
(void) strcat(new_path, "/");
(void) strcat(new_path, fp);
if (slash != NULL) {
enumerate_recurse(new_path, slash + 1,
setp, rules, index);
} else {
create_cached_numeral(new_path, setp,
numeral_id, rules, index);
if (numeral_id != NULL) {
free(numeral_id);
}
}
free(new_path);
}
}
if (slash != NULL) {
*slash = '/';
}
finddev_close(fhandle);
}
static int
match_path_component(char *file_re, char *file, char **id, int subexp)
{
regex_t re1;
int match = 0;
int nelements;
regmatch_t *pmatch;
if (subexp != 0) {
nelements = subexp + 1;
pmatch =
(regmatch_t *)s_malloc(sizeof (regmatch_t) * nelements);
} else {
pmatch = NULL;
nelements = 0;
}
if (regcomp(&re1, file_re, REG_EXTENDED) != 0) {
if (pmatch != NULL) {
free(pmatch);
}
return (0);
}
if (regexec(&re1, file, nelements, pmatch, 0) == 0) {
match = 1;
}
if ((match != 0) && (subexp != 0)) {
int size = pmatch[subexp].rm_eo - pmatch[subexp].rm_so;
*id = s_malloc(size + 1);
(void) strncpy(*id, &file[pmatch[subexp].rm_so], size);
(*id)[size] = '\0';
}
if (pmatch != NULL) {
free(pmatch);
}
regfree(&re1);
return (match);
}
static void
create_reserved_numeral(numeral_set_t *setp, char *numeral_id)
{
numeral_t *np;
vprint(RSRV_MID, "Attempting to create reserved numeral: %s\n",
numeral_id);
for (np = setp->headnumeral; np != NULL; np = np->next) {
if (strcmp(numeral_id, np->id) == 0) {
vprint(RSRV_MID, "ID: %s, already reserved\n", np->id);
assert(np->flags == NUMERAL_RESERVED);
return;
} else {
assert(np->flags == 0 ||
np->flags == NUMERAL_RESERVED);
}
}
np = s_malloc(sizeof (numeral_t));
np->id = s_strdup(numeral_id);
np->full_path = NULL;
np->rule_index = 0;
np->cmp_str = NULL;
np->flags = NUMERAL_RESERVED;
np->next = setp->headnumeral;
setp->headnumeral = np;
vprint(RSRV_MID, "Reserved numeral ID: %s\n", np->id);
}
static void
create_cached_numeral(char *path, numeral_set_t *setp, char *numeral_id,
devfsadm_enumerate_t rules[], int index)
{
char linkbuf[PATH_MAX + 1];
char lpath[PATH_MAX + 1];
char *linkptr, *cmp_str;
numeral_t *np;
int linksize;
struct stat sb;
char *contents;
const char *fcn = "create_cached_numeral";
assert(index >= 0 && index < setp->re_count);
assert(strcmp(rules[index].re, setp->re[index]) == 0);
for (np = setp->headnumeral; np != NULL; np = np->next) {
assert(np->flags == 0 || np->flags == NUMERAL_RESERVED);
if (strcmp(numeral_id, np->id) == 0) {
if (np->flags == NUMERAL_RESERVED) {
vprint(RSRV_MID, "ID derived from /dev link is"
" reserved: %s\n", np->id);
} else {
vprint(RSRV_MID, "ID derived from /dev link is"
" NOT reserved: %s\n", np->id);
}
return;
}
}
(void) strcpy(lpath, path);
if (get_stat_info(lpath, &sb) == DEVFSADM_FAILURE) {
return;
}
linksize = readlink(lpath, linkbuf, PATH_MAX);
if (linksize <= 0) {
err_print(READLINK_FAILED, fcn, lpath, strerror(errno));
return;
}
linkbuf[linksize] = '\0';
contents = di_alias2curr(devi_root_node, linkbuf);
(void) is_minor_node(contents, &linkptr);
cmp_str = alloc_cmp_str(linkptr, &rules[index]);
if (cmp_str == NULL) {
free(contents);
return;
}
np = s_malloc(sizeof (numeral_t));
np->id = s_strdup(numeral_id);
np->full_path = s_strdup(linkptr);
np->rule_index = index;
np->cmp_str = cmp_str;
np->flags = 0;
np->next = setp->headnumeral;
setp->headnumeral = np;
free(contents);
}
void
invalidate_enumerate_cache(void)
{
numeral_set_t *setp;
numeral_set_t *savedsetp;
numeral_t *savednumset;
numeral_t *numset;
int i;
for (setp = head_numeral_set; setp != NULL; ) {
savedsetp = setp;
setp = setp->next;
for (i = 0; i < savedsetp->re_count; i++) {
free(savedsetp->re[i]);
}
free(savedsetp->re);
for (numset = savedsetp->headnumeral; numset != NULL; ) {
savednumset = numset;
numset = numset->next;
assert(savednumset->rule_index < savedsetp->re_count);
free(savednumset->id);
free(savednumset->full_path);
free(savednumset->cmp_str);
free(savednumset);
}
free(savedsetp);
}
head_numeral_set = NULL;
}
int
devfsadm_copy(void)
{
char filename[PATH_MAX + 1];
(void) snprintf(filename, sizeof (filename), "%s%s", root_dir,
NAME_TO_MAJOR);
if (load_n2m_table(filename) == DEVFSADM_FAILURE) {
return (DEVFSADM_FAILURE);
}
(void) nftw(DEV, devfsadm_copy_file, 20, FTW_PHYS);
return (DEVFSADM_SUCCESS);
}
static int
devfsadm_copy_file(const char *file, const struct stat *stat,
int flags, struct FTW *ftw)
{
struct stat sp;
dev_t newdev;
char newfile[PATH_MAX + 1];
char linkcontents[PATH_MAX + 1];
int bytes;
const char *fcn = "devfsadm_copy_file";
(void) strcpy(newfile, root_dir);
(void) strcat(newfile, "/");
(void) strcat(newfile, file);
if (lstat(newfile, &sp) == 0) {
return (DEVFSADM_SUCCESS);
}
if (((stat->st_mode & S_IFMT) == S_IFBLK) ||
((stat->st_mode & S_IFMT) == S_IFCHR)) {
if (translate_major(stat->st_rdev, &newdev) ==
DEVFSADM_FAILURE) {
return (DEVFSADM_SUCCESS);
}
if (mknod(newfile, stat->st_mode, newdev) == -1) {
err_print(MKNOD_FAILED, newfile, strerror(errno));
return (DEVFSADM_SUCCESS);
}
} else if ((stat->st_mode & S_IFMT) == S_IFDIR) {
if (mknod(newfile, stat->st_mode, 0) == -1) {
err_print(MKNOD_FAILED, newfile, strerror(errno));
return (DEVFSADM_SUCCESS);
}
} else if ((stat->st_mode & S_IFMT) == S_IFLNK) {
if ((bytes = readlink(file, linkcontents, PATH_MAX)) == -1) {
err_print(READLINK_FAILED, fcn, file, strerror(errno));
return (DEVFSADM_SUCCESS);
}
linkcontents[bytes] = '\0';
if (symlink(linkcontents, newfile) == -1) {
err_print(SYMLINK_FAILED, newfile, newfile,
strerror(errno));
return (DEVFSADM_SUCCESS);
}
}
(void) lchown(newfile, stat->st_uid, stat->st_gid);
return (DEVFSADM_SUCCESS);
}
static int
translate_major(dev_t old_dev, dev_t *new_dev)
{
major_t oldmajor;
major_t newmajor;
minor_t oldminor;
minor_t newminor;
char cdriver[FILENAME_MAX + 1];
char driver[FILENAME_MAX + 1];
char *fcn = "translate_major: ";
oldmajor = major(old_dev);
if (modctl(MODGETNAME, driver, sizeof (driver), &oldmajor) != 0) {
return (DEVFSADM_FAILURE);
}
if (strcmp(driver, "clone") != 0) {
if (get_major_no(driver, &newmajor) == DEVFSADM_FAILURE) {
return (DEVFSADM_FAILURE);
}
*new_dev = makedev(newmajor, minor(old_dev));
if (old_dev != *new_dev) {
vprint(CHATTY_MID, "%sdriver: %s old: %lu,%lu "
"new: %lu,%lu\n", fcn, driver, major(old_dev),
minor(old_dev), major(*new_dev), minor(*new_dev));
}
return (DEVFSADM_SUCCESS);
} else {
if (get_major_no(driver, &newmajor) == DEVFSADM_FAILURE) {
return (DEVFSADM_FAILURE);
}
oldminor = minor(old_dev);
if (modctl(MODGETNAME, cdriver, sizeof (cdriver),
&oldminor) != 0) {
err_print(MODGETNAME_FAILED, oldminor);
return (DEVFSADM_FAILURE);
}
if (get_major_no(cdriver, &newminor) == DEVFSADM_FAILURE) {
return (DEVFSADM_FAILURE);
}
*new_dev = makedev(newmajor, newminor);
if (old_dev != *new_dev) {
vprint(CHATTY_MID, "%sdriver: %s old: "
"%lu,%lu new: %lu,%lu\n", fcn, driver,
major(old_dev), minor(old_dev),
major(*new_dev), minor(*new_dev));
}
return (DEVFSADM_SUCCESS);
}
}
static int
get_major_no(char *driver, major_t *major)
{
n2m_t *ptr;
for (ptr = n2m_list; ptr != NULL; ptr = ptr->next) {
if (strcmp(ptr->driver, driver) == 0) {
*major = ptr->major;
return (DEVFSADM_SUCCESS);
}
}
err_print(FIND_MAJOR_FAILED, driver);
return (DEVFSADM_FAILURE);
}
static int
load_n2m_table(char *file)
{
FILE *fp;
char line[1024], *cp;
char driver[PATH_MAX + 1];
major_t major;
n2m_t *ptr;
int ln = 0;
if ((fp = fopen(file, "r")) == NULL) {
err_print(FOPEN_FAILED, file, strerror(errno));
return (DEVFSADM_FAILURE);
}
while (fgets(line, sizeof (line), fp) != NULL) {
ln++;
if ((cp = strchr(line, '#')) != NULL)
*cp = '\0';
if (is_blank(line))
continue;
if (sscanf(line, "%1024s%lu", driver, &major) != 2) {
err_print(IGNORING_LINE_IN, ln, file);
continue;
}
ptr = (n2m_t *)s_malloc(sizeof (n2m_t));
ptr->major = major;
ptr->driver = s_strdup(driver);
ptr->next = n2m_list;
n2m_list = ptr;
}
if (fclose(fp) == EOF) {
err_print(FCLOSE_FAILED, file, strerror(errno));
}
return (DEVFSADM_SUCCESS);
}
static void
read_enumerate_file(void)
{
FILE *fp;
int linenum;
char line[PATH_MAX+1];
enumerate_file_t *entry;
struct stat current_sb;
static struct stat cached_sb;
static int cached = FALSE;
assert(enumerate_file);
if (stat(enumerate_file, ¤t_sb) == -1) {
vprint(RSRV_MID, "No reserved file: %s\n", enumerate_file);
cached = FALSE;
if (enumerate_reserved != NULL) {
vprint(RSRV_MID, "invalidating %s cache\n",
enumerate_file);
}
while (enumerate_reserved != NULL) {
entry = enumerate_reserved;
enumerate_reserved = entry->er_next;
free(entry->er_file);
free(entry->er_id);
free(entry);
}
return;
}
if (cached == TRUE) {
if (current_sb.st_mtime == cached_sb.st_mtime) {
vprint(RSRV_MID, "%s cache valid\n", enumerate_file);
vprint(FILES_MID, "%s cache valid\n", enumerate_file);
return;
}
vprint(RSRV_MID, "invalidating %s cache\n", enumerate_file);
vprint(FILES_MID, "invalidating %s cache\n", enumerate_file);
while (enumerate_reserved != NULL) {
entry = enumerate_reserved;
enumerate_reserved = entry->er_next;
free(entry->er_file);
free(entry->er_id);
free(entry);
}
vprint(RSRV_MID, "Recaching file: %s\n", enumerate_file);
} else {
vprint(RSRV_MID, "Caching file (first time): %s\n",
enumerate_file);
cached = TRUE;
}
(void) stat(enumerate_file, &cached_sb);
if ((fp = fopen(enumerate_file, "r")) == NULL) {
err_print(FOPEN_FAILED, enumerate_file, strerror(errno));
return;
}
vprint(RSRV_MID, "Reading reserve file: %s\n", enumerate_file);
linenum = 0;
while (fgets(line, sizeof (line), fp) != NULL) {
char *cp, *ncp;
linenum++;
cp = strchr(line, '\n');
if (cp)
*cp = '\0';
vprint(RSRV_MID, "Reserve file: line %d: %s\n", linenum, line);
for (cp = line; *cp == ' ' || *cp == '\t'; cp++)
;
if (*cp == '\0' || *cp == '#') {
vprint(RSRV_MID, "Skipping line: '%s'\n", line);
continue;
}
ncp = cp;
for (; *cp != ' ' && *cp != '\t' && *cp != '\0'; cp++)
;
*cp = '\0';
entry = s_zalloc(sizeof (enumerate_file_t));
entry->er_file = s_strdup(ncp);
entry->er_id = NULL;
entry->er_next = enumerate_reserved;
enumerate_reserved = entry;
}
if (fclose(fp) == EOF) {
err_print(FCLOSE_FAILED, enumerate_file, strerror(errno));
}
}
static void
read_devlinktab_file(void)
{
devlinktab_list_t *headp = NULL;
devlinktab_list_t *entryp;
devlinktab_list_t **previous;
devlinktab_list_t *save;
char line[MAX_DEVLINK_LINE], *cp;
char *selector;
char *p_link;
char *s_link;
FILE *fp;
int i;
static struct stat cached_sb;
struct stat current_sb;
static int cached = FALSE;
if (devlinktab_file == NULL) {
return;
}
(void) stat(devlinktab_file, ¤t_sb);
if (cached == TRUE) {
if (current_sb.st_mtime == cached_sb.st_mtime) {
vprint(FILES_MID, "%s cache valid\n", devlinktab_file);
return;
}
vprint(FILES_MID, "invalidating %s cache\n", devlinktab_file);
while (devlinktab_list != NULL) {
free_link_list(devlinktab_list->p_link);
free_link_list(devlinktab_list->s_link);
free_selector_list(devlinktab_list->selector);
free(devlinktab_list->selector_pattern);
free(devlinktab_list->p_link_pattern);
if (devlinktab_list->s_link_pattern != NULL) {
free(devlinktab_list->s_link_pattern);
}
save = devlinktab_list;
devlinktab_list = devlinktab_list->next;
free(save);
}
} else {
cached = TRUE;
}
(void) stat(devlinktab_file, &cached_sb);
if ((fp = fopen(devlinktab_file, "r")) == NULL) {
err_print(FOPEN_FAILED, devlinktab_file, strerror(errno));
return;
}
previous = &headp;
while (fgets(line, sizeof (line), fp) != NULL) {
devlinktab_line++;
i = strlen(line);
if (line[i-1] == NEWLINE) {
line[i-1] = '\0';
} else if (i == sizeof (line-1)) {
err_print(LINE_TOO_LONG, devlinktab_line,
devlinktab_file, sizeof (line)-1);
while (((i = getc(fp)) != '\n') && (i != EOF))
;
continue;
}
if ((cp = strchr(line, '#')) != NULL)
*cp = '\0';
if (is_blank(line))
continue;
vprint(DEVLINK_MID, "table: %s line %d: '%s'\n",
devlinktab_file, devlinktab_line, line);
if (split_devlinktab_entry(line, &selector, &p_link,
&s_link) == DEVFSADM_FAILURE) {
vprint(DEVLINK_MID, "split_entry returns failure\n");
continue;
} else {
vprint(DEVLINK_MID, "split_entry selector='%s' "
"p_link='%s' s_link='%s'\n\n", selector,
p_link, (s_link == NULL) ? "" : s_link);
}
entryp =
(devlinktab_list_t *)s_malloc(sizeof (devlinktab_list_t));
entryp->line_number = devlinktab_line;
if ((entryp->selector = create_selector_list(selector))
== NULL) {
free(entryp);
continue;
}
entryp->selector_pattern = s_strdup(selector);
if ((entryp->p_link = create_link_list(p_link)) == NULL) {
free_selector_list(entryp->selector);
free(entryp->selector_pattern);
free(entryp);
continue;
}
entryp->p_link_pattern = s_strdup(p_link);
if (s_link != NULL) {
if ((entryp->s_link =
create_link_list(s_link)) == NULL) {
free_selector_list(entryp->selector);
free_link_list(entryp->p_link);
free(entryp->selector_pattern);
free(entryp->p_link_pattern);
free(entryp);
continue;
}
entryp->s_link_pattern = s_strdup(s_link);
} else {
entryp->s_link = NULL;
entryp->s_link_pattern = NULL;
}
entryp->next = NULL;
*previous = entryp;
previous = &(entryp->next);
}
if (fclose(fp) == EOF) {
err_print(FCLOSE_FAILED, devlinktab_file, strerror(errno));
}
devlinktab_list = headp;
}
static int
split_devlinktab_entry(char *entry, char **selector, char **p_link,
char **s_link)
{
char *tab;
*selector = entry;
if ((tab = strchr(entry, TAB)) != NULL) {
*tab = '\0';
*p_link = ++tab;
} else {
err_print(MISSING_TAB, devlinktab_line, devlinktab_file);
return (DEVFSADM_FAILURE);
}
if (**p_link == '\0') {
err_print(MISSING_DEVNAME, devlinktab_line, devlinktab_file);
return (DEVFSADM_FAILURE);
}
if ((tab = strchr(*p_link, TAB)) != NULL) {
*tab = '\0';
*s_link = ++tab;
if (strchr(*s_link, TAB) != NULL) {
err_print(TOO_MANY_FIELDS, devlinktab_line,
devlinktab_file);
return (DEVFSADM_FAILURE);
}
} else {
*s_link = NULL;
}
return (DEVFSADM_SUCCESS);
}
static selector_list_t *
create_selector_list(char *selector)
{
char *key;
char *val;
int error = FALSE;
selector_list_t *head_selector_list = NULL;
selector_list_t *selector_list;
while ((*selector != '\0') && (error == FALSE)) {
if (parse_selector(&selector, &key, &val) == DEVFSADM_FAILURE) {
error = TRUE;
break;
} else {
selector_list = (selector_list_t *)
s_malloc(sizeof (selector_list_t));
if (strcmp(NAME_S, key) == 0) {
selector_list->key = NAME;
} else if (strcmp(TYPE_S, key) == 0) {
selector_list->key = TYPE;
} else if (strncmp(ADDR_S, key, ADDR_S_LEN) == 0) {
selector_list->key = ADDR;
if (key[ADDR_S_LEN] == '\0') {
selector_list->arg = 0;
} else if (isdigit(key[ADDR_S_LEN]) != FALSE) {
selector_list->arg =
atoi(&key[ADDR_S_LEN]);
} else {
error = TRUE;
free(selector_list);
err_print(BADKEYWORD, key,
devlinktab_line, devlinktab_file);
break;
}
} else if (strncmp(MINOR_S, key, MINOR_S_LEN) == 0) {
selector_list->key = MINOR;
if (key[MINOR_S_LEN] == '\0') {
selector_list->arg = 0;
} else if (isdigit(key[MINOR_S_LEN]) != FALSE) {
selector_list->arg =
atoi(&key[MINOR_S_LEN]);
} else {
error = TRUE;
free(selector_list);
err_print(BADKEYWORD, key,
devlinktab_line, devlinktab_file);
break;
}
vprint(DEVLINK_MID, "MINOR = %s\n", val);
} else {
err_print(UNRECOGNIZED_KEY, key,
devlinktab_line, devlinktab_file);
error = TRUE;
free(selector_list);
break;
}
selector_list->val = s_strdup(val);
selector_list->next = head_selector_list;
head_selector_list = selector_list;
vprint(DEVLINK_MID, "key='%s' val='%s' arg=%d\n",
key, val, selector_list->arg);
}
}
if ((error == FALSE) && (head_selector_list != NULL)) {
return (head_selector_list);
} else {
free_selector_list(head_selector_list);
return (NULL);
}
}
static int
parse_selector(char **selector, char **key, char **val)
{
char *equal;
char *semi_colon;
*key = *selector;
if ((equal = strchr(*key, '=')) != NULL) {
*equal = '\0';
} else {
err_print(MISSING_EQUAL, devlinktab_line, devlinktab_file);
return (DEVFSADM_FAILURE);
}
*val = ++equal;
if ((semi_colon = strchr(equal, ';')) != NULL) {
*semi_colon = '\0';
*selector = semi_colon + 1;
} else {
*selector = equal + strlen(equal);
}
return (DEVFSADM_SUCCESS);
}
static link_list_t *
create_link_list(char *link)
{
int x = 0;
int error = FALSE;
int counter_found = FALSE;
link_list_t *head = NULL;
link_list_t **ptr;
link_list_t *link_list;
char constant[MAX_DEVLINK_LINE];
char *error_str;
if (link == NULL) {
return (NULL);
}
while ((*link != '\0') && (error == FALSE)) {
link_list = (link_list_t *)s_malloc(sizeof (link_list_t));
link_list->next = NULL;
while ((*link != '\0') && (*link != '\\')) {
constant[x++] = *(link++);
}
if (x != 0) {
constant[x] = '\0';
link_list->type = CONSTANT;
link_list->constant = s_strdup(constant);
x = 0;
vprint(DEVLINK_MID, "CONSTANT FOUND %s\n", constant);
} else {
switch (*(++link)) {
case 'M':
link_list->type = MINOR;
break;
case 'A':
link_list->type = ADDR;
break;
case 'N':
if (counter_found == TRUE) {
error = TRUE;
error_str =
"multiple counters not permitted";
free(link_list);
} else {
counter_found = TRUE;
link_list->type = COUNTER;
}
break;
case 'D':
link_list->type = NAME;
break;
default:
error = TRUE;
free(link_list);
error_str = "unrecognized escape sequence";
break;
}
if (*(link++) != 'D') {
if (isdigit(*link) == FALSE) {
error_str = "escape sequence must be "
"followed by a digit\n";
error = TRUE;
free(link_list);
} else {
link_list->arg =
(int)strtoul(link, &link, 10);
vprint(DEVLINK_MID, "link_list->arg = "
"%d\n", link_list->arg);
}
}
}
if (error == FALSE) {
for (ptr = &head; *ptr != NULL; ptr = &((*ptr)->next))
;
*ptr = link_list;
}
}
if (error == FALSE) {
return (head);
} else {
err_print(CONFIG_INCORRECT, devlinktab_line, devlinktab_file,
error_str);
free_link_list(head);
return (NULL);
}
}
static int
process_devlink_compat(di_minor_t minor, di_node_t node)
{
int link_built = FALSE;
devlinktab_list_t *entry;
char *nodetype;
char *dev_path;
if (devlinks_debug == TRUE) {
nodetype = di_minor_nodetype(minor);
assert(nodetype != NULL);
if ((dev_path = di_devfs_path(node)) != NULL) {
vprint(INFO_MID, "'%s' entry: %s:%s\n",
nodetype, dev_path,
di_minor_name(minor) ? di_minor_name(minor) : "");
di_devfs_path_free(dev_path);
}
}
if (num_classes > 0) {
return (FALSE);
}
for (entry = devlinktab_list; entry != NULL; entry = entry->next) {
if (devlink_matches(entry, minor, node) == DEVFSADM_SUCCESS) {
link_built = TRUE;
(void) build_links(entry, minor, node);
}
}
return (link_built);
}
static int
devlink_matches(devlinktab_list_t *entry, di_minor_t minor, di_node_t node)
{
selector_list_t *selector = entry->selector;
char *addr;
char *minor_name;
char *node_type;
for (; selector != NULL; selector = selector->next) {
switch (selector->key) {
case NAME:
if (strcmp(di_node_name(node), selector->val) != 0) {
return (DEVFSADM_FAILURE);
}
break;
case TYPE:
node_type = di_minor_nodetype(minor);
assert(node_type != NULL);
if (strcmp(node_type, selector->val) != 0) {
return (DEVFSADM_FAILURE);
}
break;
case ADDR:
if ((addr = di_bus_addr(node)) == NULL) {
return (DEVFSADM_FAILURE);
}
if (selector->arg == 0) {
if (strcmp(addr, selector->val) != 0) {
return (DEVFSADM_FAILURE);
}
} else {
if (compare_field(addr, selector->val,
selector->arg) == DEVFSADM_FAILURE) {
return (DEVFSADM_FAILURE);
}
}
break;
case MINOR:
if ((minor_name = di_minor_name(minor)) == NULL) {
return (DEVFSADM_FAILURE);
}
if (selector->arg == 0) {
if (strcmp(minor_name, selector->val) != 0) {
return (DEVFSADM_FAILURE);
}
} else {
if (compare_field(minor_name, selector->val,
selector->arg) == DEVFSADM_FAILURE) {
return (DEVFSADM_FAILURE);
}
}
break;
default:
return (DEVFSADM_FAILURE);
}
}
return (DEVFSADM_SUCCESS);
}
static int
build_links(devlinktab_list_t *entry, di_minor_t minor, di_node_t node)
{
char secondary_link[PATH_MAX + 1];
char primary_link[PATH_MAX + 1];
char contents[PATH_MAX + 1];
char *dev_path;
if ((dev_path = di_devfs_path(node)) == NULL) {
err_print(DI_DEVFS_PATH_FAILED, strerror(errno));
devfsadm_exit(1);
}
(void) strcpy(contents, dev_path);
di_devfs_path_free(dev_path);
(void) strcat(contents, ":");
(void) strcat(contents, di_minor_name(minor));
if (construct_devlink(primary_link, entry->p_link, contents,
minor, node, entry->p_link_pattern) == DEVFSADM_FAILURE) {
return (DEVFSADM_FAILURE);
}
(void) devfsadm_mklink(primary_link, node, minor, 0);
if (entry->s_link == NULL) {
return (DEVFSADM_SUCCESS);
}
if (construct_devlink(secondary_link, entry->s_link, primary_link,
minor, node, entry->s_link_pattern) == DEVFSADM_FAILURE) {
return (DEVFSADM_FAILURE);
}
(void) devfsadm_secondary_link(secondary_link, primary_link, 0);
return (DEVFSADM_SUCCESS);
}
static int
get_anchored_re(char *link, char *anchored_re, char *pattern)
{
if (*link == '/' || *link == '\0') {
err_print(INVALID_DEVLINK_SPEC, pattern);
return (DEVFSADM_FAILURE);
}
*anchored_re++ = '^';
for (; *link != '\0'; ) {
if (*link == '/') {
while (*link == '/')
link++;
*anchored_re++ = '$';
*anchored_re++ = '/';
if (*link != '\0') {
*anchored_re++ = '^';
}
} else {
*anchored_re++ = *link++;
if (*link == '\0') {
*anchored_re++ = '$';
}
}
}
*anchored_re = '\0';
return (DEVFSADM_SUCCESS);
}
static int
construct_devlink(char *link, link_list_t *link_build, char *contents,
di_minor_t minor, di_node_t node, char *pattern)
{
int counter_offset = -1;
devfsadm_enumerate_t rules[1] = {NULL};
char templink[PATH_MAX + 1];
char *buff;
char start[10];
char *node_path;
char anchored_re[PATH_MAX + 1];
link[0] = '\0';
for (; link_build != NULL; link_build = link_build->next) {
switch (link_build->type) {
case NAME:
(void) strcat(link, di_node_name(node));
break;
case CONSTANT:
(void) strcat(link, link_build->constant);
break;
case ADDR:
if (component_cat(link, di_bus_addr(node),
link_build->arg) == DEVFSADM_FAILURE) {
node_path = di_devfs_path(node);
err_print(CANNOT_BE_USED, pattern, node_path,
di_minor_name(minor));
di_devfs_path_free(node_path);
return (DEVFSADM_FAILURE);
}
break;
case MINOR:
if (component_cat(link, di_minor_name(minor),
link_build->arg) == DEVFSADM_FAILURE) {
node_path = di_devfs_path(node);
err_print(CANNOT_BE_USED, pattern, node_path,
di_minor_name(minor));
di_devfs_path_free(node_path);
return (DEVFSADM_FAILURE);
}
break;
case COUNTER:
counter_offset = strlen(link);
(void) strcat(link, "([0-9]+)");
(void) sprintf(start, "%d", link_build->arg);
break;
default:
return (DEVFSADM_FAILURE);
}
}
if (counter_offset != -1) {
(void) strcpy(templink,
&link[counter_offset + strlen("([0-9]+)")]);
if (get_anchored_re(link, anchored_re, pattern)
!= DEVFSADM_SUCCESS) {
return (DEVFSADM_FAILURE);
}
rules[0].re = anchored_re;
rules[0].subexp = 1;
rules[0].flags = MATCH_ALL;
if (devfsadm_enumerate_int_start(contents, 0, &buff,
rules, 1, start) == DEVFSADM_FAILURE) {
return (DEVFSADM_FAILURE);
}
(void) strcpy(&link[counter_offset], buff);
free(buff);
(void) strcat(link, templink);
vprint(DEVLINK_MID, "COUNTER is %s\n", link);
}
return (DEVFSADM_SUCCESS);
}
static int
compare_field(char *full_name, char *field_item, int field)
{
--field;
while ((*full_name != '\0') && (field != 0)) {
if (*(full_name++) == ',') {
field--;
}
}
if (field != 0) {
return (DEVFSADM_FAILURE);
}
while ((*full_name != '\0') && (*field_item != '\0') &&
(*full_name != ',')) {
if (*(full_name++) != *(field_item++)) {
return (DEVFSADM_FAILURE);
}
}
if (*field_item != '\0') {
return (DEVFSADM_FAILURE);
}
if ((*full_name == '\0') || (*full_name == ','))
return (DEVFSADM_SUCCESS);
return (DEVFSADM_FAILURE);
}
static int
component_cat(char *link, char *name, int field)
{
if (name == NULL) {
return (DEVFSADM_FAILURE);
}
if (field == 0) {
(void) strcat(link, name);
return (DEVFSADM_SUCCESS);
}
while (*link != '\0') {
link++;
}
--field;
while ((*name != '\0') && (field != 0)) {
if (*(name++) == ',') {
--field;
}
}
if (field != 0) {
return (DEVFSADM_FAILURE);
}
while ((*name != '\0') && (*name != ',')) {
*(link++) = *(name++);
}
*link = '\0';
return (DEVFSADM_SUCCESS);
}
static void
free_selector_list(selector_list_t *head)
{
selector_list_t *temp;
while (head != NULL) {
temp = head;
head = head->next;
free(temp->val);
free(temp);
}
}
static void
free_link_list(link_list_t *head)
{
link_list_t *temp;
while (head != NULL) {
temp = head;
head = head->next;
if (temp->type == CONSTANT) {
free(temp->constant);
}
free(temp);
}
}
void
devfsadm_print(char *msgid, char *message, ...)
{
va_list ap;
static int newline = TRUE;
int x;
if (msgid != NULL) {
for (x = 0; x < num_verbose; x++) {
if (strcmp(verbose[x], msgid) == 0) {
break;
}
if (strcmp(verbose[x], ALL_MID) == 0) {
break;
}
}
if (x == num_verbose) {
return;
}
}
va_start(ap, message);
if (msgid == NULL) {
if (logflag == TRUE) {
(void) vsyslog(LOG_NOTICE, message, ap);
} else {
(void) vfprintf(stdout, message, ap);
}
} else {
if (logflag == TRUE) {
(void) syslog(LOG_DEBUG, "%s[%ld]: %s: ",
prog, getpid(), msgid);
(void) vsyslog(LOG_DEBUG, message, ap);
} else {
if (newline == TRUE) {
(void) fprintf(stdout, "%s[%ld]: %s: ",
prog, getpid(), msgid);
}
(void) vfprintf(stdout, message, ap);
}
}
if (message[strlen(message) - 1] == '\n') {
newline = TRUE;
} else {
newline = FALSE;
}
va_end(ap);
}
void
devfsadm_errprint(char *message, ...)
{
va_list ap;
va_start(ap, message);
if (logflag == TRUE) {
(void) vsyslog(LOG_ERR, message, ap);
} else {
(void) fprintf(stderr, "%s: ", prog);
(void) vfprintf(stderr, message, ap);
}
va_end(ap);
}
int
devfsadm_noupdate(void)
{
return (file_mods == TRUE ? DEVFSADM_TRUE : DEVFSADM_FALSE);
}
const char *
devfsadm_root_path(void)
{
if (root_dir[0] == '\0') {
return ("/");
} else {
return ((const char *)root_dir);
}
}
void
devfsadm_free_dev_names(char **dev_names, int len)
{
int i;
for (i = 0; i < len; i++)
free(dev_names[i]);
free(dev_names);
}
char **
devfsadm_lookup_dev_names(char *phys_path, char *re, int *lenp)
{
struct devlink_cb_arg cb_arg;
char **dev_names = NULL;
int i;
*lenp = 0;
cb_arg.count = 0;
cb_arg.rv = 0;
(void) di_devlink_cache_walk(devlink_cache, re, phys_path,
DI_PRIMARY_LINK, &cb_arg, devlink_cb);
if (cb_arg.rv == -1 || cb_arg.count <= 0)
return (NULL);
dev_names = s_malloc(cb_arg.count * sizeof (char *));
if (dev_names == NULL)
goto out;
for (i = 0; i < cb_arg.count; i++) {
dev_names[i] = s_strdup(cb_arg.dev_names[i]);
if (dev_names[i] == NULL) {
devfsadm_free_dev_names(dev_names, i);
dev_names = NULL;
goto out;
}
}
*lenp = cb_arg.count;
out:
free_dev_names(&cb_arg);
return (dev_names);
}
static void
devfsadm_exit(int status)
{
if (DEVFSADM_DEBUG_ON) {
vprint(INFO_MID, "exit status = %d\n", status);
}
exit_dev_lock(1);
exit_daemon_lock(1);
if (logflag == TRUE) {
closelog();
}
exit(status);
}
static void
set_root_devices_dev_dir(char *dir)
{
size_t len;
root_dir = s_strdup(dir);
len = strlen(dir) + strlen(DEVICES) + 1;
devices_dir = s_malloc(len);
(void) snprintf(devices_dir, len, "%s%s", root_dir, DEVICES);
len = strlen(root_dir) + strlen(DEV) + 1;
dev_dir = s_malloc(len);
(void) snprintf(dev_dir, len, "%s%s", root_dir, DEV);
}
static char *
dequote(char *src)
{
char *dst;
int len;
len = strlen(src);
dst = s_malloc(len + 1);
if (src[0] == '\"' && src[len - 1] == '\"') {
len -= 2;
(void) strncpy(dst, &src[1], len);
dst[len] = '\0';
} else {
(void) strcpy(dst, src);
}
return (dst);
}
static void
getattr(char *phy_path, char *aminor, int spectype, dev_t dev, mode_t *mode,
uid_t *uid, gid_t *gid)
{
char devname[PATH_MAX + 1];
char *node_name;
char *minor_name;
int match = FALSE;
int is_clone;
int mp_drvname_matches_node_name;
int mp_drvname_matches_minor_name;
int mp_drvname_is_clone;
int mp_drvname_matches_drvname;
struct mperm *mp;
major_t major_no;
char driver[PATH_MAX + 1];
major_no = major(dev);
if (modctl(MODGETNAME, driver, sizeof (driver), &major_no) != 0) {
goto use_defaults;
}
(void) strcpy(devname, phy_path);
node_name = strrchr(devname, '/');
if (node_name == NULL) {
err_print(NO_NODE, devname);
goto use_defaults;
}
minor_name = strchr(++node_name, '@');
if (minor_name != NULL) {
*minor_name++ = '\0';
} else {
minor_name = node_name;
}
minor_name = strchr(minor_name, ':');
if (minor_name == NULL) {
err_print(NO_MINOR, devname);
goto use_defaults;
}
*minor_name++ = '\0';
is_clone = (strcmp(node_name, "clone") == 0 ? TRUE : FALSE);
for (mp = minor_perms; mp != NULL; mp = mp->mp_next) {
mp_drvname_matches_node_name =
(strcmp(mp->mp_drvname, node_name) == 0 ? TRUE : FALSE);
mp_drvname_matches_minor_name =
(strcmp(mp->mp_drvname, minor_name) == 0 ? TRUE:FALSE);
mp_drvname_is_clone =
(strcmp(mp->mp_drvname, "clone") == 0 ? TRUE : FALSE);
mp_drvname_matches_drvname =
(strcmp(mp->mp_drvname, driver) == 0 ? TRUE : FALSE);
if ((mp_drvname_matches_drvname == TRUE)||
((mp_drvname_matches_node_name == TRUE) &&
(alias(driver, node_name) == TRUE)) ||
((is_clone == TRUE) &&
((mp_drvname_is_clone == TRUE) ||
(mp_drvname_matches_minor_name == TRUE)))) {
if (aminor != NULL)
minor_name = aminor;
if (gmatch(minor_name, mp->mp_minorname) != 0) {
*uid = mp->mp_uid;
*gid = mp->mp_gid;
*mode = spectype | mp->mp_mode;
match = TRUE;
}
}
}
if (match == TRUE) {
return;
}
use_defaults:
*uid = root_uid;
*gid = sys_gid;
*mode = (spectype | 0600);
}
static void
minorperm_err_cb(minorperm_err_t mp_err, int key)
{
switch (mp_err) {
case MP_FOPEN_ERR:
err_print(FOPEN_FAILED, MINOR_PERM_FILE, strerror(key));
break;
case MP_FCLOSE_ERR:
err_print(FCLOSE_FAILED, MINOR_PERM_FILE, strerror(key));
break;
case MP_IGNORING_LINE_ERR:
err_print(IGNORING_LINE_IN, key, MINOR_PERM_FILE);
break;
case MP_ALLOC_ERR:
err_print(MALLOC_FAILED, key);
break;
case MP_NVLIST_ERR:
err_print(NVLIST_ERROR, MINOR_PERM_FILE, strerror(key));
break;
case MP_CANT_FIND_USER_ERR:
err_print(CANT_FIND_USER, DEFAULT_DEV_USER);
break;
case MP_CANT_FIND_GROUP_ERR:
err_print(CANT_FIND_GROUP, DEFAULT_DEV_GROUP);
break;
}
}
static void
read_minor_perm_file(void)
{
static int cached = FALSE;
static struct stat cached_sb;
struct stat current_sb;
(void) stat(MINOR_PERM_FILE, ¤t_sb);
if (cached == TRUE) {
if (current_sb.st_mtime == cached_sb.st_mtime) {
vprint(FILES_MID, "%s cache valid\n", MINOR_PERM_FILE);
return;
}
devfs_free_minor_perm(minor_perms);
minor_perms = NULL;
} else {
cached = TRUE;
}
(void) stat(MINOR_PERM_FILE, &cached_sb);
vprint(FILES_MID, "loading binding file: %s\n", MINOR_PERM_FILE);
minor_perms = devfs_read_minor_perm(minorperm_err_cb);
}
static void
load_minor_perm_file(void)
{
read_minor_perm_file();
if (devfs_load_minor_perm(minor_perms, minorperm_err_cb) != 0)
err_print(gettext("minor_perm load failed\n"));
}
static char *
convert_to_re(char *dev)
{
char *p, *l, *out;
int i;
out = s_malloc(PATH_MAX);
for (l = p = dev, i = 0; (*p != '\0') && (i < (PATH_MAX - 1));
++p, i++) {
if ((*p == '*') && ((l != p) && (*l == '/'))) {
out[i++] = '.';
out[i] = '+';
} else {
out[i] = *p;
}
l = p;
}
out[i] = '\0';
p = (char *)s_malloc(strlen(out) + 1);
(void) strlcpy(p, out, strlen(out) + 1);
free(out);
vprint(FILES_MID, "converted %s -> %s\n", dev, p);
return (p);
}
static void
read_logindevperm_file(void)
{
static int cached = FALSE;
static struct stat cached_sb;
struct stat current_sb;
struct login_dev *ldev;
FILE *fp;
char line[MAX_LDEV_LINE];
int ln, perm, rv;
char *cp, *console, *dlist, *dev;
char *lasts, *devlasts, *permstr, *drv;
struct driver_list *list, *next;
if (login_dev_enable != TRUE)
return;
if (cached == TRUE) {
if (stat(LDEV_FILE, ¤t_sb) == 0 &&
current_sb.st_mtime == cached_sb.st_mtime) {
vprint(FILES_MID, "%s cache valid\n", LDEV_FILE);
return;
}
vprint(FILES_MID, "invalidating %s cache\n", LDEV_FILE);
while (login_dev_cache != NULL) {
ldev = login_dev_cache;
login_dev_cache = ldev->ldev_next;
free(ldev->ldev_console);
free(ldev->ldev_device);
regfree(&ldev->ldev_device_regex);
list = ldev->ldev_driver_list;
while (list) {
next = list->next;
free(list);
list = next;
}
free(ldev);
}
} else {
cached = TRUE;
}
assert(login_dev_cache == NULL);
if (stat(LDEV_FILE, &cached_sb) != 0) {
cached = FALSE;
return;
}
vprint(FILES_MID, "loading file: %s\n", LDEV_FILE);
if ((fp = fopen(LDEV_FILE, "r")) == NULL) {
cached = FALSE;
err_print(FOPEN_FAILED, LDEV_FILE, strerror(errno));
return;
}
ln = 0;
while (fgets(line, MAX_LDEV_LINE, fp) != NULL) {
ln++;
if ((cp = strchr(line, '#')) != NULL)
*cp = '\0';
if ((console = strtok_r(line, LDEV_DELIMS, &lasts)) == NULL)
continue;
if ((permstr = strtok_r(NULL, LDEV_DELIMS, &lasts)) == NULL) {
err_print(IGNORING_LINE_IN, ln, LDEV_FILE);
continue;
}
cp = NULL;
errno = 0;
perm = strtol(permstr, &cp, 8);
if (errno || perm < 0 || perm > 0777 || *cp != '\0') {
err_print(IGNORING_LINE_IN, ln, LDEV_FILE);
continue;
}
if ((dlist = strtok_r(NULL, LDEV_DELIMS, &lasts)) == NULL) {
err_print(IGNORING_LINE_IN, ln, LDEV_FILE);
continue;
}
dev = strtok_r(dlist, LDEV_DEV_DELIM, &devlasts);
while (dev) {
ldev = (struct login_dev *)s_zalloc(
sizeof (struct login_dev));
ldev->ldev_console = s_strdup(console);
ldev->ldev_perms = perm;
ldev->ldev_device = convert_to_re(dev);
if (ldev->ldev_device &&
(rv = regcomp(&ldev->ldev_device_regex,
ldev->ldev_device, REG_EXTENDED))) {
bzero(&ldev->ldev_device_regex,
sizeof (ldev->ldev_device_regex));
err_print(REGCOMP_FAILED,
ldev->ldev_device, rv);
}
ldev->ldev_next = login_dev_cache;
login_dev_cache = ldev;
dev = strtok_r(NULL, LDEV_DEV_DELIM, &devlasts);
}
drv = strtok_r(NULL, LDEV_DRVLIST_DELIMS, &lasts);
if (drv) {
if (strcmp(drv, LDEV_DRVLIST_NAME) == 0) {
drv = strtok_r(NULL, LDEV_DRV_DELIMS, &lasts);
while (drv) {
vprint(FILES_MID,
"logindevperm driver=%s\n", drv);
list = (struct driver_list *)
s_zalloc(
sizeof (struct driver_list));
(void) strlcpy(list->driver_name, drv,
sizeof (list->driver_name));
list->next = ldev->ldev_driver_list;
ldev->ldev_driver_list = list;
drv = strtok_r(NULL, LDEV_DRV_DELIMS,
&lasts);
}
}
}
}
(void) fclose(fp);
}
static int
getnexttoken(char *next, char **nextp, char **tokenpp, char *tchar)
{
char *cp;
char *cp1;
char *tokenp;
cp = next;
while (*cp == ' ' || *cp == '\t') {
cp++;
}
tokenp = cp;
while (*cp != '\0' && *cp != '\n' && *cp != ' ' && *cp != '\t' &&
*cp != ':' && *cp != '=' && *cp != '&' &&
*cp != '|' && *cp != ';') {
cp++;
}
if (*cp == ' ' || *cp == '\t') {
cp1 = cp;
while (*++cp1 == ' ' || *cp1 == '\t')
;
if (*cp1 == '=' || *cp1 == ':' || *cp1 == '&' || *cp1 == '|' ||
*cp1 == ';' || *cp1 == '\n' || *cp1 == '\0') {
*cp = '\0';
cp = cp1;
}
}
if (tchar != NULL) {
*tchar = *cp;
if (*tchar == '\0') {
*tchar = '\n';
}
}
*cp++ = '\0';
*nextp = cp;
if (cp - tokenp - 1 == 0) {
return (DEVFSADM_FAILURE);
}
*tokenpp = tokenp;
return (DEVFSADM_SUCCESS);
}
static void
read_driver_aliases_file(void)
{
driver_alias_t *save;
driver_alias_t *lst_tail;
driver_alias_t *ap;
static int cached = FALSE;
FILE *afd;
char line[256];
char *cp;
char *p;
char t;
int ln = 0;
static struct stat cached_sb;
struct stat current_sb;
(void) stat(ALIASFILE, ¤t_sb);
if (cached == TRUE) {
if (current_sb.st_mtime == cached_sb.st_mtime) {
vprint(FILES_MID, "%s cache valid\n", ALIASFILE);
return;
}
vprint(FILES_MID, "invalidating %s cache\n", ALIASFILE);
while (driver_aliases != NULL) {
free(driver_aliases->alias_name);
free(driver_aliases->driver_name);
save = driver_aliases;
driver_aliases = driver_aliases->next;
free(save);
}
} else {
cached = TRUE;
}
(void) stat(ALIASFILE, &cached_sb);
vprint(FILES_MID, "loading binding file: %s\n", ALIASFILE);
if ((afd = fopen(ALIASFILE, "r")) == NULL) {
err_print(FOPEN_FAILED, ALIASFILE, strerror(errno));
devfsadm_exit(1);
}
while (fgets(line, sizeof (line), afd) != NULL) {
ln++;
if ((cp = strchr(line, '#')) != NULL)
*cp = '\0';
if (is_blank(line))
continue;
cp = line;
if (getnexttoken(cp, &cp, &p, &t) == DEVFSADM_FAILURE) {
err_print(IGNORING_LINE_IN, ln, ALIASFILE);
continue;
}
if (t == '\n' || t == '\0') {
err_print(DRV_BUT_NO_ALIAS, ln, ALIASFILE);
continue;
}
ap = (struct driver_alias *)
s_zalloc(sizeof (struct driver_alias));
ap->driver_name = s_strdup(p);
if (getnexttoken(cp, &cp, &p, &t) == DEVFSADM_FAILURE) {
err_print(DRV_BUT_NO_ALIAS, ln, ALIASFILE);
free(ap->driver_name);
free(ap);
continue;
}
if (*p == '"') {
if (p[strlen(p) - 1] == '"') {
p[strlen(p) - 1] = '\0';
p++;
}
}
ap->alias_name = s_strdup(p);
if (driver_aliases == NULL) {
driver_aliases = ap;
lst_tail = ap;
} else {
lst_tail->next = ap;
lst_tail = ap;
}
}
if (fclose(afd) == EOF) {
err_print(FCLOSE_FAILED, ALIASFILE, strerror(errno));
}
}
static int
alias(char *driver_name, char *alias_name)
{
driver_alias_t *alias;
for (alias = driver_aliases; alias != NULL; alias = alias->next) {
if ((strcmp(alias->driver_name, driver_name) == 0) &&
(strcmp(alias->alias_name, alias_name) == 0)) {
return (TRUE);
}
}
return (FALSE);
}
static int
s_stat(const char *path, struct stat *sbufp)
{
int rv;
retry:
if ((rv = stat(path, sbufp)) == -1) {
if (errno == EINTR)
goto retry;
}
return (rv);
}
static void *
s_malloc(const size_t size)
{
void *rp;
rp = malloc(size);
if (rp == NULL) {
err_print(MALLOC_FAILED, size);
devfsadm_exit(1);
}
return (rp);
}
static void *
s_realloc(void *ptr, const size_t size)
{
ptr = realloc(ptr, size);
if (ptr == NULL) {
err_print(REALLOC_FAILED, size);
devfsadm_exit(1);
}
return (ptr);
}
static void *
s_zalloc(const size_t size)
{
void *rp;
rp = calloc(1, size);
if (rp == NULL) {
err_print(CALLOC_FAILED, size);
devfsadm_exit(1);
}
return (rp);
}
char *
s_strdup(const char *ptr)
{
void *rp;
rp = strdup(ptr);
if (rp == NULL) {
err_print(STRDUP_FAILED, ptr);
devfsadm_exit(1);
}
return (rp);
}
static void
s_closedir(DIR *dirp)
{
retry:
if (closedir(dirp) != 0) {
if (errno == EINTR)
goto retry;
err_print(CLOSEDIR_FAILED, strerror(errno));
}
}
static void
s_mkdirp(const char *path, const mode_t mode)
{
vprint(CHATTY_MID, "mkdirp(%s, 0x%lx)\n", path, mode);
if (mkdirp(path, mode) == -1) {
if (errno != EEXIST) {
err_print(MKDIR_FAILED, path, mode, strerror(errno));
}
}
}
static void
s_unlink(const char *file)
{
retry:
if (unlink(file) == -1) {
if (errno == EINTR || errno == EAGAIN)
goto retry;
if (errno != ENOENT) {
err_print(UNLINK_FAILED, file, strerror(errno));
}
}
}
static void
add_verbose_id(char *mid)
{
num_verbose++;
verbose = s_realloc(verbose, num_verbose * sizeof (char *));
verbose[num_verbose - 1] = mid;
}
static int
is_minor_node(char *contents, char **mn_root)
{
char *ptr;
char device_prefix[100];
(void) snprintf(device_prefix, sizeof (device_prefix), "../devices/");
if ((ptr = strstr(contents, device_prefix)) != NULL) {
if (mn_root != NULL) {
*mn_root = ptr += strlen(device_prefix) - 1;
}
return (DEVFSADM_TRUE);
}
(void) snprintf(device_prefix, sizeof (device_prefix), "/devices/");
if (strncmp(contents, device_prefix, strlen(device_prefix)) == 0) {
if (mn_root != NULL) {
*mn_root = contents + strlen(device_prefix) - 1;
}
return (DEVFSADM_TRUE);
}
if (mn_root != NULL) {
*mn_root = contents;
}
return (DEVFSADM_FALSE);
}
static int
add_property(nvlist_t *nvl, di_prop_t prop)
{
char *name;
char *attr_name;
int n, len;
int32_t *int32p;
int64_t *int64p;
char *str;
char **strarray;
uchar_t *bytep;
int rv = 0;
int i;
if ((name = di_prop_name(prop)) == NULL)
return (-1);
len = sizeof (DEV_PROP_PREFIX) + strlen(name);
if ((attr_name = malloc(len)) == NULL)
return (-1);
(void) strlcpy(attr_name, DEV_PROP_PREFIX, len);
(void) strlcat(attr_name, name, len);
switch (di_prop_type(prop)) {
case DI_PROP_TYPE_BOOLEAN:
if (nvlist_add_boolean(nvl, attr_name) != 0)
goto out;
break;
case DI_PROP_TYPE_INT:
if ((n = di_prop_ints(prop, &int32p)) < 1)
goto out;
if (n <= (PROP_LEN_LIMIT / sizeof (int32_t))) {
if (nvlist_add_int32_array(nvl, attr_name, int32p,
n) != 0)
goto out;
} else
rv = 1;
break;
case DI_PROP_TYPE_INT64:
if ((n = di_prop_int64(prop, &int64p)) < 1)
goto out;
if (n <= (PROP_LEN_LIMIT / sizeof (int64_t))) {
if (nvlist_add_int64_array(nvl, attr_name, int64p,
n) != 0)
goto out;
} else
rv = 1;
break;
case DI_PROP_TYPE_BYTE:
case DI_PROP_TYPE_UNKNOWN:
if ((n = di_prop_bytes(prop, &bytep)) < 1)
goto out;
if (n <= PROP_LEN_LIMIT) {
if (nvlist_add_byte_array(nvl, attr_name, bytep, n)
!= 0)
goto out;
} else
rv = 1;
break;
case DI_PROP_TYPE_STRING:
if ((n = di_prop_strings(prop, &str)) < 1)
goto out;
if ((strarray = malloc(n * sizeof (char *))) == NULL)
goto out;
len = 0;
for (i = 0; i < n; i++) {
strarray[i] = str + len;
len += strlen(strarray[i]) + 1;
}
if (len <= PROP_LEN_LIMIT) {
if (nvlist_add_string_array(nvl, attr_name, strarray,
n) != 0) {
free(strarray);
goto out;
}
} else
rv = 1;
free(strarray);
break;
default:
rv = 1;
break;
}
free(attr_name);
return (rv);
out:
free(attr_name);
return (-1);
}
static void
free_dev_names(struct devlink_cb_arg *x)
{
int i;
for (i = 0; i < x->count; i++) {
free(x->dev_names[i]);
free(x->link_contents[i]);
}
}
static int
devlink_cb(di_devlink_t dl, void *arg)
{
struct devlink_cb_arg *x = (struct devlink_cb_arg *)arg;
const char *path;
const char *content;
if ((path = di_devlink_path(dl)) == NULL ||
(content = di_devlink_content(dl)) == NULL ||
(x->dev_names[x->count] = s_strdup(path)) == NULL)
goto out;
if ((x->link_contents[x->count] = s_strdup(content)) == NULL) {
free(x->dev_names[x->count]);
goto out;
}
x->count++;
if (x->count >= MAX_DEV_NAME_COUNT)
return (DI_WALK_TERMINATE);
return (DI_WALK_CONTINUE);
out:
x->rv = -1;
free_dev_names(x);
return (DI_WALK_TERMINATE);
}
static int
lookup_dev_name(char *phys_path, char **dev_name)
{
struct devlink_cb_arg cb_arg;
*dev_name = NULL;
cb_arg.count = 0;
cb_arg.rv = 0;
(void) di_devlink_cache_walk(devlink_cache, NULL, phys_path,
DI_PRIMARY_LINK, &cb_arg, devlink_cb);
if (cb_arg.rv == -1)
return (-1);
if (cb_arg.count > 0) {
*dev_name = s_strdup(cb_arg.dev_names[0]);
free_dev_names(&cb_arg);
if (*dev_name == NULL)
return (-1);
}
return (0);
}
static char *
lookup_disk_dev_name(char *node_path)
{
struct devlink_cb_arg cb_arg;
char *dev_name = NULL;
int i;
char *p;
int len1, len2;
#define DEV_RDSK "/dev/rdsk/"
#define DISK_RAW_MINOR ",raw"
cb_arg.count = 0;
cb_arg.rv = 0;
(void) di_devlink_cache_walk(devlink_cache, NULL, node_path,
DI_PRIMARY_LINK, &cb_arg, devlink_cb);
if (cb_arg.rv == -1 || cb_arg.count == 0)
return (NULL);
for (i = 0; i < cb_arg.count; i++) {
if (strncmp(cb_arg.dev_names[i], DEV_RDSK,
sizeof (DEV_RDSK) - 1) == 0) {
dev_name = s_strdup(cb_arg.dev_names[i]);
break;
}
}
if (dev_name == NULL) {
len1 = sizeof (DISK_RAW_MINOR) - 1;
for (i = 0; i < cb_arg.count; i++) {
len2 = strlen(cb_arg.link_contents[i]);
if (len2 >= len1 &&
strcmp(cb_arg.link_contents[i] + len2 - len1,
DISK_RAW_MINOR) == 0) {
dev_name = s_strdup(cb_arg.dev_names[i]);
break;
}
}
}
free_dev_names(&cb_arg);
if (dev_name == NULL)
return (NULL);
if (strlen(dev_name) == 0) {
free(dev_name);
return (NULL);
}
p = dev_name + strlen(dev_name) - 1;
if (isdigit(*p)) {
while (p != dev_name && isdigit(*p))
p--;
if (*p == 's' || *p == 'p')
*p = '\0';
}
return (dev_name);
}
static char *
lookup_lofi_dev_name(char *node_path, char *minor)
{
struct devlink_cb_arg cb_arg;
char *dev_name = NULL;
int i;
int len1, len2;
cb_arg.count = 0;
cb_arg.rv = 0;
(void) di_devlink_cache_walk(devlink_cache, NULL, node_path,
DI_PRIMARY_LINK, &cb_arg, devlink_cb);
if (cb_arg.rv == -1 || cb_arg.count == 0)
return (NULL);
len1 = strlen(minor);
for (i = 0; i < cb_arg.count; i++) {
len2 = strlen(cb_arg.link_contents[i]);
if (len2 >= len1 &&
strcmp(cb_arg.link_contents[i] + len2 - len1,
minor) == 0) {
dev_name = s_strdup(cb_arg.dev_names[i]);
break;
}
}
free_dev_names(&cb_arg);
if (dev_name == NULL)
return (NULL);
if (strlen(dev_name) == 0) {
free(dev_name);
return (NULL);
}
return (dev_name);
}
static char *
lookup_network_dev_name(char *node_path, char *driver_name)
{
char *dev_name = NULL;
char phys_path[MAXPATHLEN];
if (lookup_dev_name(node_path, &dev_name) == -1)
return (NULL);
if (dev_name == NULL) {
(void) snprintf(phys_path, sizeof (phys_path),
"/pseudo/clone@0:%s", driver_name);
if (lookup_dev_name(phys_path, &dev_name) == -1 ||
dev_name == NULL)
return (NULL);
}
return (dev_name);
}
static char *
lookup_printer_dev_name(char *node_path)
{
struct devlink_cb_arg cb_arg;
char *dev_name = NULL;
int i;
#define DEV_PRINTERS "/dev/printers/"
cb_arg.count = 0;
cb_arg.rv = 0;
(void) di_devlink_cache_walk(devlink_cache, NULL, node_path,
DI_PRIMARY_LINK, &cb_arg, devlink_cb);
if (cb_arg.rv == -1 || cb_arg.count == 0)
return (NULL);
for (i = 0; i < cb_arg.count; i++) {
if (strncmp(cb_arg.dev_names[i], DEV_PRINTERS,
sizeof (DEV_PRINTERS) - 1) == 0) {
dev_name = s_strdup(cb_arg.dev_names[i]);
break;
}
}
if ((dev_name == NULL) && (cb_arg.count > 0))
dev_name = s_strdup(cb_arg.dev_names[0]);
free_dev_names(&cb_arg);
return (dev_name);
}
static nvlist_t *
build_event_attributes(char *class, char *subclass, char *node_path,
di_node_t node, char *driver_name, int instance, char *minor)
{
nvlist_t *nvl;
int err = 0;
di_prop_t prop;
int count;
char *prop_name;
int x;
char *dev_name = NULL;
int dev_name_lookup_err = 0;
if ((err = nvlist_alloc(&nvl, NV_UNIQUE_NAME_TYPE, 0)) != 0) {
nvl = NULL;
goto out;
}
if ((err = nvlist_add_int32(nvl, EV_VERSION, EV_V1)) != 0)
goto out;
if ((err = nvlist_add_string(nvl, DEV_PHYS_PATH, node_path)) != 0)
goto out;
if (strcmp(class, EC_DEV_ADD) != 0 &&
strcmp(class, EC_DEV_REMOVE) != 0)
return (nvl);
if (driver_name == NULL || instance == -1)
goto out;
if (strcmp(subclass, ESC_DISK) == 0) {
if (strcmp(class, EC_DEV_REMOVE) == 0 &&
strcmp(driver_name, "lofi") == 0 && minor == NULL) {
nvlist_free(nvl);
return (NULL);
}
if ((dev_name = lookup_disk_dev_name(node_path)) == NULL) {
dev_name_lookup_err = 1;
goto out;
}
} else if (strcmp(subclass, ESC_NETWORK) == 0) {
if ((dev_name = lookup_network_dev_name(node_path, driver_name))
== NULL) {
dev_name_lookup_err = 1;
goto out;
}
} else if (strcmp(subclass, ESC_PRINTER) == 0) {
if ((dev_name = lookup_printer_dev_name(node_path)) == NULL) {
dev_name_lookup_err = 1;
goto out;
}
} else if (strcmp(subclass, ESC_LOFI) == 0) {
if (strcmp(class, EC_DEV_ADD) == 0 && minor == NULL)
minor = "disk,raw";
if (minor == NULL || strstr(minor, "raw") == NULL) {
nvlist_free(nvl);
return (NULL);
}
if ((dev_name = lookup_lofi_dev_name(node_path, minor)) ==
NULL) {
dev_name_lookup_err = 1;
goto out;
}
}
if (dev_name) {
if ((err = nvlist_add_string(nvl, DEV_NAME, dev_name)) != 0)
goto out;
free(dev_name);
dev_name = NULL;
}
if ((err = nvlist_add_string(nvl, DEV_DRIVER_NAME, driver_name)) != 0)
goto out;
if ((err = nvlist_add_int32(nvl, DEV_INSTANCE, instance)) != 0)
goto out;
if (strcmp(class, EC_DEV_ADD) == 0) {
count = 0;
for (prop = di_prop_next(node, DI_PROP_NIL);
prop != DI_PROP_NIL && count < MAX_PROP_COUNT;
prop = di_prop_next(node, prop)) {
if (di_prop_devt(prop) != DDI_DEV_T_NONE)
continue;
if ((x = add_property(nvl, prop)) == 0)
count++;
else if (x == -1) {
if ((prop_name = di_prop_name(prop)) == NULL)
prop_name = "";
err_print(PROP_ADD_FAILED, prop_name);
goto out;
}
}
}
return (nvl);
out:
nvlist_free(nvl);
if (dev_name)
free(dev_name);
if (dev_name_lookup_err) {
if (strcmp(subclass, ESC_LOFI) != 0)
err_print(DEV_NAME_LOOKUP_FAILED, node_path);
} else {
err_print(BUILD_EVENT_ATTR_FAILED, (err) ? strerror(err) : "");
}
return (NULL);
}
static void
log_event(char *class, char *subclass, nvlist_t *nvl)
{
sysevent_id_t eid;
if (sysevent_post_event(class, subclass, "SUNW", DEVFSADMD,
nvl, &eid) != 0) {
err_print(LOG_EVENT_FAILED, strerror(errno));
}
}
static void
enqueue_sysevent(char *class, char *subclass, nvlist_t *nvl)
{
syseventq_t *tmp;
if ((tmp = s_zalloc(sizeof (*tmp))) == NULL)
return;
tmp->class = s_strdup(class);
tmp->subclass = s_strdup(subclass);
tmp->nvl = nvl;
(void) mutex_lock(&syseventq_mutex);
if (syseventq_front != NULL)
syseventq_front->next = tmp;
else
syseventq_back = tmp;
syseventq_front = tmp;
(void) mutex_unlock(&syseventq_mutex);
}
static void
process_syseventq()
{
(void) mutex_lock(&syseventq_mutex);
while (syseventq_back != NULL) {
syseventq_t *tmp = syseventq_back;
vprint(CHATTY_MID, "sending queued event: %s, %s\n",
tmp->class, tmp->subclass);
log_event(tmp->class, tmp->subclass, tmp->nvl);
if (tmp->class != NULL)
free(tmp->class);
if (tmp->subclass != NULL)
free(tmp->subclass);
nvlist_free(tmp->nvl);
syseventq_back = syseventq_back->next;
if (syseventq_back == NULL)
syseventq_front = NULL;
free(tmp);
}
(void) mutex_unlock(&syseventq_mutex);
}
static void
build_and_enq_event(char *class, char *subclass, char *node_path,
di_node_t node, char *minor)
{
nvlist_t *nvl;
vprint(CHATTY_MID, "build_and_enq_event(%s, %s, %s, 0x%8.8x)\n",
class, subclass, node_path, (int)node);
if (node != DI_NODE_NIL)
nvl = build_event_attributes(class, subclass, node_path, node,
di_driver_name(node), di_instance(node), minor);
else
nvl = build_event_attributes(class, subclass, node_path, node,
NULL, -1, minor);
if (nvl) {
enqueue_sysevent(class, subclass, nvl);
}
}
static int
is_blank(char *line)
{
for (; *line != '\0'; line++)
if (!isspace(*line))
return (0);
return (1);
}
static void
nfphash_create(void)
{
assert(nfp_hash == NULL);
nfp_hash = s_zalloc(NFP_HASH_SZ * sizeof (item_t *));
}
static int
nfphash_fcn(char *key)
{
int i;
uint64_t sum = 0;
for (i = 0; key[i] != '\0'; i++) {
sum += (uchar_t)key[i];
}
return (sum % NFP_HASH_SZ);
}
static item_t *
nfphash_lookup(char *key)
{
int index;
item_t *ip;
index = nfphash_fcn(key);
assert(index >= 0);
for (ip = nfp_hash[index]; ip; ip = ip->i_next) {
if (strcmp(ip->i_key, key) == 0)
return (ip);
}
return (NULL);
}
static void
nfphash_insert(char *key)
{
item_t *ip;
int index;
index = nfphash_fcn(key);
assert(index >= 0);
ip = s_zalloc(sizeof (item_t));
ip->i_key = s_strdup(key);
ip->i_next = nfp_hash[index];
nfp_hash[index] = ip;
}
static void
nfphash_destroy(void)
{
int i;
item_t *ip;
for (i = 0; i < NFP_HASH_SZ; i++) {
while (ip = nfp_hash[i]) {
nfp_hash[i] = ip->i_next;
free(ip->i_key);
free(ip);
}
}
free(nfp_hash);
nfp_hash = NULL;
}
static int
devname_kcall(int subcmd, void *args)
{
int error = 0;
switch (subcmd) {
case MODDEVNAME_LOOKUPDOOR:
error = modctl(MODDEVNAME, subcmd, (uintptr_t)args);
if (error) {
vprint(INFO_MID, "modctl(MODDEVNAME, "
"MODDEVNAME_LOOKUPDOOR) failed - %s\n",
strerror(errno));
}
break;
default:
error = EINVAL;
break;
}
return (error);
}
static void
devname_lookup_handler(void *cookie, char *argp, size_t arg_size,
door_desc_t *dp, uint_t n_desc)
{
int32_t error = 0;
door_cred_t dcred;
struct dca_impl dci;
uint8_t cmd;
sdev_door_res_t res;
sdev_door_arg_t *args;
if (argp == NULL || arg_size == 0) {
vprint(DEVNAME_MID, "devname_lookup_handler: argp wrong\n");
error = DEVFSADM_RUN_INVALID;
goto done;
}
vprint(DEVNAME_MID, "devname_lookup_handler\n");
if (door_cred(&dcred) != 0 || dcred.dc_euid != 0) {
vprint(DEVNAME_MID, "devname_lookup_handler: cred wrong\n");
error = DEVFSADM_RUN_EPERM;
goto done;
}
args = (sdev_door_arg_t *)argp;
cmd = args->devfsadm_cmd;
vprint(DEVNAME_MID, "devname_lookup_handler: cmd %d\n", cmd);
switch (cmd) {
case DEVFSADMD_RUN_ALL:
dci.dci_root = "/";
dci.dci_minor = NULL;
dci.dci_driver = NULL;
dci.dci_error = 0;
dci.dci_flags = 0;
dci.dci_arg = NULL;
lock_dev();
update_drvconf((major_t)-1, 0);
dci.dci_flags |= DCA_FLUSH_PATHINST;
pre_and_post_cleanup(RM_PRE);
devi_tree_walk(&dci, DI_CACHE_SNAPSHOT_FLAGS, NULL);
error = (int32_t)dci.dci_error;
if (!error) {
pre_and_post_cleanup(RM_POST);
update_database = TRUE;
unlock_dev(SYNC_STATE);
update_database = FALSE;
} else {
if (DEVFSADM_DEBUG_ON) {
vprint(INFO_MID, "devname_lookup_handler: "
"DEVFSADMD_RUN_ALL failed\n");
}
unlock_dev(SYNC_STATE);
}
break;
default:
error = DEVFSADM_RUN_NOTSUP;
break;
}
done:
vprint(DEVNAME_MID, "devname_lookup_handler: error %d\n", error);
res.devfsadm_error = error;
(void) door_return((char *)&res, sizeof (struct sdev_door_res),
NULL, 0);
}
di_devlink_handle_t
devfsadm_devlink_cache(void)
{
return (devlink_cache);
}
int
devfsadm_reserve_id_cache(devlink_re_t re_array[], enumerate_file_t *head)
{
enumerate_file_t *entry;
int nelem;
int i;
int subex;
char *re;
size_t size;
regmatch_t *pmch;
for (i = 0; re_array[i].d_re; i++) {
if (re_array[i].d_subexp == 0) {
err_print("bad subexp value in RE: %s\n",
re_array[i].d_re);
goto bad_re;
}
re = re_array[i].d_re;
if (regcomp(&re_array[i].d_rcomp, re, REG_EXTENDED) != 0) {
err_print("reg. exp. failed to compile: %s\n", re);
goto bad_re;
}
subex = re_array[i].d_subexp;
nelem = subex + 1;
re_array[i].d_pmatch = s_malloc(sizeof (regmatch_t) * nelem);
}
entry = head ? head : enumerate_reserved;
for (; entry; entry = entry->er_next) {
if (entry->er_id) {
vprint(RSBY_MID, "entry %s already has ID %s\n",
entry->er_file, entry->er_id);
continue;
}
for (i = 0; re_array[i].d_re; i++) {
subex = re_array[i].d_subexp;
pmch = re_array[i].d_pmatch;
if (regexec(&re_array[i].d_rcomp, entry->er_file,
subex + 1, pmch, 0) != 0) {
continue;
}
size = pmch[subex].rm_eo - pmch[subex].rm_so;
entry->er_id = s_malloc(size + 1);
(void) strncpy(entry->er_id,
&entry->er_file[pmch[subex].rm_so], size);
entry->er_id[size] = '\0';
if (head) {
vprint(RSBY_MID, "devlink(%s) matches RE(%s). "
"ID is %s\n", entry->er_file,
re_array[i].d_re, entry->er_id);
} else {
vprint(RSBY_MID, "rsrv entry(%s) matches "
"RE(%s) ID is %s\n", entry->er_file,
re_array[i].d_re, entry->er_id);
}
break;
}
}
for (i = 0; re_array[i].d_re; i++) {
regfree(&re_array[i].d_rcomp);
assert(re_array[i].d_pmatch);
free(re_array[i].d_pmatch);
}
entry = head ? head : enumerate_reserved;
for (; entry; entry = entry->er_next) {
if (entry->er_id == NULL)
continue;
if (head) {
vprint(RSBY_MID, "devlink: %s\n", entry->er_file);
vprint(RSBY_MID, "ID: %s\n", entry->er_id);
} else {
vprint(RSBY_MID, "reserve file entry: %s\n",
entry->er_file);
vprint(RSBY_MID, "reserve file id: %s\n",
entry->er_id);
}
}
return (DEVFSADM_SUCCESS);
bad_re:
for (i = i-1; i >= 0; i--) {
regfree(&re_array[i].d_rcomp);
assert(re_array[i].d_pmatch);
free(re_array[i].d_pmatch);
}
return (DEVFSADM_FAILURE);
}
int
devfsadm_have_reserved()
{
return (enumerate_reserved ? 1 : 0);
}
int
devfsadm_is_reserved(devlink_re_t re_array[], char *devlink)
{
int match;
enumerate_file_t estruct = {NULL};
enumerate_file_t *entry;
match = 0;
estruct.er_file = devlink;
estruct.er_id = NULL;
estruct.er_next = NULL;
if (devfsadm_reserve_id_cache(re_array, &estruct) != DEVFSADM_SUCCESS) {
err_print("devfsadm_is_reserved: devlink (%s) does not "
"match RE\n", devlink);
return (0);
}
if (estruct.er_id == NULL) {
err_print("devfsadm_is_reserved: ID derived from devlink %s "
"is NULL\n", devlink);
return (0);
}
entry = enumerate_reserved;
for (; entry; entry = entry->er_next) {
if (entry->er_id == NULL)
continue;
if (strcmp(entry->er_id, estruct.er_id) != 0)
continue;
match = 1;
vprint(RSBY_MID, "reserve file entry (%s) and devlink (%s) "
"match\n", entry->er_file, devlink);
break;
}
free(estruct.er_id);
return (match);
}
