xref: /onnv-gate/usr/src/uts/common/xen/os/hypercall.c (revision 7532)

/*
 * 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.
 */

/*
 * Provides basic C wrappers around hypervisor invocation.
 *
 * i386: eax = vector: ebx, ecx, edx, esi, edi = args 1-5
 *	 eax = return value
 *	 (argument registers may be clobbered on return)
 *
 * amd64:rax = vector: rdi, rsi, rdx, r10, r8, r9 = args 1-6
 *	 rax = return value
 *	 (arguments registers not clobbered on return; rcx, r11 are)
 */

#include <sys/types.h>
#ifdef XPV_HVM_DRIVER
#include <sys/xpv_support.h>
#endif

#include <sys/hypervisor.h>
#include <xen/public/sched.h>
#include <sys/debug.h>
#include <sys/archsystm.h>

long
HYPERVISOR_set_trap_table(trap_info_t *table)
{
	return (__hypercall1(__HYPERVISOR_set_trap_table, (ulong_t)table));
}

int
HYPERVISOR_mmu_update(mmu_update_t *req, int count, int *success_count,
    domid_t domain_id)
{
	return (__hypercall4_int(__HYPERVISOR_mmu_update,
	    (ulong_t)req, (long)count, (ulong_t)success_count,
	    (ulong_t)domain_id));
}

long
HYPERVISOR_set_gdt(ulong_t *frame_list, int entries)
{
	return (__hypercall2(
	    __HYPERVISOR_set_gdt, (ulong_t)frame_list, (long)entries));
}

/*
 * XXPV Seems like "sp" would be a better name for both amd64 and i386?
 * For now stay consistent with xen project source.
 */
long
HYPERVISOR_stack_switch(ulong_t ss, ulong_t esp)
{
	return (__hypercall2(__HYPERVISOR_stack_switch, ss, esp));
}

#if defined(__amd64)

long
HYPERVISOR_set_callbacks(ulong_t event_address, ulong_t failsafe_address,
    ulong_t syscall_address)
{
	return (__hypercall3(__HYPERVISOR_set_callbacks,
	    event_address, failsafe_address, syscall_address));
}

#elif defined(__i386)

long
HYPERVISOR_set_callbacks(
    ulong_t event_selector, ulong_t event_address,
    ulong_t failsafe_selector, ulong_t failsafe_address)
{
	return (__hypercall4(__HYPERVISOR_set_callbacks,
	    event_selector, event_address,
	    failsafe_selector, failsafe_address));
}

#endif	/* __amd64 */

long
HYPERVISOR_fpu_taskswitch(int set)
{
	return (__hypercall1(__HYPERVISOR_fpu_taskswitch, (long)set));
}

/* *** __HYPERVISOR_sched_op_compat *** OBSOLETED */

long
HYPERVISOR_platform_op(xen_platform_op_t *platform_op)
{
	return (__hypercall1(__HYPERVISOR_platform_op, (ulong_t)platform_op));
}

/* *** __HYPERVISOR_set_debugreg *** NOT IMPLEMENTED */

/* *** __HYPERVISOR_get_debugreg *** NOT IMPLEMENTED */

long
HYPERVISOR_update_descriptor(maddr_t ma, uint64_t desc)
{
#if defined(__amd64)

	return (__hypercall2(__HYPERVISOR_update_descriptor, ma, desc));

#elif defined(__i386)

	return (__hypercall4(__HYPERVISOR_update_descriptor,
	    (ulong_t)ma, (ulong_t)(ma >>32),
	    (ulong_t)desc, (ulong_t)(desc >> 32)));

#endif
}

long
HYPERVISOR_memory_op(int cmd, void *arg)
{
	return (__hypercall2(__HYPERVISOR_memory_op, (long)cmd,
	    (ulong_t)arg));
}

long
HYPERVISOR_multicall(void *call_list, uint_t nr_calls)
{
	return (__hypercall2(__HYPERVISOR_multicall,
	    (ulong_t)call_list, (ulong_t)nr_calls));
}

int
HYPERVISOR_update_va_mapping(ulong_t va, uint64_t new_pte, ulong_t flags)
{
#if !defined(_BOOT)
	if (IN_XPV_PANIC())
		return (0);
#endif
#if defined(__amd64)

	return (__hypercall3_int(__HYPERVISOR_update_va_mapping, va,
	    new_pte, flags));

#elif defined(__i386)

	return (__hypercall4_int(__HYPERVISOR_update_va_mapping, va,
	    (ulong_t)new_pte, (ulong_t)(new_pte >> 32), flags));

#endif	/* __i386 */
}

/*
 * Note: this timeout must be the Xen system time not hrtime (see
 * xpv_timestamp.c).
 */
long
HYPERVISOR_set_timer_op(uint64_t timeout)
{
#if defined(__amd64)

	return (__hypercall1(__HYPERVISOR_set_timer_op, timeout));

#elif defined(__i386)

	uint32_t timeout_hi = (uint32_t)(timeout >> 32);
	uint32_t timeout_lo = (uint32_t)timeout;
	return (__hypercall2(__HYPERVISOR_set_timer_op,
	    (ulong_t)timeout_lo, (ulong_t)timeout_hi));

#endif	/* __i386 */
}

/* *** __HYPERVISOR_event_channel_op_compat *** OBSOLETED */

long
HYPERVISOR_xen_version(int cmd, void *arg)
{
	return (__hypercall2(__HYPERVISOR_xen_version, (long)cmd,
	    (ulong_t)arg));
}

long
HYPERVISOR_console_io(int cmd, int count, char *str)
{
	return (__hypercall3(__HYPERVISOR_console_io, (long)cmd, (long)count,
	    (ulong_t)str));
}

/* *** __HYPERVISOR_physdev_op_compat *** OBSOLETED */

long
HYPERVISOR_grant_table_op(uint_t cmd, void *uop, uint_t count)
{
	int ret_val;
	ret_val = __hypercall3(__HYPERVISOR_grant_table_op,
	    (long)cmd, (ulong_t)uop, (ulong_t)count);

#if !defined(_BOOT) && !defined(XPV_HVM_DRIVER)
	/*
	 * XXPV --
	 * The map_grant_ref call suffers a poor design flaw.
	 * It's the only hypervisor interface that creates page table mappings
	 * that doesn't take an entire PTE. Hence we can't create the
	 * mapping with a particular setting of the software PTE bits, NX, etc.
	 *
	 * Until the interface is fixed, we need to minimize the possiblity
	 * of dtrace or kmdb blowing up on a foreign mapping that doesn't
	 * have a correct setting for the soft bits. We'll force them here.
	 */
	if (ret_val == 0 && cmd == GNTTABOP_map_grant_ref) {
		extern void xen_fix_foreign(uint64_t);
		gnttab_map_grant_ref_t *mapops = (gnttab_map_grant_ref_t *)uop;
		uint_t i;
		for (i = 0; i < count; ++i) {
			if (mapops[i].status == GNTST_okay)
				xen_fix_foreign(mapops[i].host_addr);
		}
	}
#endif
	return (ret_val);
}

long
HYPERVISOR_vm_assist(uint_t cmd, uint_t type)
{
	return (__hypercall2(__HYPERVISOR_vm_assist,
	    (ulong_t)cmd, (ulong_t)type));
}

int
HYPERVISOR_update_va_mapping_otherdomain(ulong_t va,
    uint64_t new_pte, ulong_t flags, domid_t domain_id)
{
#if defined(__amd64)

	return (__hypercall4_int(__HYPERVISOR_update_va_mapping_otherdomain,
	    va, new_pte, flags, (ulong_t)domain_id));

#elif defined(__i386)

	return (__hypercall5_int(__HYPERVISOR_update_va_mapping_otherdomain,
	    va, (ulong_t)new_pte, (ulong_t)(new_pte >> 32), flags,
	    (ulong_t)domain_id));

#endif	/* __i386 */
}

/*
 * *** __HYPERVISOR_iret ***
 *   see HYPERVISOR_IRET() macro in i86xpv/sys/machprivregs.h
 */

long
HYPERVISOR_vcpu_op(int cmd, int vcpuid, void *extra_args)
{
	return (__hypercall3(__HYPERVISOR_vcpu_op, (long)cmd, (long)vcpuid,
	    (ulong_t)extra_args));
}

#if defined(__amd64)

long
HYPERVISOR_set_segment_base(int reg, ulong_t value)
{
	return (__hypercall2(__HYPERVISOR_set_segment_base, (long)reg, value));
}

#endif	/* __amd64 */

int
HYPERVISOR_mmuext_op(struct mmuext_op *req, int count, uint_t *success_count,
    domid_t domain_id)
{
	return (__hypercall4_int(__HYPERVISOR_mmuext_op,
	    (ulong_t)req, (long)count, (ulong_t)success_count,
	    (ulong_t)domain_id));
}

long
HYPERVISOR_acm_op(struct xen_acmctl *arg)
{
	return (__hypercall1(__HYPERVISOR_acm_op, (ulong_t)arg));
}

long
HYPERVISOR_nmi_op(int cmd, void *arg)
{
	return (__hypercall2(__HYPERVISOR_nmi_op, (long)cmd, (ulong_t)arg));
}

long
HYPERVISOR_sched_op(int cmd, void *arg)
{
	return (__hypercall2(__HYPERVISOR_sched_op,
	    (ulong_t)cmd, (ulong_t)arg));
}

long
HYPERVISOR_callback_op(int cmd, void *arg)
{
	return (__hypercall2(__HYPERVISOR_callback_op,
	    (ulong_t)cmd, (ulong_t)arg));
}

/* *** __HYPERVISOR_xenoprof_op *** NOT IMPLEMENTED */

long
HYPERVISOR_event_channel_op(int cmd, void *arg)
{
	return (__hypercall2(__HYPERVISOR_event_channel_op, (long)cmd,
	    (ulong_t)arg));
}

long
HYPERVISOR_physdev_op(int cmd, void *arg)
{
	return (__hypercall2(__HYPERVISOR_physdev_op, (long)cmd,
	    (ulong_t)arg));
}

long
HYPERVISOR_hvm_op(int cmd, void *arg)
{
	return (__hypercall2(__HYPERVISOR_hvm_op, (long)cmd, (ulong_t)arg));
}

long
HYPERVISOR_sysctl(xen_sysctl_t *sysctl)
{
	return (__hypercall1(__HYPERVISOR_sysctl, (ulong_t)sysctl));
}

long
HYPERVISOR_domctl(xen_domctl_t *domctl)
{
	return (__hypercall1(__HYPERVISOR_domctl, (ulong_t)domctl));
}

/* *** __HYPERVISOR_kexec_op *** NOT IMPLEMENTED */

/*
 *
 * HYPERCALL HELPER ROUTINES
 *    These don't have there own unique hypercalls.
 *
 */

long
HYPERVISOR_yield(void)
{
	return (HYPERVISOR_sched_op(SCHEDOP_yield, NULL));
}

long
HYPERVISOR_block(void)
{
	return (HYPERVISOR_sched_op(SCHEDOP_block, NULL));
}

long
HYPERVISOR_shutdown(uint_t reason)
{
	struct sched_shutdown sched_shutdown;

	sched_shutdown.reason = reason;

	return (HYPERVISOR_sched_op(SCHEDOP_shutdown, &sched_shutdown));
}

/*
 * Poll one or more event-channel ports, and return when pending.
 * An optional timeout (in nanoseconds, absolute time since boot) may be
 * specified. Note: this timeout must be the Xen system time not hrtime (see
 * xpv_timestamp.c).
 */
long
HYPERVISOR_poll(evtchn_port_t *ports, uint_t nr_ports, uint64_t timeout)
{
	struct sched_poll sched_poll;

	/*LINTED: constant in conditional context*/
	set_xen_guest_handle(sched_poll.ports, ports);
	sched_poll.nr_ports = nr_ports;
	sched_poll.timeout = timeout;

	return (HYPERVISOR_sched_op(SCHEDOP_poll, &sched_poll));
}

long
HYPERVISOR_suspend(ulong_t start_info_mfn)
{
	struct sched_shutdown sched_shutdown;

	sched_shutdown.reason = SHUTDOWN_suspend;

	return (__hypercall3(__HYPERVISOR_sched_op, SCHEDOP_shutdown,
	    (ulong_t)&sched_shutdown, start_info_mfn));
}

long
HYPERVISOR_mca(uint32_t cmd, xen_mc_arg_t *arg)
{
	xen_mc_t xmc;
	long rv;

	switch (cmd) {
	case XEN_MC_CMD_fetch:
	case XEN_MC_CMD_physcpuinfo:
	case XEN_MC_CMD_msrinject:
	case XEN_MC_CMD_mceinject:
	case XEN_MC_CMD_offlinecpu:
		if (arg == NULL)
			return (EINVAL);
		break;

	case XEN_MC_CMD_notifydomain:
		return (ENOTSUP);

	default:
		return (EINVAL);
	}

	xmc.interface_version = XEN_MCA_INTERFACE_VERSION;
	xmc.cmd = cmd;
	if (arg != NULL)
		xmc.u = *arg;

	rv = __hypercall1(__HYPERVISOR_mca, (ulong_t)&xmc);

	if (rv == XEN_MC_HCALL_SUCCESS && arg != NULL)
		*arg = xmc.u;

	return (rv);
}