tmakin/ack-tegra
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

BACKPORT: FROMLIST: virt: gunyah: Add ioeventfd

Browse Source 
Allow userspace to attach an ioeventfd to an mmio address within the
guest.  Userspace provides a description of the type of write to
"subscribe" to and eventfd to trigger when that type of write is
performed by the guest. This mechanism allows userspace to respond
asynchronously to a guest manipulating a virtualized device and is
similar to KVM's ioeventfd.

Bug: 338347082
Link: https://lore.kernel.org/all/20240222-gunyah-v17-34-1e9da6763d38@quicinc.com/
Change-Id: Ic01e6a05f268b278a972fc28fb70168c14894537
Reviewed-by: Alex Elder <elder@linaro.org>
Co-developed-by: Prakruthi Deepak Heragu <quic_pheragu@quicinc.com>
Signed-off-by: Prakruthi Deepak Heragu <quic_pheragu@quicinc.com>
Signed-off-by: Elliot Berman <quic_eberman@quicinc.com>
Signed-off-by: Sreenad Menon <quic_sreemeno@quicinc.com>
[Elliot: s/eventfd_signal(..., 1)/event_fd_signal(...)/]
Signed-off-by: Elliot Berman <elliot.berman@oss.qualcomm.com>
This commit is contained in:
Elliot Berman
2024-02-22 15:16:57 -08:00
committed by Treehugger Robot
parent ee28f77ed3
commit bce108b74e
4 changed files with 186 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
drivers/virt/gunyah/Kconfig
+9
View File
@@ -36,3 +36,12 @@ config GUNYAH_IRQFD
on Gunyah virtual machine.
Say Y/M here if unsure and you want to support Gunyah VMMs.
config GUNYAH_IOEVENTFD
tristate "Gunyah ioeventfd interface"
depends on GUNYAH
help
Enable kernel support for creating ioeventfds which can alert userspace
when a Gunyah virtual machine accesses a memory address.
Say Y/M here if unsure and you want to support Gunyah VMMs.
drivers/virt/gunyah/Makefile
+1
View File
@@ -6,3 +6,4 @@ obj-$(CONFIG_GUNYAH) += gunyah.o gunyah_rsc_mgr.o gunyah_vcpu.o
obj-$(CONFIG_GUNYAH_PLATFORM_HOOKS) += gunyah_platform_hooks.o
obj-$(CONFIG_GUNYAH_QCOM_PLATFORM) += gunyah_qcom.o
obj-$(CONFIG_GUNYAH_IRQFD) += gunyah_irqfd.o
obj-$(CONFIG_GUNYAH_IOEVENTFD) += gunyah_ioeventfd.o
drivers/virt/gunyah/gunyah_ioeventfd.c
+139
View File
@@ -0,0 +1,139 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#include <linux/eventfd.h>
#include <linux/device/driver.h>
#include <linux/file.h>
#include <linux/fs.h>
#include <linux/gunyah.h>
#include <linux/module.h>
#include <linux/printk.h>
#include <uapi/linux/gunyah.h>
struct gunyah_ioeventfd {
struct gunyah_vm_function_instance *f;
struct gunyah_vm_io_handler io_handler;
struct eventfd_ctx *ctx;
};
static int gunyah_write_ioeventfd(struct gunyah_vm_io_handler *io_dev, u64 addr,
u32 len, u64 data)
{
struct gunyah_ioeventfd *iofd =
container_of(io_dev, struct gunyah_ioeventfd, io_handler);
eventfd_signal(iofd->ctx);
return 0;
}
static struct gunyah_vm_io_handler_ops io_ops = {
.write = gunyah_write_ioeventfd,
};
static long gunyah_ioeventfd_bind(struct gunyah_vm_function_instance *f)
{
const struct gunyah_fn_ioeventfd_arg *args = f->argp;
struct gunyah_ioeventfd *iofd;
struct eventfd_ctx *ctx;
int ret;
if (f->arg_size != sizeof(*args))
return -EINVAL;
/* All other flag bits are reserved for future use */
if (args->flags & ~GUNYAH_IOEVENTFD_FLAGS_DATAMATCH)
return -EINVAL;
/* must be natural-word sized, or 0 to ignore length */
switch (args->len) {
case 0:
case 1:
case 2:
case 4:
case 8:
break;
default:
return -EINVAL;
}
/* check for range overflow */
if (overflows_type(args->addr + args->len, u64))
return -EINVAL;
/* ioeventfd with no length can't be combined with DATAMATCH */
if (!args->len && (args->flags & GUNYAH_IOEVENTFD_FLAGS_DATAMATCH))
return -EINVAL;
ctx = eventfd_ctx_fdget(args->fd);
if (IS_ERR(ctx))
return PTR_ERR(ctx);
iofd = kzalloc(sizeof(*iofd), GFP_KERNEL);
if (!iofd) {
ret = -ENOMEM;
goto err_eventfd;
}
f->data = iofd;
iofd->f = f;
iofd->ctx = ctx;
if (args->flags & GUNYAH_IOEVENTFD_FLAGS_DATAMATCH) {
iofd->io_handler.datamatch = true;
iofd->io_handler.len = args->len;
iofd->io_handler.data = args->datamatch;
}
iofd->io_handler.addr = args->addr;
iofd->io_handler.ops = &io_ops;
ret = gunyah_vm_add_io_handler(f->ghvm, &iofd->io_handler);
if (ret)
goto err_io_dev_add;
return 0;
err_io_dev_add:
kfree(iofd);
err_eventfd:
eventfd_ctx_put(ctx);
return ret;
}
static void gunyah_ioevent_unbind(struct gunyah_vm_function_instance *f)
{
struct gunyah_ioeventfd *iofd = f->data;
gunyah_vm_remove_io_handler(iofd->f->ghvm, &iofd->io_handler);
eventfd_ctx_put(iofd->ctx);
kfree(iofd);
}
static bool gunyah_ioevent_compare(const struct gunyah_vm_function_instance *f,
const void *arg, size_t size)
{
const struct gunyah_fn_ioeventfd_arg *instance = f->argp, *other = arg;
if (sizeof(*other) != size)
return false;
if (instance->addr != other->addr || instance->len != other->len ||
instance->flags != other->flags)
return false;
if ((instance->flags & GUNYAH_IOEVENTFD_FLAGS_DATAMATCH) &&
instance->datamatch != other->datamatch)
return false;
return true;
}
DECLARE_GUNYAH_VM_FUNCTION_INIT(ioeventfd, GUNYAH_FN_IOEVENTFD, 3,
gunyah_ioeventfd_bind, gunyah_ioevent_unbind,
gunyah_ioevent_compare);
MODULE_DESCRIPTION("Gunyah ioeventfd VM Function");
MODULE_LICENSE("GPL");
include/uapi/linux/gunyah.h
+37
View File
@@ -65,10 +65,13 @@ struct gunyah_vm_dtb_config {
* Return: file descriptor to manipulate the vcpu.
* @GUNYAH_FN_IRQFD: register eventfd to assert a Gunyah doorbell
* &struct gunyah_fn_desc.arg is a pointer to &struct gunyah_fn_irqfd_arg
* @GUNYAH_FN_IOEVENTFD: register ioeventfd to trigger when VM faults on parameter
* &struct gunyah_fn_desc.arg is a pointer to &struct gunyah_fn_ioeventfd_arg
*/
enum gunyah_fn_type {
GUNYAH_FN_VCPU = 1,
GUNYAH_FN_IRQFD,
GUNYAH_FN_IOEVENTFD,
};
#define GUNYAH_FN_MAX_ARG_SIZE 256
@@ -120,6 +123,40 @@ struct gunyah_fn_irqfd_arg {
__u32 padding;
};
/**
* enum gunyah_ioeventfd_flags - flags for use in gunyah_fn_ioeventfd_arg
* @GUNYAH_IOEVENTFD_FLAGS_DATAMATCH: the event will be signaled only if the
* written value to the registered address is
* equal to &struct gunyah_fn_ioeventfd_arg.datamatch
*/
enum gunyah_ioeventfd_flags {
GUNYAH_IOEVENTFD_FLAGS_DATAMATCH = 1UL << 0,
};
/**
* struct gunyah_fn_ioeventfd_arg - Arguments to create an ioeventfd function
* @datamatch: data used when GUNYAH_IOEVENTFD_DATAMATCH is set
* @addr: Address in guest memory
* @len: Length of access
* @fd: When ioeventfd is matched, this eventfd is written
* @flags: See &enum gunyah_ioeventfd_flags
* @padding: padding bytes
*
* Create this function with &GUNYAH_VM_ADD_FUNCTION using type &GUNYAH_FN_IOEVENTFD.
*
* Attaches an ioeventfd to a legal mmio address within the guest. A guest write
* in the registered address will signal the provided event instead of triggering
* an exit on the GUNYAH_VCPU_RUN ioctl.
*/
struct gunyah_fn_ioeventfd_arg {
__u64 datamatch;
__u64 addr; /* legal mmio address */
__u32 len; /* 1, 2, 4, or 8 bytes; or 0 to ignore length */
__s32 fd;
__u32 flags;
__u32 padding;
};
/**
* struct gunyah_fn_desc - Arguments to create a VM function
* @type: Type of the function. See &enum gunyah_fn_type.