scsi/common/cfga_cvt.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include "cfga_scsi.h"

typedef struct {
	char *dyncomp;
	char *devlink;
	int l_errno;
	scfga_ret_t ret;
} dyn_t;

typedef struct {
	scfga_recur_t (*devlink_to_dyncomp_p)(dyn_t *dyntp);
	scfga_recur_t (*dyncomp_to_devlink_p)(dyn_t *dyntp);
} dynrules_t;

typedef struct {
	dyn_t *dynp;
	dynrules_t *rule_array;
	int nrules;
} dyncvt_t;

typedef struct {
	const char *hba_phys;
	const char *dyncomp;
	char *path;
	int l_errno;
	scfga_ret_t ret;
} devpath_t;


/* Function prototypes */

static int drv_to_hba_logid(di_node_t node, di_minor_t minor, void *arg);
static scfga_ret_t drv_dyn_to_devpath(const char *hba_phys,
    const char *dyncomp, char **pathpp, int *l_errnop);
static int do_drv_dyn_to_devpath(di_node_t node, void *arg);
static scfga_ret_t devlink_dyn_to_devpath(const char *hba_phys,
    const char *dyncomp, char **pathpp, int *l_errnop);

static scfga_recur_t disk_dyncomp_to_devlink(dyn_t *dyntp);
static scfga_recur_t tape_dyncomp_to_devlink(dyn_t *dyntp);
static scfga_recur_t def_dyncomp_to_devlink(dyn_t *dyntp);

static scfga_ret_t devlink_to_dyncomp(char *devlink,
    char **dyncompp, int *l_errnop);
static scfga_recur_t disk_devlink_to_dyncomp(dyn_t *dyntp);
static scfga_recur_t tape_devlink_to_dyncomp(dyn_t *dyntp);
static scfga_recur_t def_devlink_to_dyncomp(dyn_t *dyntp);
static scfga_ret_t drv_to_dyncomp(di_node_t node, const char *phys,
    char **dyncompp, int *l_errnop);
static scfga_ret_t get_hba_devlink(const char *hba_phys,
    char **hba_logpp, int *l_errnop);
static scfga_ret_t path_apid_dyn_to_path(const char *hba_phys, const char *dyn,
    char **pathpp, int *l_errnop);


/* Globals */

/*
 * Rules for converting between a devlink and logical ap_id and vice-versa
 * The default rules must be the last entry.
 */
static dynrules_t dyncvt_rules[] = {
	{disk_devlink_to_dyncomp,	disk_dyncomp_to_devlink},
	{tape_devlink_to_dyncomp,	tape_dyncomp_to_devlink},
	{def_devlink_to_dyncomp,	def_dyncomp_to_devlink}
};

#define	N_DYNRULES	(sizeof (dyncvt_rules)/sizeof (dyncvt_rules[0]))

/*
 * Numbering of disk slices is assumed to be 0 through n - 1
 */
typedef struct {
	char *prefix;
	int nslices;
} slice_t;

static slice_t disk_slices[] = {
	{"s", 16},
	{"p", 5},
};

#define	N_SLICE_TYPES	(sizeof (disk_slices) / sizeof (disk_slices[0]))

static const char *tape_modes[] = {
	"",
	"b", "bn",
	"c", "cb", "cbn", "cn",
	"h", "hb", "hbn", "hn",
	"l", "lb", "lbn", "ln",
	"m", "mb", "mbn", "mn",
	"n",
	"u", "ub", "ubn", "un"
};

#define	N_TAPE_MODES	(sizeof (tape_modes) / sizeof (tape_modes[0]))


/* Various conversions routines */

/*
 * Generates the HBA logical ap_id from physical ap_id.
 */
scfga_ret_t
make_hba_logid(const char *hba_phys, char **hba_logpp, int *l_errnop)
{
	walkarg_t u;
	pathm_t pmt = {NULL};
	scfga_ret_t ret;


	if (*hba_logpp != NULL) {
		return (SCFGA_ERR);
	}

	/* A devlink for the HBA may or may not exist */
	if (get_hba_devlink(hba_phys, hba_logpp, l_errnop) == SCFGA_OK) {
		assert(*hba_logpp != NULL);
		return (SCFGA_OK);
	}

	/*
	 * No devlink based logical ap_id.
	 * Try driver name and instance number.
	 */
	u.minor_args.nodetype = DDI_NT_SCSI_ATTACHMENT_POINT;
	u.minor_args.fcn = drv_to_hba_logid;

	pmt.phys = (char *)hba_phys;
	pmt.ret = SCFGA_APID_NOEXIST;

	errno = 0;
	ret = walk_tree(pmt.phys, &pmt, DINFOMINOR | DINFOPROP, &u,
	    SCFGA_WALK_MINOR, &pmt.l_errno);
	if (ret == SCFGA_OK && (ret = pmt.ret) == SCFGA_OK) {
		assert(pmt.log != NULL);
		*hba_logpp = pmt.log;
		return (SCFGA_OK);
	}

	/* failed to create logical ap_id */
	if (pmt.log != NULL) {
		S_FREE(pmt.log);
	}


	*l_errnop = pmt.l_errno;
	return (ret);
}

static scfga_ret_t
get_hba_devlink(const char *hba_phys, char **hba_logpp, int *l_errnop)
{
	size_t len;
	scfga_ret_t ret;
	int match_minor = 1;

	ret = physpath_to_devlink((char *)hba_phys, hba_logpp,
	    l_errnop, match_minor);
	if (ret != SCFGA_OK) {
		return (ret);
	}

	assert(*hba_logpp != NULL);

	/* Remove the "/dev/cfg/"  prefix */
	len = strlen(CFGA_DEV_DIR SLASH);

	(void) memmove(*hba_logpp, *hba_logpp + len,
	    strlen(*hba_logpp + len) + 1);

	return (SCFGA_OK);
}

/* Make logical name for HBA  based on driver and instance */
static int
drv_to_hba_logid(di_node_t node, di_minor_t minor, void *arg)
{
	int inst;
	char *drv, *mn, *log;
	pathm_t *ptp;
	const size_t loglen = MAXPATHLEN;

	ptp = (pathm_t *)arg;

	errno = 0;

	mn = di_minor_name(minor);
	drv = di_driver_name(node);
	inst = di_instance(node);
	log = calloc(1, loglen);

	if (mn != NULL && drv != NULL && inst != -1 && log != NULL) {
		/* Count does not include terminating NULL */
		if (snprintf(log, loglen, "%s%d:%s", drv, inst, mn) < loglen) {
			ptp->ret = SCFGA_OK;
			ptp->log = log;
			return (DI_WALK_TERMINATE);
		}
	}

	S_FREE(log);
	return (DI_WALK_CONTINUE);
}

/*
 * Given a bus or device ap_id <hba_phys, dyncomp>, returns the physical
 * path in pathpp.
 * Returns: SCFGA_APID_NOEXIST if the path does not exist.
 */

scfga_ret_t
apid_to_path(
	const char *hba_phys,
	const char *dyncomp,
	char **pathpp,
	int *l_errnop)
{
	scfga_ret_t ret;

	if (*pathpp != NULL) {
		return (SCFGA_LIB_ERR);
	}

	/* If a bus, the physical ap_id is the physical path */
	if (dyncomp == NULL) {
		if ((*pathpp = strdup(hba_phys)) == NULL) {
			*l_errnop = errno;
			return (SCFGA_LIB_ERR);
		}
		return (SCFGA_OK);
	}

	/* Dynamic component exists, we have a device */

	/*
	 * If the dynamic component has a '/', it was derived from a devlink
	 * Else it was derived from driver name and instance number.
	 * If it is pathinfo instance number based ap id, it will have a format
	 * path#.???.
	 */
	if (strchr(dyncomp, '/') != NULL) {
		ret = devlink_dyn_to_devpath(hba_phys, dyncomp, pathpp,
		    l_errnop);
	} else if (strstr(dyncomp, PATH_APID_DYN_SEP) != NULL) {
		ret = path_apid_dyn_to_path(hba_phys, dyncomp, pathpp,
		    l_errnop);
	} else {
		ret = drv_dyn_to_devpath(hba_phys, dyncomp, pathpp, l_errnop);
	}
	assert(ret != SCFGA_OK || *pathpp != NULL);


	return (ret);
}

/*
 * Get the devfs path of pathinfo node that is associated with
 * the given dynamic component.
 *
 * input
 *   hba_phys: physical path of HBA
 *   dyn : bus address of pathinfo node
 * output:
 *   pathpp: devfs path of the pathinfo node.
 */
static scfga_ret_t
path_apid_dyn_to_path(
	const char *hba_phys,
	const char *dyn,
	char **pathpp,
	int *l_errnop)
{

	di_node_t   root, walk_root;
	di_path_t   pi_node = DI_PATH_NIL;
	char	    *root_path, *devpath, *cp;
	int	    len;

	*l_errnop = 0;

	/* *pathpp should be NULL if pathpp is not NULL. */
	if ((hba_phys == NULL) || (pathpp != NULL) && (*pathpp != NULL)) {
		return (SCFGA_LIB_ERR);
	}

	if ((root_path = strdup(hba_phys)) == NULL) {
		*l_errnop = errno;
		return (SCFGA_LIB_ERR);
	}

	/* Fix up path for di_init() */
	len = strlen(DEVICES_DIR);
	if (strncmp(root_path, DEVICES_DIR SLASH,
	    len + strlen(SLASH)) == 0) {
		cp = root_path + len;
		(void) memmove(root_path, cp, strlen(cp) + 1);
	} else if (*root_path != '/') {
		*l_errnop = 0;
		S_FREE(root_path);
		return (SCFGA_ERR);
	}

	/* Remove dynamic component if any */
	if ((cp = GET_DYN(root_path)) != NULL) {
		*cp = '\0';
	}

	/* Remove minor name if any */
	if ((cp = strrchr(root_path, ':')) != NULL) {
		*cp = '\0';
	}

	/*
	 * Cached snapshots are always rooted at "/"
	 */

	/* Get a snapshot */
	if ((root = di_init("/", DINFOCACHE)) == DI_NODE_NIL) {
		*l_errnop = errno;
		S_FREE(root_path);
		return (SCFGA_ERR);
	}

	/*
	 * Lookup the subtree of interest
	 */
	walk_root = di_lookup_node(root, root_path);

	if (walk_root == DI_NODE_NIL) {
		*l_errnop = errno;
		di_fini(root);
		S_FREE(root_path);
		return (SCFGA_LIB_ERR);
	}

	S_FREE(root_path);

	if ((pi_node = di_path_next_client(walk_root, pi_node)) ==
	    DI_PATH_NIL) {
		di_fini(root);
		return (SCFGA_APID_NOEXIST);
	}

	/*
	 * now parse the path info node.
	 */
	do {
		/* check the length first. */
		if (strlen(di_path_bus_addr(pi_node)) != strlen(dyn)) {
			continue;
		}

		if (strcmp(di_path_bus_addr(pi_node), dyn) == 0) {
			/* get the devfspath of pathinfo node. */
			devpath = di_path_devfs_path(pi_node);
			if (devpath == NULL) {
				*l_errnop = errno;
				di_fini(root);
				return (SCFGA_ERR);
			}

			len = strlen(DEVICES_DIR) + strlen(devpath) + 1;
			*pathpp = calloc(1, len);
			if (*pathpp == NULL) {
				*l_errnop = errno;
				di_devfs_path_free(devpath);
				di_fini(root);
				return (SCFGA_ERR);
			} else {
				(void) snprintf(*pathpp, len, "%s%s",
				    DEVICES_DIR, devpath);
				di_devfs_path_free(devpath);
				di_fini(root);
				return (SCFGA_OK);
			}
		}
		pi_node = di_path_next_client(walk_root, pi_node);
	} while (pi_node != DI_PATH_NIL);

	di_fini(root);
	return (SCFGA_APID_NOEXIST);
}

static scfga_ret_t
drv_dyn_to_devpath(
	const char *hba_phys,
	const char *dyncomp,
	char **pathpp,
	int *l_errnop)
{
	walkarg_t u;
	devpath_t dpt = {NULL};
	scfga_ret_t ret;

	/* A device MUST have a dynamic component */
	if (dyncomp == NULL || *pathpp != NULL) {
		return (SCFGA_LIB_ERR);
	}

	u.node_args.flags = DI_WALK_CLDFIRST;
	u.node_args.fcn = do_drv_dyn_to_devpath;

	dpt.hba_phys = hba_phys;
	dpt.dyncomp = dyncomp;
	dpt.ret = SCFGA_APID_NOEXIST;

	ret = walk_tree(hba_phys, &dpt, DINFOCPYALL, &u,
	    SCFGA_WALK_NODE, &dpt.l_errno);

	if (ret == SCFGA_OK && (ret = dpt.ret) == SCFGA_OK) {
		assert(dpt.path != NULL);
		*pathpp = dpt.path;
		return (SCFGA_OK);
	}

	if (dpt.path != NULL) {
		S_FREE(dpt.path);
	}


	*l_errnop = dpt.l_errno;
	return (ret);
}

/* Converts a driver and instance number based logid into a physical path */
static int
do_drv_dyn_to_devpath(di_node_t node, void *arg)
{
	int inst, rv, match_minor;
	devpath_t *dptp;
	char *physpath, *drv;
	char *drvinst, *devpath;
	const size_t drvlen = MAXPATHLEN;
	size_t devlen;

	dptp = (devpath_t *)arg;

	assert(dptp->hba_phys != NULL && dptp->dyncomp != NULL);
	assert(dptp->path == NULL);

	/*
	 * Skip stub nodes
	 */
	if (IS_STUB_NODE(node)) {
		return (DI_WALK_CONTINUE);
	}

	errno = 0;

	drv = di_driver_name(node);
	inst = di_instance(node);
	physpath = di_devfs_path(node);
	if (drv == NULL || inst == -1 || physpath == NULL) {
		rv = DI_WALK_CONTINUE;
		goto out;
	}

	devlen = strlen(DEVICES_DIR) + strlen(physpath) + 1;

	devpath = calloc(1, devlen);
	drvinst = calloc(1, drvlen);
	if (devpath == NULL || drvinst == NULL) {
		dptp->l_errno = errno;
		dptp->ret = SCFGA_LIB_ERR;
		rv = DI_WALK_TERMINATE;
		goto out;
	}

	(void) snprintf(drvinst, drvlen, "%s%d", drv, inst);

	/* Create the physical path */
	(void) snprintf(devpath, devlen, "%s%s", DEVICES_DIR, physpath);

	/* Skip node if it is the HBA */
	match_minor = 0;
	if (!dev_cmp(dptp->hba_phys, devpath, match_minor)) {
		rv = DI_WALK_CONTINUE;
		goto out;
	}

	/* Compare the base and dynamic components */
	if (!hba_dev_cmp(dptp->hba_phys, devpath) &&
	    strcmp(dptp->dyncomp, drvinst) == 0) {
		dptp->ret = SCFGA_OK;
		dptp->path = devpath;
		rv = DI_WALK_TERMINATE;
	} else {
		rv =  DI_WALK_CONTINUE;
	}

	/*FALLTHRU*/
out:
	S_FREE(drvinst);
	if (physpath != NULL) di_devfs_path_free(physpath);
	if (dptp->ret != SCFGA_OK) S_FREE(devpath);
	return (rv);
}

/* readlink wrapper to ensure proper null termination of the results */
static int
s_readlink(char *link, char *buf, int len)
{
	int count;

	count = readlink(link, buf, len - 1);
	if (count != -1)
		buf[count] = '\0';
	return (count);
}

/* Converts a devlink based dynamic component to a path */
static scfga_ret_t
devlink_dyn_to_devpath(
	const char *hba_phys,
	const char *dyncomp,
	char **pathpp,
	int *l_errnop)
{
	dyn_t dynt = {NULL};
	int i;
	scfga_ret_t ret;
	char buf[PATH_MAX], *path;

	if (*pathpp != NULL) {
		return (SCFGA_LIB_ERR);
	}

	/* Convert the dynamic component to the corresponding devlink */
	dynt.dyncomp = (char *)dyncomp;
	dynt.ret = SCFGA_APID_NOEXIST;

	for (i = 0; i < N_DYNRULES; i++) {
		if (dyncvt_rules[i].dyncomp_to_devlink_p(&dynt)
		    != SCFGA_CONTINUE) {
			break;
		}
	}

	if (i >= N_DYNRULES) {
		dynt.ret = SCFGA_APID_NOEXIST;
	}

	if (dynt.ret != SCFGA_OK) {
		/* No symlink or error */
		return (dynt.ret);
	}

	assert(dynt.devlink != NULL);

	/*
	 * Follow devlink to get the physical path
	 * Note: Do not use realpath().	It will stat() device
	 *	and stat() fails under devfs if device is offline.
	 */
	errno = 0;
	if ((s_readlink(dynt.devlink, buf, PATH_MAX) == -1) ||
	    ((path = strstr(buf, "/devices/")) == NULL) ||
	    ((*pathpp = strdup(path)) == NULL)) {
		*l_errnop = errno;
		ret = SCFGA_LIB_ERR;
		goto out;
	}

	/* Compare base components as well */
	if (!hba_dev_cmp(hba_phys, path)) {
		ret = SCFGA_OK;
	} else {
		/* Mismatched base and dynamic component */
		*l_errnop = 0;
		ret = SCFGA_APID_NOEXIST;
	}

	/*FALLTHRU*/
out:
	S_FREE(dynt.devlink);
	if (ret != SCFGA_OK) S_FREE(*pathpp);
	return (ret);
}

scfga_ret_t
make_dyncomp(
	di_node_t node,
	const char *physpath,
	char **dyncompp,
	int *l_errnop)
{
	char *devlink = NULL;
	scfga_ret_t ret;
	di_minor_t minor;
	char *path;
	char pathbuf[MAXPATHLEN];
	int match_minor;

	if (*dyncompp != NULL) {
		return (SCFGA_LIB_ERR);
	}

	/* tag on minor name */
	minor = di_minor_next(node, DI_MINOR_NIL);
	if (minor == DI_MINOR_NIL) {
		match_minor = 0;
		path = (char *)physpath;
	} else {
		match_minor = 1;
		(void) snprintf(pathbuf, MAXPATHLEN, "%s:%s", physpath,
		    di_minor_name(minor));
		path = pathbuf;
	}

	/* Get the corresponding devlink from the physical path */
	ret = physpath_to_devlink(path, &devlink, l_errnop, match_minor);
	if (ret == SCFGA_OK) {
		assert(devlink != NULL);

		/* Create dynamic component. */
		ret = devlink_to_dyncomp(devlink, dyncompp, l_errnop);
		S_FREE(devlink);
		if (ret == SCFGA_OK) {
			assert(*dyncompp != NULL);
			return (SCFGA_OK);
		}

		/*
		 * Failed to get devlink based dynamic component.
		 * Try driver and instance
		 */
	}

	ret = drv_to_dyncomp(node, physpath, dyncompp, l_errnop);
	assert(ret != SCFGA_OK || *dyncompp != NULL);

	return (ret);
}

/*
 * Create a dynamic component of path ap_id for the given path info node.
 * The caller should free the buffer for the dynamic component.
 */
scfga_ret_t
make_path_dyncomp(
	di_path_t path,
	char **dyncompp,
	int *l_errnop)
{
	char *pi_addr;

	if ((path == DI_PATH_NIL) || (*dyncompp != NULL)) {
		return (SCFGA_LIB_ERR);
	}

	if ((pi_addr = di_path_bus_addr(path)) != NULL) {
		*dyncompp = calloc(1, strlen(pi_addr) + 1);
		if (*dyncompp == NULL) {
			*l_errnop = errno;
			return (SCFGA_LIB_ERR);
		}
		(void) strncpy(*dyncompp, pi_addr, strlen(pi_addr));
	} else {
		return (SCFGA_LIB_ERR);
	}

	return (SCFGA_OK);
}

/*ARGSUSED*/
static scfga_ret_t
drv_to_dyncomp(di_node_t node, const char *phys, char **dyncompp, int *l_errnop)
{
	char *drv;
	int inst;
	const int dynlen = MAXPATHLEN;
	scfga_ret_t ret;

	*l_errnop = 0;

	if ((*dyncompp = calloc(1, dynlen)) == NULL) {
		*l_errnop = errno;
		return (SCFGA_LIB_ERR);
	}

	drv = di_driver_name(node);
	inst = di_instance(node);
	if (drv != NULL && inst != -1) {
		if (snprintf(*dyncompp, dynlen, "%s%d", drv, inst) < dynlen) {
			return (SCFGA_OK);
		} else {
			ret = SCFGA_LIB_ERR;
		}
	} else {
		ret = SCFGA_APID_NOEXIST;
	}

	S_FREE(*dyncompp);
	return (ret);
}

/* Get a dynamic component from a physical path if possible */
static scfga_ret_t
devlink_to_dyncomp(char *devlink, char **dyncompp, int *l_errnop)
{
	int i;
	dyn_t dynt = {NULL};

	*l_errnop = 0;

	if (*dyncompp != NULL) {
		return (SCFGA_LIB_ERR);
	}

	/* Convert devlink to dynamic component */
	dynt.devlink = devlink;
	dynt.ret = SCFGA_APID_NOEXIST;

	for (i = 0; i < N_DYNRULES; i++) {
		if (dyncvt_rules[i].devlink_to_dyncomp_p(&dynt)
		    != SCFGA_CONTINUE) {
			break;
		}
	}

	if (i >= N_DYNRULES) {
		dynt.ret = SCFGA_APID_NOEXIST;
	}

	if (dynt.ret == SCFGA_OK) {
		assert(dynt.dyncomp != NULL);
		*dyncompp = dynt.dyncomp;
	}

	return (dynt.ret);
}

/* For disks remove partition information, (s or p) */
static scfga_recur_t
disk_devlink_to_dyncomp(dyn_t *dyntp)
{
	char *cp = NULL, *cp1 = NULL;

	assert(dyntp->devlink != NULL);

	dyntp->l_errno = 0;

	if (dyntp->dyncomp != NULL) {
		goto lib_err;
	}

	/* Check if a disk devlink */
	if (strncmp(dyntp->devlink, DEV_DSK SLASH, strlen(DEV_DSK SLASH)) &&
	    strncmp(dyntp->devlink, DEV_RDSK SLASH, strlen(DEV_RDSK SLASH))) {
		return (SCFGA_CONTINUE);
	}

	cp = dyntp->devlink + strlen(DEV_DIR SLASH);

	if ((dyntp->dyncomp = strdup(cp)) == NULL) {
		dyntp->l_errno = errno;
		goto lib_err;
	}

	/* Get the leaf component from dsk/cXtYdZsN */
	cp1 = strrchr(dyntp->dyncomp, '/');

	/* Blank out partition information */
	dyntp->ret = SCFGA_OK;
	if ((cp = strchr(cp1 + 1, 's')) != NULL) {
		*cp = '\0';
	} else if ((cp = strchr(cp1 + 1, 'p')) != NULL) {
		*cp = '\0';
	} else {
		S_FREE(dyntp->dyncomp);
		dyntp->ret = SCFGA_ERR;
	}

	return (SCFGA_TERMINATE);

lib_err:
	dyntp->ret = SCFGA_LIB_ERR;
	return (SCFGA_TERMINATE);
}


static scfga_recur_t
disk_dyncomp_to_devlink(dyn_t *dyntp)
{
	char buf[MAXPATHLEN], *cp = NULL;
	int i, j;
	size_t len;
	struct stat sbuf;

	assert(dyntp->dyncomp != NULL);

	dyntp->l_errno = 0;

	if (dyntp->devlink != NULL) {
		dyntp->ret = SCFGA_LIB_ERR;
		return (SCFGA_TERMINATE);
	}

	/* A disk link can only be from DEV_DSK (ignore /dev/rdsk) */
	if (strncmp(dyntp->dyncomp, DSK_DIR SLASH, strlen(DSK_DIR SLASH)) != 0)
		return (SCFGA_CONTINUE);	/* not a disk link */

	(void) snprintf(buf, sizeof (buf), "%s%s", DEV_DIR SLASH,
	    dyntp->dyncomp);

	len = strlen(buf);
	cp = buf + len;
	len = sizeof (buf) - len;

	for (i = 0; i < N_SLICE_TYPES; i++) {
		for (j = 0; j < disk_slices[i].nslices; j++) {
			if (snprintf(cp, len, "%s%d", disk_slices[i].prefix, j)
			    >= len) {
				continue;
			}

			if (lstat(buf, &sbuf) != -1 && S_ISLNK(sbuf.st_mode)) {
				if ((dyntp->devlink = strdup(buf)) == NULL) {
					dyntp->l_errno = errno;
					dyntp->ret = SCFGA_LIB_ERR;
					return (SCFGA_TERMINATE);
				}
				dyntp->ret = SCFGA_OK;
				return (SCFGA_TERMINATE);
			}
		}
	}

	dyntp->ret = SCFGA_APID_NOEXIST;
	return (SCFGA_TERMINATE);
}

/* For tapes, remove mode(minor) information from link */
static scfga_recur_t
tape_devlink_to_dyncomp(dyn_t *dyntp)
{
	char *cp = NULL;

	assert(dyntp->devlink != NULL);

	dyntp->l_errno = 0;

	if (dyntp->dyncomp != NULL) {
		goto lib_err;
	}

	if (strncmp(dyntp->devlink, DEV_RMT SLASH, strlen(DEV_RMT SLASH))) {
		return (SCFGA_CONTINUE);	/* not a tape */
	}

	cp = dyntp->devlink + strlen(DEV_DIR SLASH);
	if ((dyntp->dyncomp = strdup(cp)) == NULL) {
		dyntp->l_errno = errno;
		goto lib_err;
	}

	/* Get the leaf component from rmt/xyz */
	cp = strrchr(dyntp->dyncomp, '/');

	/* Remove the mode part */
	while (isdigit(*(++cp))) {
	};
	*cp = '\0';


	dyntp->ret = SCFGA_OK;
	return (SCFGA_TERMINATE);

lib_err:
	dyntp->ret = SCFGA_LIB_ERR;
	return (SCFGA_TERMINATE);
}

static scfga_recur_t
tape_dyncomp_to_devlink(dyn_t *dyntp)
{
	char buf[MAXPATHLEN], *cp = NULL;
	int i;
	size_t len = 0;
	struct stat sbuf;

	assert(dyntp->dyncomp != NULL);

	dyntp->l_errno = 0;

	if (dyntp->devlink != NULL) {
		goto lib_err;
	}

	if (strncmp(dyntp->dyncomp, RMT_DIR SLASH, strlen(RMT_DIR SLASH))) {
		return (SCFGA_CONTINUE);	/* not a tape */
	}

	/* A tape device */
	(void) snprintf(buf, sizeof (buf), "%s%s", DEV_DIR SLASH,
	    dyntp->dyncomp);

	len = strlen(buf);
	cp = buf + len;
	len = sizeof (buf) - len;

	for (i = 0; i < N_TAPE_MODES; i++) {
		(void) snprintf(cp, len, "%s", tape_modes[i]);

		if (lstat(buf, &sbuf) != -1 && S_ISLNK(sbuf.st_mode)) {
			if ((dyntp->devlink = strdup(buf)) == NULL) {
				dyntp->l_errno = errno;
				goto lib_err;
			}
			dyntp->ret = SCFGA_OK;
			return (SCFGA_TERMINATE);
		}
	}

	dyntp->ret = SCFGA_APID_NOEXIST;
	return (SCFGA_TERMINATE);

lib_err:
	dyntp->ret = SCFGA_LIB_ERR;
	return (SCFGA_TERMINATE);

}

/*
 * Default rules
 */
static scfga_recur_t
def_devlink_to_dyncomp(dyn_t *dyntp)
{
	size_t len = 0;
	char *cp = NULL;

	assert(dyntp->devlink != NULL);

	dyntp->l_errno = 0;

	if (dyntp->dyncomp != NULL) {
		dyntp->ret = SCFGA_LIB_ERR;
		return (SCFGA_TERMINATE);
	}

	/* Is it a link in DEV_DIR directory ? */
	len = strlen(DEV_DIR SLASH);
	if (strncmp(dyntp->devlink, DEV_DIR SLASH, len)) {
		return (SCFGA_CONTINUE);
	}

	/* Check if this is a top level devlink */
	if (strchr(dyntp->devlink + len, '/') != NULL) {
		/* not top level - Remove DEV_DIR SLASH prefix */
		cp = dyntp->devlink + len;
	} else {
		/* top level, leave DEV_DIR SLASH part in */
		cp = dyntp->devlink;
	}

	if ((dyntp->dyncomp = strdup(cp)) == NULL) {
		dyntp->l_errno = errno;
		dyntp->ret = SCFGA_LIB_ERR;
	} else {
		dyntp->ret = SCFGA_OK;
	}

	return (SCFGA_TERMINATE);

}

static scfga_recur_t
def_dyncomp_to_devlink(dyn_t *dyntp)
{
	struct stat sbuf;
	int top;
	size_t prelen, linklen;

	assert(dyntp->dyncomp != NULL);

	dyntp->l_errno = 0;

	if (dyntp->devlink != NULL) {
		goto lib_err;
	}

	prelen = strlen(DEV_DIR SLASH);
	linklen = strlen(dyntp->dyncomp) + 1;

	/*
	 * Check if the dynamic component was derived from a top level entry
	 * in "/dev"
	 */
	if (strncmp(dyntp->dyncomp, DEV_DIR SLASH, prelen) == 0) {
		top = 1;
	} else if (*dyntp->dyncomp != '/' && linklen > 1 &&
	    strchr(dyntp->dyncomp + 1, '/') != NULL) {
		top = 0;
		linklen += prelen;  /* The "/dev/" needs to be prepended */
	} else {
		/* Not a dynamic component we handle */
		return (SCFGA_CONTINUE);
	}

	if ((dyntp->devlink = calloc(1, linklen)) == NULL) {
		dyntp->l_errno = errno;
		goto lib_err;
	}

	*dyntp->devlink = '\0';
	if (!top) {
		(void) strcpy(dyntp->devlink, DEV_DIR SLASH);
	}
	(void) strcat(dyntp->devlink, dyntp->dyncomp);

	if (lstat(dyntp->devlink, &sbuf) != -1 && S_ISLNK(sbuf.st_mode)) {
		dyntp->ret = SCFGA_OK;
		return (SCFGA_TERMINATE);
	}


	S_FREE(dyntp->devlink);
	return (SCFGA_CONTINUE);

lib_err:
	dyntp->ret = SCFGA_LIB_ERR;
	return (SCFGA_TERMINATE);
}