lib: remove sparc-only libdscp

[unleashed.git] / usr / src / cmd / fm / modules / sun4u / cpumem-diagnosis / cmd_dp.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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I%     %E% SMI"

#include <strings.h>
#include <string.h>
#include <errno.h>
#include <fm/fmd_api.h>
#include <sys/fm/protocol.h>
#include <sys/async.h>
#include <sys/time.h>
#include <cmd.h>
#include <cmd_state.h>
#include <cmd_mem.h>
#include <cmd_dp.h>
#include <cmd_dp_page.h>
#include <libnvpair.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mem.h>
#include <sys/plat_datapath.h>

/*ARGSUSED*/
static nvlist_t *
dp_cpu_fmri(fmd_hdl_t *hdl, uint32_t cpuid, uint64_t serial_id)
{
        nvlist_t        *nvl = NULL;
        int             err;
        char sbuf[21]; /* sizeof (UINT64_MAX) + '\0' */

        if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
                return (NULL);

        err = nvlist_add_string(nvl, FM_FMRI_SCHEME, FM_FMRI_SCHEME_CPU);
        err |= nvlist_add_uint8(nvl, FM_VERSION, FM_CPU_SCHEME_VERSION);
        err |= nvlist_add_uint32(nvl, FM_FMRI_CPU_ID, cpuid);

        /*
         * Version 1 calls for a string-based serial number
         */
        (void) snprintf(sbuf, sizeof (sbuf), "%llX", (u_longlong_t)serial_id);
        err |= nvlist_add_string(nvl, FM_FMRI_CPU_SERIAL_ID, sbuf);
        if (err != 0) {
                nvlist_free(nvl);
                return (NULL);
        }
        return (nvl);
}

cmd_dp_t *
cmd_dp_lookup_fault(fmd_hdl_t *hdl, uint32_t cpuid)
{
        cmd_dp_t        *ptr;
        int             i, found = 0;

        /*
         * Scan the cmd.cmd_datapaths list to see if there is
         * a fault event present that impacts 'cpuid'
         */
        for (ptr = cmd_list_next(&cmd.cmd_datapaths); ptr != NULL;
            ptr = cmd_list_next(ptr)) {
                if (ptr->dp_erpt_type == DP_FAULT) {
                        for (i = 0; i < ptr->dp_ncpus; i++) {
                                if (ptr->dp_cpuid_list[i] == cpuid) {
                                        found = 1;
                                        break;
                                }
                        }
                }
                if (found)
                        break;
        }

        /*
         * Check if the FMRI for the found cpuid exists in the domain.
         * If it does not, it implies a DR has been done and this DP_FAULT
         * is no longer needed.
         */
        if (ptr != NULL) {
                nvlist_t        *nvl;

                nvl = dp_cpu_fmri(hdl, ptr->dp_cpuid_list[i],
                    ptr->dp_serid_list[i]);

                if (nvl != NULL) {
                        if (!fmd_nvl_fmri_present(hdl, nvl)) {
                                cmd_dp_destroy(hdl, ptr);
                                ptr = NULL;
                        }
                        nvlist_free(nvl);
                }
        }
        return (ptr);
}

cmd_dp_t *
cmd_dp_lookup_error(cmd_dp_t *dp)
{
        cmd_dp_t        *ptr;

        /*
         * Scan the cmd.cmd_datapaths list to see if there is
         * an existing error that matches 'dp'. A match is if
         * both dp_err and the base cpuid are identical
         */
        for (ptr = cmd_list_next(&cmd.cmd_datapaths); ptr != NULL;
            ptr = cmd_list_next(ptr)) {
                if (ptr->dp_erpt_type == DP_ERROR) {
                        if ((ptr->dp_err == dp->dp_err) &&
                            (ptr->dp_cpuid_list[0] == dp->dp_cpuid_list[0]))
                                return (ptr);
                }
        }
        return (NULL);
}

/*
 * Allocates an nvlist_t, and sets ASRU information according to
 * the cmd_dp_t provided.
 */
/*ARGSUSED*/
nvlist_t *
cmd_dp_setasru(fmd_hdl_t *hdl, cmd_dp_t *dpt)
{
        nvlist_t        *asru, *hcelem[DP_MAX_ASRUS];
        int             i, j, sz, err;
        char            buf[DP_MAX_BUF];

        sz = dpt->dp_ncpus;

        /* put ASRUs in an nvlist */
        for (i = 0; i < sz; i++) {
                (void) snprintf(buf, DP_MAX_BUF, "%d", dpt->dp_cpuid_list[i]);
                if (nvlist_alloc(&hcelem[i], NV_UNIQUE_NAME, 0) != 0)
                        return (NULL);

                err = nvlist_add_string(hcelem[i], FM_FMRI_HC_NAME,
                    FM_FMRI_CPU_ID);
                err |= nvlist_add_string(hcelem[i], FM_FMRI_HC_ID, buf);
                if (err != 0) {
                        for (j = 0; j < i + 1; j++)
                                nvlist_free(hcelem[j]);
                        return (NULL);
                }
        }

        /* put it in an HC scheme */
        if (nvlist_alloc(&asru, NV_UNIQUE_NAME, 0) != 0) {
                for (j = 0; j < sz; j++)
                        nvlist_free(hcelem[j]);
                return (NULL);
        }
        err = nvlist_add_uint8(asru, FM_VERSION, FM_HC_SCHEME_VERSION);
        err |= nvlist_add_string(asru, FM_FMRI_SCHEME, FM_FMRI_SCHEME_HC);
        err |= nvlist_add_string(asru, FM_FMRI_HC_ROOT, "");
        err |= nvlist_add_uint32(asru, FM_FMRI_HC_LIST_SZ, sz);
        err |= nvlist_add_nvlist_array(asru, FM_FMRI_HC_LIST, &hcelem[0],
            dpt->dp_ncpus);
        if (err != 0) {
                for (j = 0; j < sz; j++)
                        nvlist_free(hcelem[j]);
                nvlist_free(asru);
                return (NULL);
        }

        /* free up memory */
        for (j = 0; j < sz; j++)
                nvlist_free(hcelem[j]);

        /* return the ASRU */
        return (asru);
}

void
dp_buf_write(fmd_hdl_t *hdl, cmd_dp_t *dp)
{
        size_t sz;

        if ((sz = fmd_buf_size(hdl, NULL, dp->dp_bufname)) != 0 &&
            sz != sizeof (cmd_dp_pers_t))
                fmd_buf_destroy(hdl, NULL, dp->dp_bufname);

        fmd_buf_write(hdl, NULL, dp->dp_bufname, &dp->dp_pers,
            sizeof (cmd_dp_pers_t));
}

static cmd_dp_t *
dp_wrapv0(fmd_hdl_t *hdl, cmd_dp_pers_t *pers, size_t psz)
{
        cmd_dp_t *dp;

        if (psz != sizeof (cmd_dp_pers_t)) {
                fmd_hdl_abort(hdl, "size of state doesn't match size of "
                    "version 1 state (%u bytes).\n", sizeof (cmd_dp_pers_t));
        }

        dp = fmd_hdl_zalloc(hdl, sizeof (cmd_dp_t), FMD_SLEEP);
        bcopy(pers, dp, sizeof (cmd_dp_pers_t));
        fmd_hdl_free(hdl, pers, psz);
        return (dp);
}

void *
cmd_dp_restore(fmd_hdl_t *hdl, fmd_case_t *cp, cmd_case_ptr_t *ptr)
{
        cmd_dp_t *dp;

        for (dp = cmd_list_next(&cmd.cmd_datapaths); dp != NULL;
            dp = cmd_list_next(dp)) {
                if (dp->dp_case == cp)
                        break;
        }

        if (dp == NULL) {
                size_t dpsz;

                fmd_hdl_debug(hdl, "restoring dp from %s\n", ptr->ptr_name);

                if ((dpsz = fmd_buf_size(hdl, NULL, ptr->ptr_name)) == 0) {
                        if (fmd_case_solved(hdl, cp) ||
                            fmd_case_closed(hdl, cp)) {
                                fmd_hdl_debug(hdl, "dp %s from case %s not "
                                    "found. Case is already solved or closed\n",
                                    ptr->ptr_name, fmd_case_uuid(hdl, cp));
                                return (NULL);
                        } else {
                                fmd_hdl_abort(hdl, "dp referenced by case %s "
                                    "does not exist in saved state\n",
                                    fmd_case_uuid(hdl, cp));
                        }
                } else if (dpsz > CMD_DP_MAXSIZE ||
                    dpsz < CMD_DP_MINSIZE) {
                        fmd_hdl_abort(hdl, "dp buffer referenced by "
                            "case %s is out of bounds (is %u bytes, "
                            "max %u, min %u)\n", fmd_case_uuid(hdl, cp),
                            dpsz, CMD_DP_MAXSIZE, CMD_DP_MINSIZE);
                }

                if ((dp = cmd_buf_read(hdl, NULL, ptr->ptr_name, dpsz)) == NULL)
                        fmd_hdl_abort(hdl, "failed to read dp buf %s",
                            ptr->ptr_name);

                switch (dp->dp_version) {
                case CMD_DP_VERSION_0:
                        dp = dp_wrapv0(hdl, (cmd_dp_pers_t *)dp, dpsz);
                        break;
                default:
                        fmd_hdl_abort(hdl, "unknown version (found %d) "
                            "for dp state referenced by case %s.\n",
                            dp->dp_version, fmd_case_uuid(hdl, cp));
                        break;
                }

                dp->dp_case = cp;

                if (dp->dp_erpt_type == DP_ERROR) {
                        fmd_event_t *ep = fmd_case_getprincipal(hdl, cp);

                        ++cmd.cmd_dp_flag;

                        dp->dp_id = fmd_timer_install(hdl,
                            (void *)CMD_TIMERTYPE_DP, ep,
                            (hrtime_t)NANOSEC * (dp->dp_t_value + 120));
                }

                cmd_list_append(&cmd.cmd_datapaths, dp);
        }

        return (dp);
}

void
cmd_dp_close(fmd_hdl_t *hdl, void *arg)
{
        cmd_dp_destroy(hdl, arg);
}

void
cmd_dp_timeout(fmd_hdl_t *hdl, id_t id)
{
        cmd_dp_t                *dp;

        /* close case associated with the timer */
        for (dp = cmd_list_next(&cmd.cmd_datapaths); dp != NULL;
            dp = cmd_list_next(dp)) {
                if (dp->dp_id == id) {
                        cmd_dp_destroy(hdl, dp);
                        break;
                }
        }

        fmd_hdl_debug(hdl, "cmd_dp_timeout() complete\n");
}

/*
 * Validate by matching each cmd_dp_t cpu and serial id to what is
 * installed and active on this machine or domain. Delete the cmd_dp_t
 * if no match is made.
 */
void
cmd_dp_validate(fmd_hdl_t *hdl)
{
        cmd_dp_t *dp, *next;
        nvlist_t *nvl;
        int i, no_match;

        for (dp = cmd_list_next(&cmd.cmd_datapaths); dp != NULL; dp = next) {
                next = cmd_list_next(dp);

                for (i = 0, no_match = 0; i < dp->dp_ncpus; i++) {
                        nvl = dp_cpu_fmri(hdl, dp->dp_cpuid_list[i],
                            dp->dp_serid_list[i]);

                        if (nvl == NULL)
                                fmd_hdl_abort(hdl, "could not make CPU fmri");

                        if (!fmd_nvl_fmri_present(hdl, nvl))
                                no_match = 1;

                        nvlist_free(nvl);

                        if (no_match) {
                                cmd_dp_destroy(hdl, dp);
                                break;
                        }
                }
        }
}

static void
cmd_dp_free(fmd_hdl_t *hdl, cmd_dp_t *dp, int destroy)
{
        if (dp->dp_case != NULL)
                cmd_case_fini(hdl, dp->dp_case, destroy);

        if (destroy && dp->dp_erpt_type == DP_ERROR) {
                --cmd.cmd_dp_flag;
                /*
                 * If there are no active datapath events, replay any
                 * pages that were deferred.
                 */
                if (cmd.cmd_dp_flag == 0)
                        cmd_dp_page_replay(hdl);
        }

        if (destroy)
                fmd_buf_destroy(hdl, NULL, dp->dp_bufname);

        cmd_list_delete(&cmd.cmd_datapaths, dp);
        fmd_hdl_free(hdl, dp, sizeof (cmd_dp_t));
}

void
cmd_dp_destroy(fmd_hdl_t *hdl, cmd_dp_t *dp)
{
        cmd_dp_free(hdl, dp, FMD_B_TRUE);
}

/*ARGSUSED*/
int
cmd_dp_error(fmd_hdl_t *hdl)
{
        if (cmd.cmd_dp_flag)
                return (1);
        else
                return (0);
}

int
cmd_dp_get_mcid(uint64_t addr, int *mcid)
{
        int fd, rc;
        mem_info_t data;

        if ((fd = open("/dev/mem", O_RDONLY)) < 0)
                return (-1);

        data.m_addr = addr;
        data.m_synd = 0;
        if ((rc = ioctl(fd, MEM_INFO, &data)) < 0) {
                (void) close(fd);
                return (rc);
        }

        (void) close(fd);
        *mcid = data.m_mcid;

        return (0);
}

/*ARGSUSED*/
int
cmd_dp_fault(fmd_hdl_t *hdl, uint64_t addr)
{
        int mcid;

        if (cmd_dp_get_mcid(addr, &mcid) < 0)
                fmd_hdl_abort(hdl, "cmd_dp_get_mcid failed");

        if (cmd_dp_lookup_fault(hdl, mcid) != NULL)
                return (1);
        else
                return (0);
}

void
cmd_dp_fini(fmd_hdl_t *hdl)
{
        cmd_dp_t *dp;
        cmd_dp_defer_t *dpage;

        while ((dp = cmd_list_next(&cmd.cmd_datapaths)) != NULL)
                cmd_dp_free(hdl, dp, FMD_B_FALSE);

        while ((dpage = cmd_list_next(&cmd.cmd_deferred_pages)) != NULL) {
                cmd_list_delete(&cmd.cmd_deferred_pages, dpage);
                fmd_hdl_free(hdl, dpage, sizeof (cmd_dp_defer_t));
        }
}