/*
 * 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) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <scsi/libses.h>
#include "ses_impl.h"

#define NEXT_ED(eip)    \
        ((ses2_ed_impl_t *)((uint8_t *)(eip) +  \
            ((eip)->st_hdr.sehi_ed_len + sizeof (ses2_ed_hdr_impl_t))))

static ses_node_t *
ses_find_enclosure(ses_snap_t *sp, uint64_t number)
{
        ses_node_t *np;

        for (np = sp->ss_root->sn_first_child; np != NULL;
            np = np->sn_next_sibling) {
                ASSERT(np->sn_type == SES_NODE_ENCLOSURE);
                if (np->sn_enc_num == number)
                        return ((ses_node_t *)np);
        }

        return (NULL);
}

/*
 * ses_snap_primary_enclosure() finds the primary enclosure for
 * the supplied ses_snap_t.
 */
ses_node_t *
ses_snap_primary_enclosure(ses_snap_t *sp)
{
        return (ses_find_enclosure(sp, 0));
}

void
ses_node_teardown(ses_node_t *np)
{
        ses_node_t *rp;

        if (np == NULL)
                return;

        for (; np != NULL; np = rp) {
                ses_node_teardown(np->sn_first_child);
                rp = np->sn_next_sibling;
                nvlist_free(np->sn_props);
                ses_free(np);
        }
}

static ses_node_t *
ses_node_alloc(ses_snap_t *sp, ses_node_t *pnp)
{
        ses_node_t *np;

        np = ses_zalloc(sizeof (ses_node_t));
        if (np == NULL)
                goto fail;
        if (nvlist_alloc(&np->sn_props, NV_UNIQUE_NAME, 0) != 0)
                goto fail;

        np->sn_snapshot = sp;
        np->sn_id = sp->ss_n_nodes++;

        if (pnp == NULL) {
                ASSERT(sp->ss_root == NULL);
                sp->ss_root = np;
        } else {
                np->sn_parent = pnp;
                np->sn_prev_sibling = pnp->sn_last_child;

                if (pnp->sn_first_child == NULL)
                        pnp->sn_first_child = np;
                else
                        pnp->sn_last_child->sn_next_sibling = np;

                pnp->sn_last_child = np;
        }

        return (np);

fail:
        ses_free(np);
        ses_node_teardown(sp->ss_root);
        sp->ss_root = NULL;
        return (NULL);
}

/*
 * Parse element type descriptor.
 */
static int
elem_parse_td(ses2_td_hdr_impl_t *tip, const char *tp, nvlist_t *nvl)
{
        int nverr;

        if (tp != NULL)
                SES_NV_ADD(fixed_string, nverr, nvl, SES_PROP_CLASS_DESCRIPTION,
                    tp, tip->sthi_text_len);

        return (0);
}


/*
 * Build a skeleton tree of nodes in the given snapshot.  This is the heart of
 * libses, and is responsible for parsing the config page into a tree and
 * populating nodes with data from the config page.
 */
static int
ses_build_snap_skel(ses_snap_t *sp)
{
        ses2_ed_impl_t *eip;
        ses2_td_hdr_impl_t *tip, *ftip;
        ses_node_t *np, *pnp, *cnp, *root;
        ses_snap_page_t *pp;
        ses2_config_page_impl_t *pip;
        int i, j, n_etds = 0;
        off_t toff;
        char *tp, *text;
        int err;
        uint64_t idx, eidx;

        pp = ses_snap_find_page(sp, SES2_DIAGPAGE_CONFIG, B_FALSE);
        if (pp == NULL)
                return (ses_error(ESES_BAD_RESPONSE, "target does not support "
                    "configuration diagnostic page"));
        pip = (ses2_config_page_impl_t *)pp->ssp_page;

        if (pp->ssp_len < offsetof(ses2_config_page_impl_t, scpi_data))
                return (ses_error(ESES_BAD_RESPONSE, "no enclosure "
                    "descriptors found"));

        /*
         * Start with the root of the tree, which is a target node, containing
         * just the SCSI inquiry properties.
         */
        if ((root = ses_node_alloc(sp, sp->ss_root)) == NULL)
                return (-1);

        root->sn_type = SES_NODE_TARGET;
        SES_NV_ADD(string, err, root->sn_props, SCSI_PROP_VENDOR,
            libscsi_vendor(sp->ss_target->st_target));
        SES_NV_ADD(string, err, root->sn_props, SCSI_PROP_PRODUCT,
            libscsi_product(sp->ss_target->st_target));
        SES_NV_ADD(string, err, root->sn_props, SCSI_PROP_REVISION,
            libscsi_revision(sp->ss_target->st_target));

        for (eip = (ses2_ed_impl_t *)pip->scpi_data, i = 0;
            i < pip->scpi_n_subenclosures + 1;
            i++, eip = NEXT_ED(eip)) {
                if (!SES_WITHIN_PAGE_STRUCT(eip, pp->ssp_page, pp->ssp_len))
                        break;

                n_etds += eip->st_hdr.sehi_n_etd_hdrs;
        }
        ftip = (ses2_td_hdr_impl_t *)eip;

        /*
         * There should really be only one Enclosure element possible for a
         * give subenclosure ID.  The standard never comes out and says this,
         * but it does describe this element as "managing the enclosure itself"
         * which implies rather strongly that the subenclosure ID field is that
         * of, well, the enclosure itself.  Since an enclosure can't contain
         * itself, it follows logically that each subenclosure has at most one
         * Enclosure type descriptor elements matching its ID.  Of course, some
         * enclosure firmware is buggy, so this may not always work out; in
         * this case we just ignore all but the first Enclosure-type element
         * with our subenclosure ID.
         */
        for (eip = (ses2_ed_impl_t *)pip->scpi_data, i = 0;
            i < pip->scpi_n_subenclosures + 1;
            i++, eip = NEXT_ED(eip)) {
                if (!SES_WITHIN_PAGE_STRUCT(eip, pp->ssp_page, pp->ssp_len))
                        break;

                if ((np = ses_node_alloc(sp, root)) == NULL)
                        return (-1);

                np->sn_type = SES_NODE_ENCLOSURE;
                np->sn_enc_num = eip->st_hdr.sehi_subenclosure_id;

                if (!SES_WITHIN_PAGE(eip, eip->st_hdr.sehi_ed_len +
                    sizeof (ses2_ed_hdr_impl_t),
                    pp->ssp_page, pp->ssp_len))
                        break;

                if (enc_parse_ed(eip, np->sn_props) != 0)
                        return (-1);
        }

        if (root->sn_first_child == NULL)
                return (ses_error(ESES_BAD_RESPONSE, "no enclosure "
                    "descriptors found"));

        tp = (char *)(ftip + n_etds);

        for (i = 0, toff = 0, idx = eidx = 0; i < n_etds; i++) {
                tip = ftip + i;

                if (!SES_WITHIN_PAGE_STRUCT(tip, pp->ssp_page, pp->ssp_len))
                        break;

                pnp = ses_find_enclosure(sp,
                    tip->sthi_subenclosure_id);
                if (pnp == NULL) {
                        idx += tip->sthi_max_elements + 1;
                        eidx += tip->sthi_max_elements;
                        toff += tip->sthi_text_len;
                        continue;
                }

                if (tip->sthi_element_type == SES_ET_ENCLOSURE) {
                        if (tip->sthi_max_elements == 0) {
                                SES_NV_ADD(uint64, err, pnp->sn_props,
                                    SES_PROP_ELEMENT_INDEX, idx);
                                pnp->sn_rootidx = idx;
                        } else {
                                SES_NV_ADD(uint64, err, pnp->sn_props,
                                    SES_PROP_ELEMENT_INDEX, idx + 1);
                                SES_NV_ADD(uint64, err, pnp->sn_props,
                                    SES_PROP_ELEMENT_ONLY_INDEX, eidx);
                                pnp->sn_rootidx = idx + 1;
                        }

                        if (tip->sthi_text_len > 0 &&
                            SES_WITHIN_PAGE(tp + toff, tip->sthi_text_len,
                            pp->ssp_page, pp->ssp_len)) {
                                text = tp + toff;
                                toff += tip->sthi_text_len;
                        } else {
                                text = NULL;
                        }

                        SES_NV_ADD(uint64, err, pnp->sn_props,
                            SES_PROP_ELEMENT_TYPE, SES_ET_ENCLOSURE);
                        if (enc_parse_td(tip, text, pnp->sn_props) != 0)
                                return (-1);

                        idx += tip->sthi_max_elements + 1;
                        eidx += tip->sthi_max_elements;
                        continue;
                }

                if ((np = ses_node_alloc(sp, pnp)) == NULL)
                        return (-1);

                np->sn_type = SES_NODE_AGGREGATE;
                np->sn_enc_num = tip->sthi_subenclosure_id;
                np->sn_parent = pnp;
                np->sn_rootidx = idx;

                SES_NV_ADD(uint64, err, np->sn_props,
                    SES_PROP_ELEMENT_INDEX, idx);
                SES_NV_ADD(uint64, err, np->sn_props,
                    SES_PROP_ELEMENT_TYPE, tip->sthi_element_type);

                if (tip->sthi_text_len > 0 &&
                    SES_WITHIN_PAGE(tp + toff, tip->sthi_text_len,
                    pp->ssp_page, pp->ssp_len)) {
                        text = tp + toff;
                        toff += tip->sthi_text_len;
                } else {
                        text = NULL;
                }

                if (elem_parse_td(tip, text, np->sn_props) != 0)
                        return (-1);

                idx += tip->sthi_max_elements + 1;

                if (tip->sthi_max_elements == 0)
                        continue;

                for (j = 0; j < tip->sthi_max_elements; j++) {
                        cnp = ses_node_alloc(sp, np);
                        if (cnp == NULL)
                                return (-1);

                        cnp->sn_type = SES_NODE_ELEMENT;
                        SES_NV_ADD(uint64, err, cnp->sn_props,
                            SES_PROP_ELEMENT_INDEX, np->sn_rootidx + j + 1);
                        SES_NV_ADD(uint64, err, cnp->sn_props,
                            SES_PROP_ELEMENT_ONLY_INDEX, eidx + j);
                        SES_NV_ADD(uint64, err, cnp->sn_props,
                            SES_PROP_ELEMENT_CLASS_INDEX, j);
                        SES_NV_ADD(uint64, err, cnp->sn_props,
                            SES_PROP_ELEMENT_TYPE, tip->sthi_element_type);
                }

                eidx += tip->sthi_max_elements;
        }

        np->sn_snapshot->ss_n_elem = idx;

        return (0);
}

static int
ses_fill_tree(ses_node_t *np)
{
        if (np == NULL)
                return (0);

        for (; np != NULL; np = np->sn_next_sibling) {
                if (ses_fill_node(np) != 0)
                        return (-1);
                if (ses_fill_tree(np->sn_first_child) != 0)
                        return (-1);
        }

        return (0);
}

int
ses_fill_snap(ses_snap_t *sp)
{
        if (ses_build_snap_skel(sp) != 0)
                return (-1);

        if (ses_fill_tree(sp->ss_root) != 0)
                return (-1);

        return (0);
}

ses_node_t *
ses_root_node(ses_snap_t *sp)
{
        return (sp->ss_root);
}

ses_node_t *
ses_node_sibling(ses_node_t *np)
{
        return (np->sn_next_sibling);
}

ses_node_t *
ses_node_prev_sibling(ses_node_t *np)
{
        return (np->sn_prev_sibling);
}

ses_node_t *
ses_node_parent(ses_node_t *np)
{
        return (np->sn_parent);
}

ses_node_t *
ses_node_child(ses_node_t *np)
{
        return (np->sn_first_child);
}

ses_node_type_t
ses_node_type(ses_node_t *np)
{
        return (np->sn_type);
}

ses_snap_t *
ses_node_snapshot(ses_node_t *np)
{
        return ((ses_snap_t *)np->sn_snapshot);
}

ses_target_t *
ses_node_target(ses_node_t *np)
{
        return (np->sn_snapshot->ss_target);
}

nvlist_t *
ses_node_props(ses_node_t *np)
{
        return (np->sn_props);
}

/*
 * A node identifier is a (generation, index) tuple that can be used to lookup a
 * node within this target at a later point.  This will be valid across
 * snapshots, though it will return failure if the generation count has changed.
 */
uint64_t
ses_node_id(ses_node_t *np)
{
        return (((uint64_t)np->sn_snapshot->ss_generation << 32) |
            np->sn_id);
}