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);
}