sun4v/os/hsvc.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 <sys/types.h>
#include <sys/dditypes.h>
#include <sys/machsystm.h>
#include <sys/archsystm.h>
#include <sys/prom_plat.h>
#include <sys/promif.h>
#include <sys/kmem.h>
#include <sys/hypervisor_api.h>
#include <sys/hsvc.h>

#ifdef DEBUG

int hsvc_debug = 0;             /* HSVC debug flags */

/*
 * Flags to control HSVC debugging
 */
#define DBG_HSVC_REGISTER   0x0001
#define DBG_HSVC_UNREGISTER 0x0002
#define DBG_HSVC_OBP_CIF    0x0004
#define DBG_HSVC_ALLOC      0x0008
#define DBG_HSVC_VERSION    0x0010
#define DBG_HSVC_REFCNT     0x0020
#define DBG_HSVC_SETUP      0x0040

#define HSVC_CHK_REFCNT(hsvcp)  \
    if (hsvc_debug & DBG_HSVC_REFCNT) hsvc_chk_refcnt(hsvcp)

#define HSVC_DEBUG(flag, ARGS)  \
    if (hsvc_debug & flag)  prom_printf ARGS

#define HSVC_DUMP() \
    if (hsvc_debug & DBG_HSVC_SETUP) hsvc_dump()

#else /* DEBUG */

#define HSVC_CHK_REFCNT(hsvcp)
#define HSVC_DEBUG(flag, args)
#define HSVC_DUMP()

#endif /* DEBUG */

/*
 * Each hypervisor API group negotiation is tracked via a
 * hsvc structure. This structure contains the API group,
 * currently negotiated major/minor number, a singly linked
 * list of clients currently registered and a reference count.
 *
 * Since the number of API groups is fairly small, negotiated
 * API groups are maintained via a singly linked list. Also,
 * sufficient free space is reserved to allow for API group
 * registration before kmem_xxx interface can be used to
 * allocate memory dynamically.
 *
 * Note that all access to the API group lookup and negotiation
 * is serialized to support strict HV API interface.
 */

typedef struct hsvc {
    struct hsvc *next;          /* next group/free entry */
    uint64_t    group;          /* hypervisor service group */
    uint64_t    major;          /* major number */
    uint64_t    minor;          /* minor number */
    uint64_t    refcnt;         /* reference count */
    hsvc_info_t *clients;       /* linked list of clients */
} hsvc_t;


/*
 * Global variables
 */
hsvc_t      *hsvc_groups;       /* linked list of API groups in use */
hsvc_t      *hsvc_avail;        /* free reserved buffers */
kmutex_t    hsvc_lock;      /* protects linked list and globals */

/*
 * Preallocate some space for boot requirements (before kmem_xxx can be
 * used)
 */
#define HSVC_RESV_BUFS_MAX      16
hsvc_t  hsvc_resv_bufs[HSVC_RESV_BUFS_MAX];

/*
 * Pre-versioning groups (not negotiated by Ontario/Erie FCS release)
 */
static uint64_t hsvc_pre_versioning_groups[] = {
    HSVC_GROUP_SUN4V,
    HSVC_GROUP_CORE,
    HSVC_GROUP_VPCI,
    HSVC_GROUP_VSC,
    HSVC_GROUP_NIAGARA_CPU,
    HSVC_GROUP_NCS,
    HSVC_GROUP_DIAG
};

#define HSVC_PRE_VERSIONING_GROUP_CNT   \
    (sizeof (hsvc_pre_versioning_groups) / sizeof (uint64_t))

static boolean_t
pre_versioning_group(uint64_t api_group)
{
    int i;

    for (i = 0; i < HSVC_PRE_VERSIONING_GROUP_CNT; i++)
        if (hsvc_pre_versioning_groups[i] == api_group)
            return (B_TRUE);
    return (B_FALSE);
}

static hsvc_t *
hsvc_lookup(hsvc_info_t *hsvcinfop)
{
    hsvc_t      *hsvcp;
    hsvc_info_t *p;

    for (hsvcp = hsvc_groups; hsvcp != NULL; hsvcp = hsvcp->next) {
        for (p = hsvcp->clients; p != NULL;
            p = (hsvc_info_t *)p->hsvc_private)
            if (p == hsvcinfop)
                break;
        if (p)
            break;
    }

    return (hsvcp);
}

#ifdef DEBUG

/*
 * Check client reference count
 */
static void
hsvc_chk_refcnt(hsvc_t *hsvcp)
{
    int     refcnt;
    hsvc_info_t *p;

    for (refcnt = 0, p = hsvcp->clients; p != NULL;
        p = (hsvc_info_t *)p->hsvc_private)
        refcnt++;

    ASSERT(hsvcp->refcnt == refcnt);
}

/*
 * Dump registered clients information
 */
static void
hsvc_dump(void)
{
    hsvc_t      *hsvcp;
    hsvc_info_t *p;

    mutex_enter(&hsvc_lock);

    prom_printf("hsvc_dump: hsvc_groups: %p  hsvc_avail: %p\n",
        (void *)hsvc_groups, (void *)hsvc_avail);

    for (hsvcp = hsvc_groups; hsvcp != NULL; hsvcp = hsvcp->next) {
        prom_printf(" hsvcp: %p (0x%lx 0x%lx 0x%lx) ref: %ld clients: "
            "%p\n", (void *)hsvcp, hsvcp->group, hsvcp->major,
            hsvcp->minor, hsvcp->refcnt, (void *)hsvcp->clients);

        for (p = hsvcp->clients; p != NULL;
            p = (hsvc_info_t *)p->hsvc_private) {
            prom_printf("  client %p (0x%lx 0x%lx 0x%lx '%s') "
                "private: %p\n", (void *)p, p->hsvc_group,
                p->hsvc_major, p->hsvc_minor, p->hsvc_modname,
                p->hsvc_private);
        }
    }

    mutex_exit(&hsvc_lock);
}

#endif /* DEBUG */

/*
 * Allocate a buffer to cache API group information. Note that we
 * allocate a buffer from reserved pool early on, before kmem_xxx
 * interface becomes available.
 */
static hsvc_t *
hsvc_alloc(void)
{
    hsvc_t  *hsvcp;

    ASSERT(MUTEX_HELD(&hsvc_lock));

    if (hsvc_avail != NULL) {
        hsvcp = hsvc_avail;
        hsvc_avail = hsvcp->next;
    } else if (kmem_ready) {
        hsvcp = kmem_zalloc(sizeof (hsvc_t), KM_SLEEP);
        HSVC_DEBUG(DBG_HSVC_ALLOC,
            ("hsvc_alloc: hsvc_avail: %p  kmem_zalloc hsvcp: %p\n",
            (void *)hsvc_avail, (void *)hsvcp));
    } else
        hsvcp = NULL;
    return (hsvcp);
}

static void
hsvc_free(hsvc_t *hsvcp)
{
    ASSERT(hsvcp != NULL);
    ASSERT(MUTEX_HELD(&hsvc_lock));

    if (hsvcp >= hsvc_resv_bufs &&
        hsvcp < &hsvc_resv_bufs[HSVC_RESV_BUFS_MAX]) {
        hsvcp->next = hsvc_avail;
        hsvc_avail =  hsvcp;
    } else {
        HSVC_DEBUG(DBG_HSVC_ALLOC,
            ("hsvc_free: hsvc_avail: %p  kmem_free hsvcp: %p\n",
            (void *)hsvc_avail, (void *)hsvcp));
        (void) kmem_free(hsvcp, sizeof (hsvc_t));
    }
}

/*
 * Link client on the specified hsvc's client list and
 * bump the reference count.
 */
static void
hsvc_link_client(hsvc_t *hsvcp, hsvc_info_t *hsvcinfop)
{
    ASSERT(MUTEX_HELD(&hsvc_lock));
    HSVC_CHK_REFCNT(hsvcp);

    hsvcinfop->hsvc_private = hsvcp->clients;
    hsvcp->clients = hsvcinfop;
    hsvcp->refcnt++;
}

/*
 * Unlink a client from the specified hsvc's client list and
 * decrement the reference count, if found.
 *
 * Return 0 if client unlinked. Otherwise return -1.
 */
static int
hsvc_unlink_client(hsvc_t *hsvcp, hsvc_info_t *hsvcinfop)
{
    hsvc_info_t *p, **pp;
    int status = 0;

    ASSERT(MUTEX_HELD(&hsvc_lock));
    HSVC_CHK_REFCNT(hsvcp);

    for (pp = &hsvcp->clients; (p = *pp) != NULL;
        pp = (hsvc_info_t **)&p->hsvc_private) {
        if (p != hsvcinfop)
            continue;

        ASSERT(hsvcp->refcnt > 0);
        hsvcp->refcnt--;
        *pp = (hsvc_info_t *)p->hsvc_private;
        p->hsvc_private = NULL;
        break;
    }

    if (p == NULL)
        status = -1;

    return (status);
}

/*
 * Negotiate/register an API group usage
 */
int
hsvc_register(hsvc_info_t *hsvcinfop, uint64_t *supported_minor)
{
    hsvc_t *hsvcp;
    uint64_t api_group = hsvcinfop->hsvc_group;
    uint64_t major = hsvcinfop->hsvc_major;
    uint64_t minor = hsvcinfop->hsvc_minor;
    int status = 0;

    HSVC_DEBUG(DBG_HSVC_REGISTER,
        ("hsvc_register %p (0x%lx 0x%lx 0x%lx ID %s)\n", (void *)hsvcinfop,
        api_group, major, minor, hsvcinfop->hsvc_modname));

    if (hsvcinfop->hsvc_rev != HSVC_REV_1)
        return (EINVAL);

    mutex_enter(&hsvc_lock);

    /*
     * Make sure that the hsvcinfop is new (i.e. not already registered).
     */
    if (hsvc_lookup(hsvcinfop) != NULL) {
        mutex_exit(&hsvc_lock);
        return (EINVAL);
    }

    /*
     * Search for the specified api_group
     */
    for (hsvcp = hsvc_groups; hsvcp != NULL; hsvcp = hsvcp->next)
        if (hsvcp->group == api_group)
            break;

    if (hsvcp) {
        /*
         * If major number mismatch, then return ENOTSUP.
         * Otherwise return currently negotiated minor
         * and the following status:
         *  ENOTSUP     requested minor < current minor
         *  OK      requested minor >= current minor
         */

        if (hsvcp->major != major) {
            status = ENOTSUP;
        } else if (hsvcp->minor > minor) {
            /*
             * Client requested a lower minor number than
             * currently in use.
             */
            status = ENOTSUP;
            *supported_minor = hsvcp->minor;
        } else {
            /*
             * Client requested a minor number same or higher
             * than the one in use.  Set supported minor number
             * and link the client on hsvc client linked list.
             */
            *supported_minor = hsvcp->minor;
            hsvc_link_client(hsvcp, hsvcinfop);
        }
    } else {
        /*
         * This service group has not been negotiated yet.
         * Call OBP CIF interface to negotiate a major/minor
         * number.
         *
         * If not enough memory to cache this information, then
         * return EAGAIN so that the caller can try again later.
         * Otherwise, process OBP CIF results as follows:
         *
         *  H_BADTRAP   OBP CIF interface is not supported.
         *          If not a pre-versioning group, then
         *          return EINVAL, indicating unsupported
         *          API group. Otherwise, mimic default
         *          behavior (i.e. support only major=1).
         *
         *  H_EOK       Negotiation was successful. Cache
         *          and return supported major/minor,
         *          limiting the minor number to the
         *          requested value.
         *
         *  H_EINVAL    Invalid group. Return EINVAL
         *
         *  H_ENOTSUPPORTED Unsupported major number. Return
         *          ENOTSUP.
         *
         *  H_EBUSY     Return EAGAIN.
         *
         *  H_EWOULDBLOCK   Return EAGAIN.
         */
        hsvcp = hsvc_alloc();
        if (hsvcp == NULL) {
            status = EAGAIN;
        } else {
            uint64_t hvstat;

            hvstat = prom_set_sun4v_api_version(api_group,
                major, minor, supported_minor);

            HSVC_DEBUG(DBG_HSVC_OBP_CIF,
                ("prom_set_sun4v_api_ver: 0x%lx 0x%lx, 0x%lx "
                " hvstat: 0x%lx sup_minor: 0x%lx\n", api_group,
                major, minor, hvstat, *supported_minor));

            switch (hvstat) {
            case H_EBADTRAP:
                /*
                 * Older firmware does not support OBP CIF
                 * interface. If it's a pre-versioning group,
                 * then assume that the firmware supports
                 * only major=1 and minor=0.
                 */
                if (!pre_versioning_group(api_group)) {
                    status = EINVAL;
                    break;
                } else if (major != 1) {
                    status = ENOTSUP;
                    break;
                }

                /*
                 * It's a preversioning group. Default minor
                 * value to 0.
                 */
                *supported_minor = 0;

                /*FALLTHROUGH*/
            case H_EOK:
                /*
                 * Limit supported minor number to the
                 * requested value and cache the new
                 * API group information.
                 */
                if (*supported_minor > minor)
                    *supported_minor = minor;
                hsvcp->group = api_group;
                hsvcp->major = major;
                hsvcp->minor = *supported_minor;
                hsvcp->refcnt = 0;
                hsvcp->clients = NULL;
                hsvcp->next = hsvc_groups;
                hsvc_groups = hsvcp;

                /*
                 * Link the caller on the client linked list.
                 */
                hsvc_link_client(hsvcp, hsvcinfop);
                break;

            case H_ENOTSUPPORTED:
                status = ENOTSUP;
                break;

            case H_EBUSY:
            case H_EWOULDBLOCK:
                status = EAGAIN;
                break;

            case H_EINVAL:
            default:
                status = EINVAL;
                break;
            }
        }
        /*
         * Deallocate entry if not used
         */
        if (status != 0)
            hsvc_free(hsvcp);
    }
    mutex_exit(&hsvc_lock);

    HSVC_DEBUG(DBG_HSVC_REGISTER,
        ("hsvc_register(%p) status; %d sup_minor: 0x%lx\n",
        (void *)hsvcinfop, status, *supported_minor));

    return (status);
}

/*
 * Unregister an API group usage
 */
int
hsvc_unregister(hsvc_info_t *hsvcinfop)
{
    hsvc_t      **hsvcpp, *hsvcp;
    uint64_t    api_group;
    uint64_t    major, supported_minor;
    int     status = 0;

    if (hsvcinfop->hsvc_rev != HSVC_REV_1)
        return (EINVAL);

    major = hsvcinfop->hsvc_major;
    api_group = hsvcinfop->hsvc_group;

    HSVC_DEBUG(DBG_HSVC_UNREGISTER,
        ("hsvc_unregister %p (0x%lx 0x%lx 0x%lx ID %s)\n",
        (void *)hsvcinfop, api_group, major, hsvcinfop->hsvc_minor,
        hsvcinfop->hsvc_modname));

    /*
     * Search for the matching entry and return EINVAL if no match found.
     * Otherwise, remove it from our list and unregister the API
     * group if this was the last reference to that API group.
     */
    mutex_enter(&hsvc_lock);

    for (hsvcpp = &hsvc_groups; (hsvcp = *hsvcpp) != NULL;
        hsvcpp = &hsvcp->next) {
        if (hsvcp->group != api_group || hsvcp->major != major)
            continue;

        /*
         * Search client list for a matching hsvcinfop entry
         * and unlink it and decrement refcnt, if found.
         */
        if (hsvc_unlink_client(hsvcp, hsvcinfop) < 0) {
            /* client not registered */
            status = EINVAL;
            break;
        }

        /*
         * Client has been unlinked. If this was the last
         * reference, unregister API group via OBP CIF
         * interface.
         */
        if (hsvcp->refcnt == 0) {
            uint64_t    hvstat;

            ASSERT(hsvcp->clients == NULL);
            hvstat = prom_set_sun4v_api_version(api_group, 0, 0,
                &supported_minor);

            HSVC_DEBUG(DBG_HSVC_OBP_CIF,
                (" prom unreg group: 0x%lx hvstat: 0x%lx\n",
                api_group, hvstat));

            /*
             * Note that the call to unnegotiate an API group
             * may fail if anyone, including OBP, is using
             * those services. However, the caller is done
             * with this API group and should be allowed to
             * unregister regardless of the outcome.
             */
            *hsvcpp = hsvcp->next;
            hsvc_free(hsvcp);
        }
        break;
    }

    if (hsvcp == NULL)
        status = EINVAL;

    mutex_exit(&hsvc_lock);

    HSVC_DEBUG(DBG_HSVC_UNREGISTER,
        ("hsvc_unregister %p status: %d\n", (void *)hsvcinfop, status));

    return (status);
}


/*
 * Get negotiated major/minor version number for an API group
 */
int
hsvc_version(uint64_t api_group, uint64_t *majorp, uint64_t *minorp)
{
    int status = 0;
    uint64_t hvstat;
    hsvc_t  *hsvcp;

    /*
     * Check if the specified api_group is already in use.
     * If so, return currently negotiated major/minor number.
     * Otherwise, call OBP CIF interface to get the currently
     * negotiated major/minor number.
     */
    mutex_enter(&hsvc_lock);
    for (hsvcp = hsvc_groups; hsvcp != NULL; hsvcp = hsvcp->next)
        if (hsvcp->group == api_group)
            break;

    if (hsvcp) {
        *majorp = hsvcp->major;
        *minorp = hsvcp->minor;
    } else {
        hvstat = prom_get_sun4v_api_version(api_group, majorp, minorp);

        switch (hvstat) {
        case H_EBADTRAP:
            /*
             * Older firmware does not support OBP CIF
             * interface. If it's a pre-versioning group,
             * then return default major/minor (i.e. 1/0).
             * Otherwise, return EINVAL.
             */
            if (pre_versioning_group(api_group)) {
                *majorp = 1;
                *minorp = 0;
            } else
                status = EINVAL;
            break;

        case H_EINVAL:
        default:
            status = EINVAL;
            break;

        }
    }
    mutex_exit(&hsvc_lock);

    HSVC_DEBUG(DBG_HSVC_VERSION,
        ("hsvc_version(0x%lx) status: %d major: 0x%lx minor: 0x%lx\n",
        api_group, status, *majorp, *minorp));

    return (status);
}

/*
 * Initialize framework data structures
 */
void
hsvc_init(void)
{
    int     i;
    hsvc_t      *hsvcp;

    /*
     * Initialize global data structures
     */
    mutex_init(&hsvc_lock, NULL, MUTEX_DEFAULT, NULL);
    hsvc_groups = NULL;
    hsvc_avail = NULL;

    /*
     * Setup initial free list
     */
    mutex_enter(&hsvc_lock);
    for (i = 0, hsvcp = &hsvc_resv_bufs[0];
        i < HSVC_RESV_BUFS_MAX; i++, hsvcp++)
        hsvc_free(hsvcp);
    mutex_exit(&hsvc_lock);
}


/*
 * Hypervisor services to be negotiated at boot time.
 *
 * Note that the kernel needs to negotiate the HSVC_GROUP_SUN4V
 * API group first, before doing any other negotiation. Also, it
 * uses hypervisor services belonging to the HSVC_GROUP_CORE API
 * group only for itself.
 *
 * Note that the HSVC_GROUP_DIAG is negotiated on behalf of
 * any driver/module using DIAG services.
 */
typedef struct hsvc_info_unix_s {
    hsvc_info_t hsvcinfo;
    int     required;
} hsvc_info_unix_t;

static hsvc_info_unix_t  hsvcinfo_unix[] = {
    {{HSVC_REV_1, NULL, HSVC_GROUP_SUN4V,   1,  0, NULL}, 1},
    {{HSVC_REV_1, NULL, HSVC_GROUP_CORE,    1,  2, NULL}, 1},
    {{HSVC_REV_1, NULL, HSVC_GROUP_DIAG,    1,  0, NULL}, 1},
    {{HSVC_REV_1, NULL, HSVC_GROUP_INTR,    1,  0, NULL}, 0},
    {{HSVC_REV_1, NULL, HSVC_GROUP_REBOOT_DATA, 1,  0, NULL}, 0},
};

#define HSVCINFO_UNIX_CNT   (sizeof (hsvcinfo_unix) / sizeof (hsvc_info_t))
static char *hsvcinfo_unix_modname = "unix";

/*
 * Initialize framework and register hypervisor services to be used
 * by the kernel.
 */
void
hsvc_setup()
{
    int         i, status;
    uint64_t        sup_minor;
    hsvc_info_unix_t    *hsvcinfop;

    /*
     * Initialize framework
     */
    hsvc_init();

    /*
     * Negotiate versioning for required groups
     */
    for (hsvcinfop = &hsvcinfo_unix[0], i = 0; i < HSVCINFO_UNIX_CNT;
        i++, hsvcinfop++) {
        hsvcinfop->hsvcinfo.hsvc_private = NULL;
        hsvcinfop->hsvcinfo.hsvc_modname = hsvcinfo_unix_modname;
        status = hsvc_register(&(hsvcinfop->hsvcinfo), &sup_minor);

        if ((status != 0) && hsvcinfop->required) {
            cmn_err(CE_PANIC, "%s: cannot negotiate hypervisor "
                "services - group: 0x%lx major: 0x%lx minor: 0x%lx"
                " errno: %d\n", hsvcinfop->hsvcinfo.hsvc_modname,
                hsvcinfop->hsvcinfo.hsvc_group,
                hsvcinfop->hsvcinfo.hsvc_major,
                hsvcinfop->hsvcinfo.hsvc_minor, status);
        }
    }
    HSVC_DUMP();
}