xref: /freebsd/sys/x86/x86/vmware_guestrpc.c (revision ecaab0fb)

/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2013-2024, Juniper Networks, Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/conf.h>
#include <sys/kernel.h>
#include <sys/limits.h>
#include <sys/bus.h>
#include <sys/sbuf.h>
#include <sys/errno.h>
#include <sys/module.h>

#include <x86/vmware.h>
#include <x86/vmware_guestrpc.h>

/* GuestRPC Subcommands */
#define		VMW_HVGUESTRPC_OPEN			0x00
#define		VMW_HVGUESTRPC_SEND_LEN			0x01
#define		VMW_HVGUESTRPC_SEND_DATA		0x02
#define		VMW_HVGUESTRPC_RECV_LEN			0x03
#define		VMW_HVGUESTRPC_RECV_DATA		0x04
#define		VMW_HVGUESTRPC_FINISH_RECV		0x05
#define		VMW_HVGUESTRPC_CLOSE			0x06
/* GuestRPC Parameters */
#define		VMW_HVGUESTRPC_OPEN_MAGIC		0x49435052
/* GuestRPC Status */
#define		VMW_HVGUESTRPC_FAILURE			0x00000000
#define		VMW_HVGUESTRPC_OPEN_SUCCESS		0x00010000
#define		VMW_HVGUESTRPC_SEND_LEN_SUCCESS		0x00810000
#define		VMW_HVGUESTRPC_SEND_DATA_SUCCESS	0x00010000
#define		VMW_HVGUESTRPC_RECV_LEN_SUCCESS		0x00830000
#define		VMW_HVGUESTRPC_RECV_DATA_SUCCESS	0x00010000
#define		VMW_HVGUESTRPC_FINISH_RECV_SUCCESS	0x00010000
#define		VMW_HVGUESTRPC_CLOSE_SUCCESS		0x00010000

#define	VMW_GUESTRPC_EBX(_p)	((_p)[1])
#define	VMW_GUESTRPC_EDXHI(_p)	((_p)[3] >> 16)
#define	VMW_GUESTRPC_STATUS(_p)	((_p)[2])

static __inline void
vmware_guestrpc(int chan, uint16_t subcmd, uint32_t param, u_int *p)
{

#ifdef DEBUG_VMGUESTRPC
	printf("%s(%d, %#x, %#x, %p)\n", __func__, chan, subcmd, param, p);
#endif
	vmware_hvcall(chan, VMW_HVCMD_GUESTRPC | (subcmd << 16), param, p);
#ifdef DEBUG_VMGUESTRPC
	printf("p[0] = %#x\n", p[0]);
	printf("p[1] = %#x\n", p[1]);
	printf("p[2] = %#x\n", p[2]);
	printf("p[3] = %#x\n", p[3]);
#endif
}

/*
 * Start a GuestRPC request
 *
 * Channel number is returned in the EDXHI parameter.
 *
 * This channel number must be used in successive GuestRPC requests for
 * sending and receiving RPC data.
 */
static int
vmware_guestrpc_open(void)
{
	u_int p[4];

	vmware_guestrpc(0, VMW_HVGUESTRPC_OPEN, VMW_HVGUESTRPC_OPEN_MAGIC,
	    p);
	if (VMW_GUESTRPC_STATUS(p) != VMW_HVGUESTRPC_OPEN_SUCCESS)
		return (-1);

	return (VMW_GUESTRPC_EDXHI(p));
}

/*
 * Send the length of the GuestRPC request
 *
 * In a GuestRPC request, the total length of the request must be sent
 * before any data can be sent.
 */
static int
vmware_guestrpc_send_len(int channel, size_t len)
{
	u_int p[4];

	vmware_guestrpc(channel, VMW_HVGUESTRPC_SEND_LEN, len, p);
	if (VMW_GUESTRPC_STATUS(p) != VMW_HVGUESTRPC_SEND_LEN_SUCCESS)
		return (-1);

	return (0);
}

/*
 * Send the data for the GuestRPC request
 *
 * The total length of the GuestRPC request must be sent before any data.
 * Data is sent 32-bit values at a time and therefore may require multiple
 * calls to send all the data.
 */
static int
vmware_guestrpc_send_data(int channel, uint32_t data)
{
	u_int p[4];

	vmware_guestrpc(channel, VMW_HVGUESTRPC_SEND_DATA, data, p);
	if (VMW_GUESTRPC_STATUS(p) != VMW_HVGUESTRPC_SEND_DATA_SUCCESS)
		return (-1);

	return (0);
}

/*
 * Receive the length of the GuestRPC reply.
 *
 * Length of the reply data is returned in the EBX parameter.
 * The reply identifier is returned in the EDXHI parameter.
 *
 * The reply identifier must be used as the GuestRPC parameter in calls
 * to vmware_guestrpc_recv_data()
 */
static int
vmware_guestrpc_recv_len(int channel, size_t *lenp)
{
	u_int p[4];

	vmware_guestrpc(channel, VMW_HVGUESTRPC_RECV_LEN, 0, p);
	if (VMW_GUESTRPC_STATUS(p) != VMW_HVGUESTRPC_RECV_LEN_SUCCESS)
		return (-1);

	*lenp = VMW_GUESTRPC_EBX(p);
	return (VMW_GUESTRPC_EDXHI(p));
}

/*
 * Receive the GuestRPC reply data.
 *
 * Data is received in 32-bit values at a time and therefore may
 * require multiple requests to get all the data.
 */
static int
vmware_guestrpc_recv_data(int channel, int id, uint32_t *datap)
{
	u_int p[4];

	vmware_guestrpc(channel, VMW_HVGUESTRPC_RECV_DATA, id, p);
	if (VMW_GUESTRPC_STATUS(p) != VMW_HVGUESTRPC_RECV_DATA_SUCCESS)
		return (-1);

	*datap = VMW_GUESTRPC_EBX(p);
	return (0);
}

/*
 * Close the GuestRPC channel.
 */
static int
vmware_guestrpc_close(int channel)
{
	u_int p[4];

	vmware_guestrpc(channel, VMW_HVGUESTRPC_CLOSE, 0, p);
	if (VMW_GUESTRPC_STATUS(p) != VMW_HVGUESTRPC_CLOSE_SUCCESS)
		return (-1);

	return (0);
}

/*
 * Send a GuestRPC command.
 */
int
vmware_guestrpc_cmd(struct sbuf *sbufp)
{
	char *buf;
	size_t cnt, len;
	int chan, id, status;
	uint32_t data;

	/* Make sure we are running under VMware hypervisor */
	if (vm_guest != VM_GUEST_VMWARE)
		return (ENXIO);

	/* Open the GuestRPC channel */
	chan = vmware_guestrpc_open();
	if (chan == -1)
		return (EIO);

	/* Send the length */
	buf = sbuf_data(sbufp);
	len = sbuf_len(sbufp);
	status = vmware_guestrpc_send_len(chan, len);
	if (status == -1)
		goto done;

	/* Send the data */
	while (len > 0) {
		data = 0;
		cnt = min(4, len);
		memcpy(&data, buf, cnt);
		status = vmware_guestrpc_send_data(chan, data);
		if (status == -1)
			goto done;
		buf += cnt;
		len -= cnt;
	}

	/* Receive the length of the reply data */
	id = vmware_guestrpc_recv_len(chan, &len);
	if (id == -1)
		goto done;

	/* Receive the reply data */
	sbuf_clear(sbufp);
	while (len > 0) {
		status = vmware_guestrpc_recv_data(chan, id, &data);
		if (status == -1)
			goto done;
		sbuf_bcat(sbufp, &data, 4);
		len -= min(4, len);
	}

done:
	/* Close the GuestRPC channel */
	vmware_guestrpc_close(chan);
	return (status == -1 ? EIO : 0);
}

/*
 * Set guest information key/value pair
 */
int
vmware_guestrpc_set_guestinfo(const char *keyword, const char *val)
{
	struct sbuf sb;
	char *buf;
	int error;

#ifdef DEBUG_VMGUESTRPC
	printf("%s: %s=%s\n", __func__, keyword, val);
#endif

	/* Send "info-set" GuestRPC command */
	sbuf_new(&sb, NULL, 256, SBUF_AUTOEXTEND);
	sbuf_printf(&sb, "info-set guestinfo.fbsd.%s %s", keyword, val);
	sbuf_trim(&sb);
	sbuf_finish(&sb);

	error = vmware_guestrpc_cmd(&sb);
	if (error)
		return (error);

	sbuf_finish(&sb);
	buf = sbuf_data(&sb);

#ifdef DEBUG_VMGUESTRPC
	printf("%s: result: %s\n", __func__, buf);
#endif

	/* Buffer will contain 1 on sucess or 0 on failure */
	return ((buf[0] == '0') ? EINVAL : 0);
}

/*
 * Get guest information key/value pair.
 */
int
vmware_guestrpc_get_guestinfo(const char *keyword, struct sbuf *sbufp)
{
	struct sbuf sb;
	char *buf;
	int error;

#ifdef DEBUG_VMGUESTRPC
	printf("%s: %s\n", __func__, keyword);
#endif

	/* Send "info-get" GuestRPC command */
	sbuf_new(&sb, NULL, 256, SBUF_AUTOEXTEND);
	sbuf_printf(&sb, "info-get guestinfo.fbsd.%s", keyword);
	sbuf_trim(&sb);
	sbuf_finish(&sb);

	error = vmware_guestrpc_cmd(&sb);
	if (error)
		return (error);

	sbuf_finish(&sb);
	buf = sbuf_data(&sb);

#ifdef DEBUG_VMGUESTRPC
	printf("%s: result: %s\n", __func__, buf);
#endif

	/*
	 * Buffer will contain "1 <value>" on success or
	 * "0 No value found" on failure
	 */
	if (buf[0] == '0')
		return (ENOENT);

	/*
	 * Add value from buffer to the sbuf
	 */
	sbuf_cat(sbufp, buf + 2);
	return (0);
}

MODULE_VERSION(vmware_guestrpc, 1);