hypervisor/src/common/src/res_mau.c

/*
* ========== Copyright Header Begin ==========================================
*
* Hypervisor Software File: res_mau.c
*
* Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
*
*  - Do no alter or remove copyright notices
*
*  - Redistribution and use of this software in source and binary forms, with
*    or without modification, are permitted provided that the following
*    conditions are met:
*
*  - Redistribution of source code must retain the above copyright notice,
*    this list of conditions and the following disclaimer.
*
*  - Redistribution in binary form must reproduce the above copyright notice,
*    this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
*    Neither the name of Sun Microsystems, Inc. or the names of contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
*     This software is provided "AS IS," without a warranty of any kind.
* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
* INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
* PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
* MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
* ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
* DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN
* OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR
* FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
* DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
* ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
* SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed, licensed or
* intended for use in the design, construction, operation or maintenance of
* any nuclear facility.
*
* ========== Copyright Header End ============================================
*/
/*
 * Copyright 2007 Sun Microsystems, Inc.         All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "@(#)res_mau.c  1.7     07/06/07 SMI"

#ifdef CONFIG_CRYPTO /* Compiled in if the CRYPTO option selected */

#include <stdarg.h>

#include <sys/htypes.h>
#include <traps.h>
#include <cache.h>
#include <mmu.h>
#include <sun4v/asi.h>
#include <vdev_intr.h>
#include <ncs.h>
#include <cyclic.h>
#include <support.h>
#include <strand.h>
#include <vcpu.h>
#include <guest.h>
#include <pcie.h>
#include <vdev_ops.h>
#include <fpga.h>
#include <ldc.h>
#include <config.h>
#include <offsets.h>
#include <hvctl.h>
#include <md.h>
#include <abort.h>
#include <hypervisor.h>
#include <proto.h>

/*
 * (re)-configuration code to handle HV MAU resources
 */

/*
 * resource processing support
 */

extern void c_unconfig_mau(vcpu_t *, guest_t *);
extern void c_setup_mau(vcpu_t *, uint64_t, config_t *);

static void res_mau_commit_config(mau_t *maup);
static void res_mau_commit_unconfig(mau_t *maup);
static void res_mau_commit_modify(mau_t *maup);

static hvctl_status_t res_mau_parse_1(bin_md_t *mdp, md_element_t *maunodep,
    hvctl_res_error_t *fail_codep, int *fail_res_idp);

static void setup_a_mau(vcpu_t *vcpup, mau_t *maup, uint64_t ino);

/*
 * mau support functions.
 */
void
res_mau_prep()
{
        mau_t   *mp;
        int     i;

        mp = config.config_m.maus;

        for (i = 0; i < NMAUS; i++, mp++) {
                mp->pip.res.flags = (mp->state == MAU_STATE_UNCONFIGURED) ?
                    RESF_Noop : RESF_Unconfig;
                mp->pip.cpuset = 0;
        }
}


hvctl_status_t
res_mau_parse(bin_md_t *mdp, hvctl_res_error_t *fail_codep,
                        md_element_t **failnodepp, int *fail_res_idp)
{
        md_element_t    *mdep;
        uint64_t        arc_token;
        uint64_t        node_token;
        md_element_t    *maunodep;

        mdp = (bin_md_t *)config.parse_hvmd;

        mdep = md_find_node(mdp, NULL, MDNAME(maus));
        if (mdep == NULL) {
                DBG_MAU(c_printf("Missing maus node in HVMD\n"));
                *failnodepp = NULL;
                *fail_res_idp = 0;
                return (HVctl_st_badmd);
        }

        arc_token = MDARC(MDNAME(fwd));
        node_token = MDNODE(MDNAME(mau));

        while (NULL != (mdep = md_find_node_by_arc(mdp, mdep,
            arc_token, node_token, &maunodep))) {
                hvctl_status_t status;
                status = res_mau_parse_1(mdp, maunodep, fail_codep,
                    fail_res_idp);
                if (status != HVctl_st_ok) {
                        *failnodepp = maunodep;
                        return (status);
                }
        }
        return (HVctl_st_ok);
}

hvctl_status_t
res_mau_parse_1(bin_md_t *mdp, md_element_t *maunodep,
                hvctl_res_error_t *fail_codep, int *fail_res_idp)
{
        uint64_t        strand_id, thread_id, mau_id, gid, ino;
        mau_t           *maup = NULL;
        md_element_t    *guestnodep, *cpunodep, *mdep;

        DBG_MAU(md_dump_node(mdp, maunodep));

        mdep = maunodep;

        while (NULL != (mdep = md_find_node_by_arc(mdp, mdep,
            MDARC(MDNAME(back)), MDNODE(MDNAME(cpu)), &cpunodep))) {

                if (!md_node_get_val(mdp, cpunodep, MDNAME(pid), &strand_id)) {
                        DBG_MAU(c_printf("Missing PID in cpu node\n"));
                        *fail_codep = HVctl_e_mau_missing_strandid;
                        goto fail;
                }

                if (strand_id >= NSTRANDS) {
                        DBG_MAU(c_printf("Invalid PID in cpu node\n"));
                        *fail_codep = HVctl_e_mau_invalid_strandid;
                        goto fail;
                }

                if (maup == NULL) {
                        mau_id = strand_id >> STRANDID_2_COREID_SHIFT;
                        ASSERT(mau_id < NMAUS);
                        maup = config.config_m.maus;
                        maup = &(maup[mau_id]);
                        maup->pip.cpuset = 0;
                        *fail_res_idp = mau_id;
                        DBG_MAU(c_printf("res_mau_parse_1(0x%x)\n", mau_id));
                }

                thread_id = strand_id & NSTRANDS_PER_CORE_MASK;

                maup->pip.cpuset |= (1 << thread_id);

                if (NULL == md_find_node_by_arc(mdp, cpunodep,
                    MDARC(MDNAME(back)), MDNODE(MDNAME(guest)),
                    &guestnodep)) {
                        DBG_MAU(c_printf("Missing back arc to guest node in "
                            "cpu node\n"));
                        *fail_codep = HVctl_e_mau_missing_guest;
                        goto fail;
                }

                if (!md_node_get_val(mdp, guestnodep, MDNAME(resource_id),
                    &gid)) {
                        DBG_MAU(c_printf(
                            "Missing resource_id in guest node\n"));
                        *fail_codep = HVctl_e_guest_missing_id;
                        goto fail;
                }
                if (gid >= NGUESTS) {
                        DBG_MAU(c_printf(
                            "Invalid resource_id in guest node\n"));
                        *fail_codep = HVctl_e_guest_invalid_id;
                        goto fail;
                }
                /* FIXME: check that all cpus belong to same guest */
                maup->pip.guestid = gid;
        }

        /* Get ino value for this mau */
        if (!md_node_get_val(mdp, maunodep, MDNAME(ino), &ino)) {
                DBG_MAU(c_printf("WARNING: Missing ino in mau node\n"));
                *fail_codep = HVctl_e_mau_missing_ino;
                goto fail;
        }

        DBG_MAU(c_printf("Virtual mau 0x%x in guest 0x%x ino 0x%x\n",
            mau_id, gid, ino));


        /*
         * Now determine the delta - if relevent...
         */
        maup->pip.pid = mau_id;
        maup->pip.ino = ino;

        /*
         * We can configure an unconfigured MAU.
         * Cannot (yet) support the dynamic re-binding of
         * a configured / running mau, except to modify the
         * set of vcpus bound to it, which is handled as part of unconfig
         * or config.
         */
        DBG_MAU(c_printf("\t\tCurrent mau status = 0x%x\n",     maup->state));

        if (maup->state == MAU_STATE_UNCONFIGURED) {
                DBG_MAU(c_printf("\t\tElected to config mau\n"));
                maup->pip.res.flags = RESF_Config;
        } else {
                if (maup->pid == maup->pip.pid &&
                    maup->guest->guestid == gid &&
                    maup->ino == ino &&
                    maup->cpuset != maup->pip.cpuset) {
                        DBG_MAU(c_printf("\t\tElected to modify mau\n"));
                        maup->pip.res.flags = RESF_Modify;
                } else if (maup->pid == maup->pip.pid &&
                    maup->guest->guestid == gid &&
                    maup->ino == ino) {
                        DBG_MAU(c_printf("\t\tElected to ignore mau\n"));
                        maup->pip.res.flags = RESF_Noop;
                } else {
                        DBG_MAU(c_printf("\t\tFailed MD update - no "
                            "rebind live\n"));
                        *fail_codep = HVctl_e_mau_rebind_na;
                        goto fail;
                }
        }

        return (HVctl_st_ok);
fail:;
        return (HVctl_st_badmd);
}

hvctl_status_t
res_mau_postparse(hvctl_res_error_t *res_error, int *fail_res_id)
{
        return (HVctl_st_ok);
}

void
res_mau_commit(int flag)
{
        mau_t   *mp;
        int     i;

        mp = config.config_m.maus;

        for (i = 0; i < NMAUS; i++, mp++) {
                /* if not this ops turn move on */
                DBG_MAU(c_printf("res_mau_commit: mauid 0x%x : state 0x%x : "
                    "flags 0x%x - opflag 0x%x\n",
                    mp->pid, mp->state, mp->pip.res.flags, flag));

                if (mp->pip.res.flags != flag)
                        continue;

                switch (mp->pip.res.flags) {
                case RESF_Noop:
                        DBG_MAU(c_printf("mau 0x%x : noop\n", i));
                        break;
                case RESF_Unconfig:
                        DBG_MAU(c_printf("mau 0x%x : unconfig\n", i));
                        res_mau_commit_unconfig(mp);
                        break;
                case RESF_Config:
                        DBG_MAU(c_printf("mau 0x%x : config\n", i));
                        res_mau_commit_config(mp);
                        break;
                case RESF_Rebind:
                        DBG_MAU(c_printf("mau 0x%x : rebind\n", i));
                        ASSERT(0);      /* not supported */
                        break;
                case RESF_Modify:
                        DBG_MAU(c_printf("mau 0x%x : modify\n", i));
                        res_mau_commit_modify(mp);
                        break;
                default:
                        ASSERT(0);
                }

                mp->pip.res.flags = RESF_Noop; /* cleanup */
        }
}

bool_t
strand_in_vcpu_list(uint64_t strand_id, vcpu_t *vcpu_list, uint64_t *found_idx)
{
        int i;

        for (i = 0; i < NVCPUS; ++i) {
                if (vcpu_list[i].strand && vcpu_list[i].strand->id ==
                    strand_id) {
                        if (found_idx != NULL)
                                *found_idx = i;
                        return (true);
                }
        }
        return (false);
}

void
res_mau_commit_config(mau_t *maup)
{
        guest_t         *guestp;
        vcpu_t          *cpup;
        uint64_t        strand_num, vcpu_num;
        int             i;

        DBG_MAU(c_printf("res_mau_commit_config\n"));

        /*
         * Assign the mau its bound vcpu.
         * Note: this does not schedule the mau.
         */
        maup->pid = maup->pip.pid;

        guestp = config.guests;
        guestp = &(guestp[maup->pip.guestid]);
        ASSERT(guestp->guestid == maup->pip.guestid);
        ASSERT(guestp->maus[maup->pid] == NULL);
        guestp->maus[maup->pid] = maup;

        /*
         * Initialise the remainder of the mau struct.  Need to do this
         * once for each cpu bound to this mau.
         */

        /*
         * Loop through the cpus attached to this mau.
         * FIXME: make independent of cpu arch
         */
        strand_num = maup->pid << STRANDID_2_COREID_SHIFT;
        for (i = 0; i < NSTRANDS_PER_CORE; ++i, ++strand_num) {
                /* Skip cpus not being bound to this mau */
                if ((maup->pip.cpuset & (1 << i)) == 0) {
                        DBG_MAU(c_printf("Skipping thread id %d for mau %d "
                            "(pip.cpuset 0x%x)\n",
                            i, maup->pid, maup->pip.cpuset));
                        continue;
                }
                cpup = config.vcpus;

                /* Convert strand to vid */
                if (strand_in_vcpu_list(strand_num, cpup, &vcpu_num)) {
                        cpup = &(cpup[vcpu_num]);
                } else {
                        DBG_MAU(c_printf(
                            "strand 0x%x not found!\n", strand_num));
                        c_hvabort();
                }

                cpup->maup = maup;

                DBG_MAU(c_printf("\tBinding mau (pid = 0x%x) to vcpu 0x%x on "
                    "strand 0x%x in guest 0x%x\n",
                    maup->pid, vcpu_num, strand_num, maup->pip.guestid));

                setup_a_mau(cpup, maup, maup->pip.ino);
                config_a_guest_device_vino(maup->guest, maup->pip.ino,
                    DEVOPS_VDEV);
        }
}

void
init_mau(mau_t *maup)
{
#ifdef ERRATA_192
        maup->store_in_progr = 0;
        maup->enable_cwq = 0;
#endif
        maup->queue.mq_base_ra = 0;
        maup->queue.mq_base = 0;
        maup->queue.mq_end = 0;
        maup->queue.mq_head = 0;
        maup->queue.mq_tail = 0;
        maup->queue.mq_nentries = 0;
        maup->queue.mq_busy = 0;
}

void
unconfig_strand_from_mau(mau_t *maup, uint64_t strand_num)
{
        int thread_id;

        /*
         * Check if already unconfigured!
         */
        ASSERT(maup->guest->maus[maup->pid] != NULL);
        ASSERT(maup->state != MAU_STATE_UNCONFIGURED);

        thread_id = strand_num & NSTRANDS_PER_CORE_MASK;

        /*
         * Force the cpu_active entry to 0.
         * It is possible to come through the unconfig sequence
         * without having gone through stop_mau.  However, we
         * assured that when we come into unconfig_mau that the
         * respective cpu is stopped.
         */
        maup->cpu_active[thread_id] = 0;

        /*
         * Remove cpu from MAU's cpuset and if this
         * is the last one, then clear the queue structure.
         */
        DBG_MAU(c_printf(
"\tunconfig_strand_from_mau: mau %d thread %d (strand %d) guest %d\n",
            maup->pid, thread_id, strand_num, maup->guest->guestid));

        maup->cpuset &= ~(1 << thread_id);

        DBG_MAU(c_printf("\tnew cpuset: %d\n", maup->cpuset));

        if (maup->cpuset == 0) {
                init_mau(maup);
                maup->state = MAU_STATE_UNCONFIGURED;
                maup->guest->maus[maup->pid] = NULL;
                maup->guest = NULL;
        }
}

void
res_mau_commit_unconfig(mau_t *maup)
{
        vcpu_t          *cpup;
        uint64_t        strand_num, vcpu_num;
        int i;

        ASSERT(maup->state == MAU_STATE_RUNNING ||
            maup->state == MAU_STATE_ERROR);

        ASSERT(maup->guest != NULL);

        strand_num = maup->pid << STRANDID_2_COREID_SHIFT;
        for (i = 0; i < NSTRANDS_PER_CORE; ++i, ++strand_num) {
                /* Skip cpus not bound to this mau */
                if ((maup->cpuset & (1 << i)) == 0) {
                        DBG_MAU(c_printf(
                            "Skipping thread id %d (strand 0x%x) for "
                            "mau %d (cpuset 0x%x)\n",
                            i, strand_num, maup->pid, maup->cpuset));
                        continue;
                }

                cpup = config.vcpus;

                /* Convert strand to vid */
                DBG_MAU(c_printf(
                    "\tUnconfig mau (pid = 0x%x) from strand 0x%x in "
                    "guest 0x%x\n", maup->pid, strand_num,
                    maup->guest->guestid));

                if (strand_in_vcpu_list(strand_num, cpup, &vcpu_num)) {
                        cpup = &(cpup[vcpu_num]);
                        DBG_MAU(c_printf("\tstrand 0x%x is vcpu 0x%x\n",
                            strand_num, vcpu_num));
                } else {
                        DBG_MAU(c_printf(
                            "strand 0x%x not found!\n", strand_num));
                        c_hvabort();
                }

                unconfig_a_guest_device_vino(maup->guest, maup->ino,
                    DEVOPS_VDEV);
                unconfig_strand_from_mau(maup, strand_num);
        }
}

vcpu_t *
mau_to_vcpu(mau_t *maup, int strand_id)
{
        vcpu_t *cpup;
        int i;

        /*
         * Walk all vcpus bound to guest which owns mau, and find
         * one with strand_id passed in.
         */
        for (i = 0; i < NVCPUS; ++i) {
                cpup = maup->guest->vcpus[i];

                /* Is vcpu mapped to guest? */
                if (cpup == NULL)
                        continue;

                ASSERT(cpup->strand != NULL);
                if (cpup->strand->id == strand_id) {
                        DBG_MAU(c_printf(
                            "\tmau_to_vcpu: mau %d strand %d is vcpu %d\n",
                            maup->pid, strand_id, cpup->vid));
                        return (cpup);
                }
        }

        return (NULL);
}

/*
 * The only allowed modification on a mau is the list of vcpus which
 * are bound to it.
 */
void
res_mau_commit_modify(mau_t *maup)
{
        uint64_t        strand_id, thread_id;

        ASSERT(maup->state == MAU_STATE_RUNNING ||
            maup->state == MAU_STATE_ERROR);
        ASSERT(maup->guest != NULL);

        /*
         * Compare old & new cpusets, configuring or unconfiguring
         * cpu->mau bindings as appropriate.
         */
        /*
         * We can't determine which cpu->mau bindings to unconfigure
         * by walking the available vcpus, as they've already been
         * unconfigured, so we find them by comparing the old & new
         * cpuset mask values.
         */
        strand_id = maup->pid << STRANDID_2_COREID_SHIFT;
        for (thread_id = 0; thread_id < NSTRANDS_PER_CORE;
            ++thread_id, ++strand_id) {
                uint64_t mask = 1LL << thread_id;

                if ((maup->cpuset & mask) == (maup->pip.cpuset & mask)) {
                        DBG_MAU(c_printf(
                            "\tIgnoring mau (pid = 0x%x) on strand "
                            "0x%x in guest 0x%x\n",
                            maup->pid, strand_id, maup->pip.guestid));
                        continue;
                }
                /* Configure? */
                if ((maup->pip.cpuset & mask) != 0) {
                        vcpu_t *cpup;

                        cpup = mau_to_vcpu(maup, strand_id);
                        ASSERT(cpup != NULL);
                        cpup->maup = maup;

                        DBG_MAU(c_printf("\tBinding mau (pid = 0x%x) to strand "
                            "0x%x in guest 0x%x\n",
                            maup->pid, strand_id, maup->pip.guestid));

                        setup_a_mau(cpup, maup, maup->pip.ino);
                } else {
                        /* Unconfigure */
                        DBG_MAU(c_printf("\tUnbinding mau %d from strand 0x%x "
                            "in guest 0x%x\n",
                            maup->pid, strand_id, maup->guest->guestid));
                        unconfig_strand_from_mau(maup, strand_id);
                }
        }
}

/*
 * Setup an MAU ...
 *
 * FIXME: bunch of wierd stuff here .. check this is done right.
 * This is a copy of config_a_mau in reconf.c. The reconf.c version
 * will go away when we handle delayed reconfig.
 */
static void
setup_a_mau(vcpu_t *vcpup, mau_t *maup, uint64_t ino)
{
        c_setup_mau(vcpup, ino, &config);
        maup->guest = vcpup->guest;
}

/*
 * Initialise MAUs
 */
void
init_mau_crypto_units()
{
        mau_t   *maup;
        int     i, j;

        config.config_m.maus = &maus[0];

        maup = (mau_t *)config.config_m.maus;
        for (i = 0; i < NMAUS; i++) {
                maup[i].handle = 0LL;
#ifdef ERRATA_192
                maup[i].store_in_progr = 0LL;
                maup[i].enable_cwq = 0LL;
#endif
                maup[i].res_id = i;
                maup[i].cpuset = 0LL;
                for (j = 0; j < NSTRANDS_PER_CORE; j++) {
                        maup[i].cpu_active[j] = 0;
                }
                maup[i].state = MAU_STATE_UNCONFIGURED;
        }
}

#endif