From patchwork Tue Jan 9 19:38:11 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Elliot Berman X-Patchwork-Id: 13515373 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 94B73C4707C for ; Tue, 9 Jan 2024 20:03:14 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 1CE486B00B1; Tue, 9 Jan 2024 15:03:14 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 17E626B00B2; Tue, 9 Jan 2024 15:03:14 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id EEAD86B00B3; Tue, 9 Jan 2024 15:03:13 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0012.hostedemail.com [216.40.44.12]) by kanga.kvack.org (Postfix) with ESMTP id D7BD76B00B1 for ; Tue, 9 Jan 2024 15:03:13 -0500 (EST) Received: from smtpin28.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay08.hostedemail.com (Postfix) with ESMTP id ACA321409FA for ; Tue, 9 Jan 2024 20:03:13 +0000 (UTC) X-FDA: 81660846666.28.2C176CC Received: from mx0a-0031df01.pphosted.com (mx0a-0031df01.pphosted.com [205.220.168.131]) by imf13.hostedemail.com (Postfix) with ESMTP id 4F5E120020 for ; Tue, 9 Jan 2024 20:03:11 +0000 (UTC) Authentication-Results: imf13.hostedemail.com; dkim=pass header.d=quicinc.com header.s=qcppdkim1 header.b=M+oc6rkS; spf=pass (imf13.hostedemail.com: domain of quic_eberman@quicinc.com designates 205.220.168.131 as permitted sender) smtp.mailfrom=quic_eberman@quicinc.com; dmarc=pass (policy=none) header.from=quicinc.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1704830591; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=CFZQM9HHgwsq85wbA4HaJDXM+Ti//VjdbRwqaGcKBmo=; b=VOQ28rzpMDGC9HAXt3Phihns7oTEkCRCiHHUKc/2lnPDl1y0xzoyktPMBthxPhz/+dc1Ij Hv4geP7IhZREEbYyypKTBKK5w0CUriAfBL7KFLZodUWrxKy/pic/+MrmoplSoh+LyWD5zR piLks1J/VTDdJvugs7IudQvG7TiQrXA= ARC-Authentication-Results: i=1; imf13.hostedemail.com; dkim=pass header.d=quicinc.com header.s=qcppdkim1 header.b=M+oc6rkS; spf=pass (imf13.hostedemail.com: domain of quic_eberman@quicinc.com designates 205.220.168.131 as permitted sender) smtp.mailfrom=quic_eberman@quicinc.com; dmarc=pass (policy=none) header.from=quicinc.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1704830591; a=rsa-sha256; cv=none; b=U7sCYHfm1ru4xuJ7EI6vr9bdnh9Z70S+48e2Xkie6NSwp8bp+V0O9HJ6qqBeRKDaN+Ie5S IULStBXQa9X8vAIfopmVEAcS77J5Xt0CALrCPJddgSAI26qHIGbYZD2ZlV+jDzfriyGQfj 3nllgvTAgXo8ThqHfvPDcRFu3ylyLXw= Received: from pps.filterd (m0279863.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.17.1.24/8.17.1.24) with ESMTP id 409G4aDP020396; Tue, 9 Jan 2024 19:38:11 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=quicinc.com; h= from:date:subject:mime-version:content-type :content-transfer-encoding:message-id:references:in-reply-to:to :cc; s=qcppdkim1; bh=CFZQM9HHgwsq85wbA4HaJDXM+Ti//VjdbRwqaGcKBmo =; b=M+oc6rkSFe+jMKMYTEkPOSWJug2g+MbEY+O8KJwHpVmZh7f+2oV2ISiRl0T qjXb+/r2csBU6vfw6lLHFVNhxHcqmMncste+FXqfTcAFEG6lRO4suvajndNqACxZ pQApBfS4U+27uvDwRmQDiNW+CgZvcUzh3xpDS54jdKA2Vvh/GfzSlLFNsuwpZ4zt zdZwPf5aolzF2jJyqNrRDRKg/d2OO0mpECaGnVjU/JcPiVvQ8Kg6XV7KghxBwhi6 zF+pH65r5zACqta+UuRK9/8R3yMSRHO74AJWTmVvHupDAdHkKos4CRWAYNAxw1OQ tKyfAs5OD9zgcvnQRuzNwnmz8mg== Received: from nasanppmta03.qualcomm.com (i-global254.qualcomm.com [199.106.103.254]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 3vh9bmggdp-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Tue, 09 Jan 2024 19:38:11 +0000 (GMT) Received: from nasanex01b.na.qualcomm.com (nasanex01b.na.qualcomm.com [10.46.141.250]) by NASANPPMTA03.qualcomm.com (8.17.1.5/8.17.1.5) with ESMTPS id 409JcA3i011573 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Tue, 9 Jan 2024 19:38:10 GMT Received: from hu-eberman-lv.qualcomm.com (10.49.16.6) by nasanex01b.na.qualcomm.com (10.46.141.250) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1118.40; Tue, 9 Jan 2024 11:38:10 -0800 From: Elliot Berman Date: Tue, 9 Jan 2024 11:38:11 -0800 Subject: [PATCH v16 33/34] virt: gunyah: Add ioeventfd MIME-Version: 1.0 Message-ID: <20240109-gunyah-v16-33-634904bf4ce9@quicinc.com> References: <20240109-gunyah-v16-0-634904bf4ce9@quicinc.com> In-Reply-To: <20240109-gunyah-v16-0-634904bf4ce9@quicinc.com> To: Alex Elder , Srinivas Kandagatla , Murali Nalajal , Trilok Soni , Srivatsa Vaddagiri , Carl van Schaik , Philip Derrin , Prakruthi Deepak Heragu , Jonathan Corbet , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Catalin Marinas , Will Deacon , Konrad Dybcio , Bjorn Andersson , Dmitry Baryshkov , "Fuad Tabba" , Sean Christopherson , "Andrew Morton" CC: , , , , , , Elliot Berman X-Mailer: b4 0.13-dev X-Originating-IP: [10.49.16.6] X-ClientProxiedBy: nalasex01c.na.qualcomm.com (10.47.97.35) To nasanex01b.na.qualcomm.com (10.46.141.250) X-QCInternal: smtphost X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Proofpoint-ORIG-GUID: TqyjYIVU4KJsNF6XyeHikBnwWRuxaqt5 X-Proofpoint-GUID: TqyjYIVU4KJsNF6XyeHikBnwWRuxaqt5 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.272,Aquarius:18.0.997,Hydra:6.0.619,FMLib:17.11.176.26 definitions=2023-12-09_01,2023-12-07_01,2023-05-22_02 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 impostorscore=0 mlxscore=0 clxscore=1015 spamscore=0 priorityscore=1501 malwarescore=0 mlxlogscore=999 adultscore=0 bulkscore=0 suspectscore=0 lowpriorityscore=0 phishscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.19.0-2311290000 definitions=main-2401090158 X-Rspamd-Queue-Id: 4F5E120020 X-Rspam-User: X-Stat-Signature: oym743f58uzqujtr89a6km5kzkhnc6y8 X-Rspamd-Server: rspam01 X-HE-Tag: 1704830591-482278 X-HE-Meta: U2FsdGVkX19BwZumNZiRT4NhwxEtUtA5rd3KQJ0eIz20IOXaCDsHySTBmJkx2j5bTfcbLqiYPoj9/U6x6ViSq7epubZNh3Wp9iJj1REpc4NDFX1LlmbRAIubECZxW9MwOEwCwOEKy+Wg21idY4D4YJf/Ik1Gezae+vSq8t7iisPNzlO+5N1VJIEkYCpClRY/jvz85XkZkHWze6RuVXNFshNxAg7tybhgDE69v9QJSrTQ9UhNTP4R3m/YQG3CfxK5SAjE7n9hf29+jd3EYLIeThJbyn08Ql5kgUkg0QQQtfb8JINowhBghEzOPvFcdo9zhuNU630+FbbrBHir9VmbJEj+vvG8Uxb3M14S99hzVb6Us0aPDag8PeiOJXgAhUdr6UsoSNuD4Jrk6UVbQskL3cvmEkG6Kw76SRYwJgfG6w9cLcxNIQMlu555iYyubbUONGN22ZFWVdtlP1L8KhB78k1ub0hlUUHtq2u46Lu7t19doj2hAXIpHIxz+XcAHiRp2ETtrZDE13KTtj03L77RbMyibNOv1PtK9uQg1n+zKkWBPCzWN+tqGunpaSvel16l0g95oygE+HEjwaU4EeSJildFWpyBl8tJEGBrhuiJeCXm6/zA0fDl2xe9AlLaM9DmUdaFLPbXMRedrQlpImmu1EpQuU/onvuq7khVRciGud4jxVhnzUI7/PRDCzl7YSyaPUo0cenaKfDWhaR6gaGU+5xepeuSqtHVUoMcK2c3XKJpfAYSRYDBVe1em7WhFI+0iwU2mNIp/P8ubTscJccxae7CiISzyHTUts4IbX/ijma08Ci4ZQVDwNoH4YdmEInVfXHW9YtsfDG5+99hS77ZsiQa6zwylYhGH+ZQYRD3LiJAYvShKSHY248QHUjmpKNqPNKcvFx7ucBgpYU16nMEPU+/bjTO8uOWT/ZtKAV9SjASppeCbZwuVqhn7XbTzOwXbCVJZkbGATxlPu9MruX oVvNCpEz TrAqrmimHbz2CnRMoCJKgziB4TCPFpgNkNlypS6vq4XCKfzMTKji4PaQQlBRKcj0nMo/jOboBfsOY40674aOGiDryduxc0OL56UiDhMQfLCI8xILeHb+KryUAJCUbj8+4tEZv1L2jq7TMo22rA6xq/tCgoZwDuIkvc2gyy9wfFQ+KKN4GNGU4AHOeciX4xdKbouYINco4Xrt6RkL4YGu6+bOKqt+SjZf7mRYNXtOjKB1N6vdHUYwV2OWGa0xxMM5b/CE3N5p7ZhI8EyuzYxjuHCgazp5NqFk8eGeEclWX4worJhCvsPZeSDBtLh4NeE2YQIBt94QaZgyp0tJ2wsqZudc099VDhgut8i/2VazC+RgUF4pKoJOrjzC3RfEJRPYvdkggnjvUD1f+BYKGLb9p6ze8jgtO6xLPqjtr50jnLZN0selPKJc9H4tbFlIyWFTIPJZeheNg/I310JaSePAqo/eegw== X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: 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. Reviewed-by: Alex Elder Co-developed-by: Prakruthi Deepak Heragu Signed-off-by: Prakruthi Deepak Heragu Signed-off-by: Elliot Berman --- drivers/virt/gunyah/Kconfig | 9 +++ drivers/virt/gunyah/Makefile | 1 + drivers/virt/gunyah/gunyah_ioeventfd.c | 139 +++++++++++++++++++++++++++++++++ include/uapi/linux/gunyah.h | 37 +++++++++ 4 files changed, 186 insertions(+) diff --git a/drivers/virt/gunyah/Kconfig b/drivers/virt/gunyah/Kconfig index 1685b75fb77a..855d41a88b16 100644 --- a/drivers/virt/gunyah/Kconfig +++ b/drivers/virt/gunyah/Kconfig @@ -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. diff --git a/drivers/virt/gunyah/Makefile b/drivers/virt/gunyah/Makefile index b41b02792921..2aec5989402b 100644 --- a/drivers/virt/gunyah/Makefile +++ b/drivers/virt/gunyah/Makefile @@ -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 diff --git a/drivers/virt/gunyah/gunyah_ioeventfd.c b/drivers/virt/gunyah/gunyah_ioeventfd.c new file mode 100644 index 000000000000..e33924d19be4 --- /dev/null +++ b/drivers/virt/gunyah/gunyah_ioeventfd.c @@ -0,0 +1,139 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include + +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; + + eventfd_ctx_put(iofd->ctx); + gunyah_vm_remove_io_handler(iofd->f->ghvm, &iofd->io_handler); + 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"); diff --git a/include/uapi/linux/gunyah.h b/include/uapi/linux/gunyah.h index cb7b0bb9bef3..fd461e2fe8b5 100644 --- a/include/uapi/linux/gunyah.h +++ b/include/uapi/linux/gunyah.h @@ -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.