OpenSolaris_b135/uts/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();
}