schemes/hc/scheme.c

	scheme.c revision 35f59e50e9ef37e6f1bd3b018289d678d5551cab
/*
 * 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 (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <strings.h>
#include <fm/fmd_fmri.h>
#include <fm/libtopo.h>
#include <fm/topo_mod.h>

int
fmd_fmri_init(void)
{
    return (0);
}

void
fmd_fmri_fini(void)
{
}

ssize_t
fmd_fmri_nvl2str(nvlist_t *nvl, char *buf, size_t buflen)
{
    int err;
    uint8_t version;
    ssize_t len;
    topo_hdl_t *thp;
    char *str;

    if (nvlist_lookup_uint8(nvl, FM_VERSION, &version) != 0 ||
        version > FM_HC_SCHEME_VERSION)
        return (fmd_fmri_set_errno(EINVAL));

    if ((thp = fmd_fmri_topo_hold(TOPO_VERSION)) == NULL)
        return (fmd_fmri_set_errno(EINVAL));
    if (topo_fmri_nvl2str(thp, nvl, &str, &err) != 0) {
        fmd_fmri_topo_rele(thp);
        return (fmd_fmri_set_errno(EINVAL));
    }

    if (buf != NULL)
        len = snprintf(buf, buflen, "%s", str);
    else
        len = strlen(str);

    topo_hdl_strfree(thp, str);
    fmd_fmri_topo_rele(thp);

    return (len);
}

int
fmd_fmri_present(nvlist_t *nvl)
{
    int err, present;
    topo_hdl_t *thp;
    nvlist_t **hcprs;
    char *nm;
    uint_t hcnprs;

    err = nvlist_lookup_nvlist_array(nvl, FM_FMRI_HC_LIST, &hcprs, &hcnprs);
    if (err != 0)
        return (fmd_fmri_set_errno(EINVAL));
    err = nvlist_lookup_string(hcprs[0], FM_FMRI_HC_NAME, &nm);
    if (err != 0)
        return (fmd_fmri_set_errno(EINVAL));

    if ((thp = fmd_fmri_topo_hold(TOPO_VERSION)) == NULL)
        return (fmd_fmri_set_errno(EINVAL));
    present = topo_fmri_present(thp, nvl, &err);
    fmd_fmri_topo_rele(thp);

    return (present);
}

int
fmd_fmri_replaced(nvlist_t *nvl)
{
    int err, replaced;
    topo_hdl_t *thp;
    nvlist_t **hcprs;
    char *nm;
    uint_t hcnprs;

    err = nvlist_lookup_nvlist_array(nvl, FM_FMRI_HC_LIST, &hcprs, &hcnprs);
    if (err != 0)
        return (fmd_fmri_set_errno(EINVAL));
    err = nvlist_lookup_string(hcprs[0], FM_FMRI_HC_NAME, &nm);
    if (err != 0)
        return (fmd_fmri_set_errno(EINVAL));

    if ((thp = fmd_fmri_topo_hold(TOPO_VERSION)) == NULL)
        return (fmd_fmri_set_errno(EINVAL));
    replaced = topo_fmri_replaced(thp, nvl, &err);
    fmd_fmri_topo_rele(thp);

    return (replaced);
}

int
fmd_fmri_unusable(nvlist_t *nvl)
{
    int err, unusable;
    topo_hdl_t *thp;
    nvlist_t **hcprs;
    char *nm;
    uint_t hcnprs;

    if (nvlist_lookup_nvlist_array(nvl, FM_FMRI_HC_LIST,
        &hcprs, &hcnprs) != 0 ||
        nvlist_lookup_string(hcprs[0], FM_FMRI_HC_NAME, &nm) != 0)
        return (0);

    if ((thp = fmd_fmri_topo_hold(TOPO_VERSION)) == NULL)
        return (fmd_fmri_set_errno(EINVAL));
    unusable = topo_fmri_unusable(thp, nvl, &err);
    fmd_fmri_topo_rele(thp);

    return (unusable == 1 ? 1 : 0);
}

static int
auth_compare(nvlist_t *nvl1, nvlist_t *nvl2)
{
    const char *names[] = {
        FM_FMRI_AUTH_PRODUCT,
        FM_FMRI_AUTH_PRODUCT_SN,
        FM_FMRI_AUTH_CHASSIS,
        FM_FMRI_AUTH_SERVER,
        FM_FMRI_AUTH_DOMAIN,
        FM_FMRI_AUTH_HOST,
        NULL
    };
    const char **namep;
    nvlist_t *auth1 = NULL, *auth2 = NULL;

    (void) nvlist_lookup_nvlist(nvl1, FM_FMRI_AUTHORITY, &auth1);
    (void) nvlist_lookup_nvlist(nvl2, FM_FMRI_AUTHORITY, &auth2);
    if (auth1 == NULL && auth2 == NULL)
        return (0);
    if (auth1 == NULL || auth2 == NULL)
        return (1);

    for (namep = names; *namep != NULL; namep++) {
        char *val1 = NULL, *val2 = NULL;

        (void) nvlist_lookup_string(auth1, *namep, &val1);
        (void) nvlist_lookup_string(auth2, *namep, &val2);
        if (val1 == NULL && val2 == NULL)
            continue;
        if (val1 == NULL || val2 == NULL || strcmp(val1, val2) != 0)
            return (1);
    }

    return (0);
}

static int
hclist_contains(nvlist_t **erhcl, uint_t erhclsz, nvlist_t **eehcl,
    uint_t eehclsz)
{
    uint_t i;
    char *erval, *eeval;

    if (erhclsz > eehclsz || erhcl == NULL || eehcl == NULL)
        return (0);

    for (i = 0; i < erhclsz; i++) {
        (void) nvlist_lookup_string(erhcl[i], FM_FMRI_HC_NAME,
            &erval);
        (void) nvlist_lookup_string(eehcl[i], FM_FMRI_HC_NAME,
            &eeval);
        if (strcmp(erval, eeval) != 0)
            return (0);
        (void) nvlist_lookup_string(erhcl[i], FM_FMRI_HC_ID,
            &erval);
        (void) nvlist_lookup_string(eehcl[i], FM_FMRI_HC_ID,
            &eeval);
        if (strcmp(erval, eeval) != 0)
            return (0);
    }

    return (1);
}

static int
fru_compare(nvlist_t *r1, nvlist_t *r2)
{
    topo_hdl_t *thp;
    nvlist_t *f1 = NULL, *f2 = NULL;
    nvlist_t **h1 = NULL, **h2 = NULL;
    uint_t h1sz, h2sz;
    int err, rc = 1;

    if ((thp = fmd_fmri_topo_hold(TOPO_VERSION)) == NULL)
        return (fmd_fmri_set_errno(EINVAL));

    (void) topo_fmri_fru(thp, r1, &f1, &err);
    (void) topo_fmri_fru(thp, r2, &f2, &err);
    if (f1 != NULL && f2 != NULL) {
        (void) nvlist_lookup_nvlist_array(f1, FM_FMRI_HC_LIST, &h1,
            &h1sz);
        (void) nvlist_lookup_nvlist_array(f2, FM_FMRI_HC_LIST, &h2,
            &h2sz);
        if (h1sz == h2sz && hclist_contains(h1, h1sz, h2, h2sz) == 1)
            rc = 0;
    }

    fmd_fmri_topo_rele(thp);
    if (f1 != NULL)
        nvlist_free(f1);
    if (f2 != NULL)
        nvlist_free(f2);
    return (rc);
}

int
fmd_fmri_contains(nvlist_t *er, nvlist_t *ee)
{
    nvlist_t **erhcl, **eehcl;
    uint_t erhclsz, eehclsz;
    nvlist_t *hcsp;
    uint64_t eroff, eeoff;

    if (nvlist_lookup_nvlist_array(er, FM_FMRI_HC_LIST, &erhcl,
        &erhclsz) != 0 || nvlist_lookup_nvlist_array(ee,
        FM_FMRI_HC_LIST, &eehcl, &eehclsz) != 0)
        return (fmd_fmri_set_errno(EINVAL));

    /*
     * Check ee is further down the hc tree than er; er and ee have
     * the same auth and are on the same fru.
     */
    if (hclist_contains(erhcl, erhclsz, eehcl, eehclsz) == 0 ||
        auth_compare(er, ee) != 0 || fru_compare(er, ee) != 0)
        return (0);

    /*
     * return true if er is parent of ee, or er is not a page
     */
    if (erhclsz < eehclsz || nvlist_lookup_nvlist(er,
        FM_FMRI_HC_SPECIFIC, &hcsp) != 0 || (nvlist_lookup_uint64(hcsp,
        FM_FMRI_HC_SPECIFIC_OFFSET, &eroff) != 0 &&
        nvlist_lookup_uint64(hcsp, "asru-" FM_FMRI_HC_SPECIFIC_OFFSET,
        &eroff) != 0))
        return (1);

    /*
     * special case for page fmri: return true if ee is the same page
     */
    if (nvlist_lookup_nvlist(ee, FM_FMRI_HC_SPECIFIC, &hcsp) == 0 &&
        (nvlist_lookup_uint64(hcsp, FM_FMRI_HC_SPECIFIC_OFFSET,
        &eeoff) == 0 || nvlist_lookup_uint64(hcsp, "asru-"
        FM_FMRI_HC_SPECIFIC_OFFSET, &eeoff) == 0) && eroff == eeoff)
        return (1);

    return (0);
}

int
fmd_fmri_service_state(nvlist_t *nvl)
{
    uint8_t version;
    int err, service_state;
    topo_hdl_t *thp;

    if (nvlist_lookup_uint8(nvl, FM_VERSION, &version) != 0 ||
        version > FM_DEV_SCHEME_VERSION)
        return (fmd_fmri_set_errno(EINVAL));

    if ((thp = fmd_fmri_topo_hold(TOPO_VERSION)) == NULL)
        return (fmd_fmri_set_errno(EINVAL));
    err = 0;
    service_state = topo_fmri_service_state(thp, nvl, &err);
    fmd_fmri_topo_rele(thp);

    if (err != 0)
        return (FMD_SERVICE_STATE_UNKNOWN);
    else
        return (service_state);
}