From patchwork Fri Aug 11 07:14:58 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yi Liu X-Patchwork-Id: 134363 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:b824:0:b0:3f2:4152:657d with SMTP id z4csp933167vqi; Fri, 11 Aug 2023 01:17:10 -0700 (PDT) X-Google-Smtp-Source: AGHT+IGUiTC+ffR2s/YN5HJTi0xd+Md5CULNcXwdcfCsHyJ6UBpalRH3vLfQA5LBXOTDW2kLh9GN X-Received: by 2002:a17:906:3f48:b0:99d:6eea:8e34 with SMTP id f8-20020a1709063f4800b0099d6eea8e34mr1018829ejj.75.1691741830520; Fri, 11 Aug 2023 01:17:10 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1691741830; cv=none; d=google.com; s=arc-20160816; b=ra0swq/K/DD1VSx84HdPcdafnEl42byP6td7Nr2U88icoxejVbYuBNrKQMguegWmOQ TLocfvuhzNp2OdM6ZwmnPRYO7WMbT2bIIy4okTE7PGKq6z6KXFNVs+/ndz9FhEKObNsS rDXFLQOl66IG2XLh7LeDaMAMyLR8oTaM9r04Rem34YtG2CMItVPwDL2RKctXXKP3YZeJ AIchZVWyuZFW56uGhCnvUSX6qfODLI5n2DuNt7CCOPqoH17vfjVNNMQ+YCDJnulFkSu9 LHQXBE4ObYscqEqWzXnc3qsA0snKtSA55SD3DvyW17u5N2pvyFh6R9YzuXjLkY+t5hY7 D/nw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=qYKFcoX/32SqnlHj3mVzs0qaHMvQZg3RhZZ/J0UOMHY=; fh=25kVo4cotgMzE250R6E3K5ES7E7C2JawiavlW0h5mKU=; b=yU0KgAJKjqH59ZUhUJ3ppTamQLVeRZP/c8XwYoIlnqiOd9lgvrd8Qx85yC0kbQw1PV bL9oxS2Oa25Vr8ivDXB9TLWx2dSaJSn5Y25frDR5pw+u2A3SxJ3AKhtqxmrMTlc6aLNi VH24lZmtJZqfnLiSFQLgrS0t5s9uoyBIftI95ZbQaWjAZboj+b75fdMFdbwPiIXU5SGa sTW6K5Tj9u5DjM2kbtGvrL2oB+cUArnWJlnLk34bFQmIBGaQC5ZtLDMiHK95sm1YLHWE eDpRKAKBFqKC71DjVfQwph9z41ybZxhPsDJfiK2H0cYtMYy8ajXs12nEVb101hn7dlv8 i8Fw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@intel.com header.s=Intel header.b=S0yfxAE+; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=intel.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id y20-20020a1709064b1400b00991ece4c959si3024031eju.532.2023.08.11.01.16.37; Fri, 11 Aug 2023 01:17:10 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@intel.com header.s=Intel header.b=S0yfxAE+; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=intel.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233580AbjHKHPM (ORCPT + 99 others); Fri, 11 Aug 2023 03:15:12 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:55978 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233418AbjHKHPH (ORCPT ); Fri, 11 Aug 2023 03:15:07 -0400 Received: from mgamail.intel.com (mgamail.intel.com [192.55.52.151]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 30F31271B; Fri, 11 Aug 2023 00:15:07 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1691738107; x=1723274107; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=jyeuaCSwcnEpIvAt6SkFbJoVnSmQjh1HrN7Z4gQT92w=; b=S0yfxAE+mmtb4WARnpjgczDTEfkshOo+I3gyHKLq/Gsk5IKYv7EJrmxD 42v/Ax2MjY8uFJiK0mGCGM3eyRh1ne5n8ytvg6B5VN/+fxCDiDMn0CD6L NhwM/XyepEKJ1CnhEkVWMWOXmZi/szVn92uQtvrGtPlCgIeEqky9HzmpW Ey2Av4COYfT2OMto/lFuMs/O9PI4e95FKVIanD9Z3tB01wbBBJ9EIz1jQ 8gF0abBQkafm3UdKSZNV8Ha7SVBkHB82iD1ovm6S+vWOY1zsgCwxzJbWm 7yWFHQzWsNNWTIh3JxKKdq0xNCBef3cA3VOiELncUlI5NtXEdb52K7khQ g==; X-IronPort-AV: E=McAfee;i="6600,9927,10798"; a="351937632" X-IronPort-AV: E=Sophos;i="6.01,164,1684825200"; d="scan'208";a="351937632" Received: from fmsmga006.fm.intel.com ([10.253.24.20]) by fmsmga107.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 11 Aug 2023 00:15:04 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6600,9927,10798"; a="979142000" X-IronPort-AV: E=Sophos;i="6.01,164,1684825200"; d="scan'208";a="979142000" Received: from 984fee00a4c6.jf.intel.com ([10.165.58.231]) by fmsmga006.fm.intel.com with ESMTP; 11 Aug 2023 00:15:03 -0700 From: Yi Liu To: joro@8bytes.org, alex.williamson@redhat.com, jgg@nvidia.com, kevin.tian@intel.com, robin.murphy@arm.com, baolu.lu@linux.intel.com Cc: cohuck@redhat.com, eric.auger@redhat.com, nicolinc@nvidia.com, kvm@vger.kernel.org, mjrosato@linux.ibm.com, chao.p.peng@linux.intel.com, yi.l.liu@intel.com, yi.y.sun@linux.intel.com, peterx@redhat.com, jasowang@redhat.com, shameerali.kolothum.thodi@huawei.com, lulu@redhat.com, suravee.suthikulpanit@amd.com, iommu@lists.linux.dev, linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org, zhenzhong.duan@intel.com Subject: [PATCH v7 1/4] iommu: Move dev_iommu_ops() to private header Date: Fri, 11 Aug 2023 00:14:58 -0700 Message-Id: <20230811071501.4126-2-yi.l.liu@intel.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230811071501.4126-1-yi.l.liu@intel.com> References: <20230811071501.4126-1-yi.l.liu@intel.com> MIME-Version: 1.0 X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF, RCVD_IN_DNSWL_BLOCKED,SPF_HELO_NONE,SPF_NONE,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1773919881582960382 X-GMAIL-MSGID: 1773919881582960382 dev_iommu_ops() is essentially only used in iommu subsystem, so move to a private header to avoid being abused by other drivers. Suggested-by: Jason Gunthorpe Reviewed-by: Kevin Tian Reviewed-by: Lu Baolu Reviewed-by: Jason Gunthorpe Signed-off-by: Yi Liu --- drivers/iommu/iommu-priv.h | 11 +++++++++++ include/linux/iommu.h | 11 ----------- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/drivers/iommu/iommu-priv.h b/drivers/iommu/iommu-priv.h index 7c8011bfd153..a6e694f59f64 100644 --- a/drivers/iommu/iommu-priv.h +++ b/drivers/iommu/iommu-priv.h @@ -4,6 +4,17 @@ #include +static inline const struct iommu_ops *dev_iommu_ops(struct device *dev) +{ + /* + * Assume that valid ops must be installed if iommu_probe_device() + * has succeeded. The device ops are essentially for internal use + * within the IOMMU subsystem itself, so we should be able to trust + * ourselves not to misuse the helper. + */ + return dev->iommu->iommu_dev->ops; +} + int iommu_group_replace_domain(struct iommu_group *group, struct iommu_domain *new_domain); diff --git a/include/linux/iommu.h b/include/linux/iommu.h index d31642596675..e0245aa82b75 100644 --- a/include/linux/iommu.h +++ b/include/linux/iommu.h @@ -450,17 +450,6 @@ static inline void iommu_iotlb_gather_init(struct iommu_iotlb_gather *gather) }; } -static inline const struct iommu_ops *dev_iommu_ops(struct device *dev) -{ - /* - * Assume that valid ops must be installed if iommu_probe_device() - * has succeeded. The device ops are essentially for internal use - * within the IOMMU subsystem itself, so we should be able to trust - * ourselves not to misuse the helper. - */ - return dev->iommu->iommu_dev->ops; -} - extern int bus_iommu_probe(const struct bus_type *bus); extern bool iommu_present(const struct bus_type *bus); extern bool device_iommu_capable(struct device *dev, enum iommu_cap cap); From patchwork Fri Aug 11 07:14:59 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yi Liu X-Patchwork-Id: 134383 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:b824:0:b0:3f2:4152:657d with SMTP id z4csp965825vqi; Fri, 11 Aug 2023 02:38:21 -0700 (PDT) X-Google-Smtp-Source: AGHT+IFWC5cgWLDTQ1KYPuRDqLKxhc37SiTGqud3nFtEtxyYU2ClGot2iQWUk/VEBJw5/Nd7z4ow X-Received: by 2002:a17:903:2643:b0:1b8:649d:3652 with SMTP id je3-20020a170903264300b001b8649d3652mr876546plb.32.1691746700807; Fri, 11 Aug 2023 02:38:20 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1691746700; cv=none; d=google.com; s=arc-20160816; b=ceNdSgBw1uHFRiqynBDNmfW8W57tLxDiyN9IPFvX6qGLDViJee+/NCpunX1CqGMFf1 d6KKA6L/WzcXOrz6Ys99uCMB2/IdjikeS7WgfBYotD8XF+zwz/PWdPas4g8LpeZKvOy9 53OcHrlaC2uw2Cb6rKQM1MYiQWwv4pW2YIGF5tzDd9NZDgv4DtgRKd+fOmGFyk2Qb5YM 9GMNl3ymtdac9AAbE0+UeGal1KQ4MrV4ecMroHFlWOEtt6QOa0U2hSku7hSJcpvqEo64 gBi0Rl4zoMqC4dWN4TXyZdI7Yq2XfREA4hW3n2TMyvn0dCPJnRhBsgeXT3B81UqAgTtb nzUw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=mNzVbIS9esikMQCX6OsBAZkjdkau0ltmXr1Ruc5Qz5o=; fh=25kVo4cotgMzE250R6E3K5ES7E7C2JawiavlW0h5mKU=; b=p0vvvuyFfHKIhnUoc2+rLlmywmzOp0BCIBFTYccBq6n1s272FX8xA/sz6hiwzk/d4F lK/rdivG8qF7thb90IPADmlLd/4QppDJteXbPx+vO5ZyUWz7e47uop00ZTrnR4NkNVLB F3rKvkjgS4NLgEPhnnr6XSQ/q0BMe3RVU32APT4Myxk8O27bpF2ImR5gLKerWjKUF4Tf y9mcdHyPApy+MADbdDBkBx5z6dqaA+amihtMddXPak7Lq7UrbUv0xJeflD8QJ4oWa7vx cp22YnTpl6eCvz7IZIc+Qxd5wKrjgYq0MD+vdMrg0eIU1oRYeLoooOPfV8i3e5wOwdV7 xwtQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@intel.com header.s=Intel header.b=iq4joCSj; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=intel.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id b11-20020a170902d50b00b001a6bb7b7a44si3109257plg.307.2023.08.11.02.38.06; Fri, 11 Aug 2023 02:38:20 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@intel.com header.s=Intel header.b=iq4joCSj; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=intel.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233800AbjHKHPZ (ORCPT + 99 others); Fri, 11 Aug 2023 03:15:25 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:41240 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233618AbjHKHPS (ORCPT ); Fri, 11 Aug 2023 03:15:18 -0400 Received: from mgamail.intel.com (mgamail.intel.com [192.55.52.151]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 612882D70; Fri, 11 Aug 2023 00:15:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1691738113; x=1723274113; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=sxfubDWI2gwfOBW2/jdEN8IlvwFA21yaOXGd5zVExW0=; b=iq4joCSjZeuZeJeuf7/sycTZfL8uX/VHLuBn9Cm0A9Z3DcZZrZJktkX9 Am0c5grRsBb5qNNj7omWXwedks5oZNyn5TeCZrBPcEL/vEVeWXLMN2X2U V4n3c+6FV1cZDIg6EOkgt8r6LZizeQ/z62VtFdaYtcrrS6qw8rXV4RXmo tZQunHsXd5m81tN/4hfNa+OJcHX2CbPS6Ovfcq0Vbic9W1fnmBwyP6svC 3riRhPXv+NPTRLZAN0Nqmxt+3Ink84yVJRAtn6/ObqIX4Ek4n+rh+K/71 N+RjJm+lgRnMo91Bzijfs0SptRdCLGmJOWQ1XTBLa/xXEYO2J45Q9tmxI Q==; X-IronPort-AV: E=McAfee;i="6600,9927,10798"; a="351937653" X-IronPort-AV: E=Sophos;i="6.01,164,1684825200"; d="scan'208";a="351937653" Received: from fmsmga006.fm.intel.com ([10.253.24.20]) by fmsmga107.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 11 Aug 2023 00:15:05 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6600,9927,10798"; a="979142003" X-IronPort-AV: E=Sophos;i="6.01,164,1684825200"; d="scan'208";a="979142003" Received: from 984fee00a4c6.jf.intel.com ([10.165.58.231]) by fmsmga006.fm.intel.com with ESMTP; 11 Aug 2023 00:15:05 -0700 From: Yi Liu To: joro@8bytes.org, alex.williamson@redhat.com, jgg@nvidia.com, kevin.tian@intel.com, robin.murphy@arm.com, baolu.lu@linux.intel.com Cc: cohuck@redhat.com, eric.auger@redhat.com, nicolinc@nvidia.com, kvm@vger.kernel.org, mjrosato@linux.ibm.com, chao.p.peng@linux.intel.com, yi.l.liu@intel.com, yi.y.sun@linux.intel.com, peterx@redhat.com, jasowang@redhat.com, shameerali.kolothum.thodi@huawei.com, lulu@redhat.com, suravee.suthikulpanit@amd.com, iommu@lists.linux.dev, linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org, zhenzhong.duan@intel.com Subject: [PATCH v7 2/4] iommu: Add new iommu op to get iommu hardware information Date: Fri, 11 Aug 2023 00:14:59 -0700 Message-Id: <20230811071501.4126-3-yi.l.liu@intel.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230811071501.4126-1-yi.l.liu@intel.com> References: <20230811071501.4126-1-yi.l.liu@intel.com> MIME-Version: 1.0 X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF, RCVD_IN_DNSWL_BLOCKED,SPF_HELO_NONE,SPF_NONE,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1773924988408887456 X-GMAIL-MSGID: 1773924988408887456 From: Lu Baolu Introduce a new iommu op to get the IOMMU hardware capabilities for iommufd. This information will be used by any vIOMMU driver which is owned by userspace. This op chooses to make the special parameters opaque to the core. This suits the current usage model where accessing any of the IOMMU device special parameters does require a userspace driver that matches the kernel driver. If a need for common parameters, implemented similarly by several drivers, arises then there's room in the design to grow a generic parameter set as well. No wrapper API is added as it is supposed to be used by iommufd only. Different IOMMU hardware would have different hardware information. So the information reported differs as well. To let the external user understand the difference. enum iommu_hw_info_type is defined. For the iommu drivers that are capable to report hardware information, it should have a unique iommu_hw_info_type and return to caller. For the driver doesn't report hardware information, caller just uses IOMMU_HW_INFO_TYPE_NONE if a type is required. Signed-off-by: Lu Baolu Co-developed-by: Nicolin Chen Signed-off-by: Nicolin Chen Signed-off-by: Yi Liu --- include/linux/iommu.h | 9 +++++++++ include/uapi/linux/iommufd.h | 9 +++++++++ 2 files changed, 18 insertions(+) diff --git a/include/linux/iommu.h b/include/linux/iommu.h index e0245aa82b75..f2d6a3989713 100644 --- a/include/linux/iommu.h +++ b/include/linux/iommu.h @@ -228,6 +228,14 @@ struct iommu_iotlb_gather { /** * struct iommu_ops - iommu ops and capabilities * @capable: check capability + * @hw_info: IOMMU hardware information. The type of the returned data is + * marked by the output type of this op. Type is one of + * enum iommu_hw_info_type defined in include/uapi/linux/iommufd.h. + * The drivers that support this op should define a unique type + * in include/uapi/linux/iommufd.h. The data buffer returned by this + * op is allocated in the IOMMU driver and the caller should free it + * after use. Return the data buffer if success, or ERR_PTR on + * failure. * @domain_alloc: allocate iommu domain * @probe_device: Add device to iommu driver handling * @release_device: Remove device from iommu driver handling @@ -257,6 +265,7 @@ struct iommu_iotlb_gather { */ struct iommu_ops { bool (*capable)(struct device *dev, enum iommu_cap); + void *(*hw_info)(struct device *dev, u32 *length, u32 *type); /* Domain allocation and freeing by the iommu driver */ struct iommu_domain *(*domain_alloc)(unsigned iommu_domain_type); diff --git a/include/uapi/linux/iommufd.h b/include/uapi/linux/iommufd.h index 8245c01adca6..ac11ace21edb 100644 --- a/include/uapi/linux/iommufd.h +++ b/include/uapi/linux/iommufd.h @@ -370,4 +370,13 @@ struct iommu_hwpt_alloc { __u32 __reserved; }; #define IOMMU_HWPT_ALLOC _IO(IOMMUFD_TYPE, IOMMUFD_CMD_HWPT_ALLOC) + +/** + * enum iommu_hw_info_type - IOMMU Hardware Info Types + * @IOMMU_HW_INFO_TYPE_NONE: Used by the drivers that do not report hardware + * info + */ +enum iommu_hw_info_type { + IOMMU_HW_INFO_TYPE_NONE, +}; #endif From patchwork Fri Aug 11 07:15:00 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yi Liu X-Patchwork-Id: 134348 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:b824:0:b0:3f2:4152:657d with SMTP id z4csp919757vqi; Fri, 11 Aug 2023 00:44:34 -0700 (PDT) X-Google-Smtp-Source: AGHT+IEU2pwJtnffrFbmNDsbPfbNiAqmCuJgrpJn7uG7LNOk0N8haNxVgjTu/+f27EyPN4kVVogG X-Received: by 2002:a05:6808:1491:b0:3a7:9acc:4725 with SMTP id e17-20020a056808149100b003a79acc4725mr1662701oiw.54.1691739874085; Fri, 11 Aug 2023 00:44:34 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1691739874; cv=none; d=google.com; s=arc-20160816; b=Ha32qSvLSLe3tfSJCNWj900iJl97tzuO3WvMZ3xqQIzAmAhbCRDnyJ16UOjXDaejyj mwx6Qy1Y+c0w9iF/XXciJ78cL7Sfb7Mmj5PHoFJvdfu5zB2WN667Kw5Z6eHX3Y9O1WZB +VEzGJYI20Jn7KXEum1j/7RwUAt0Wddof4HuZ4bD4tSwigCjiWXm4GQIjLQZ7CqXHicR mNq54DTamHw4xj7/kT8FhpO7QrgWKPsbPg+1Nex6S/zMTUv3B1hl7PqJfTlSKRcv1BJk loust4K7yYmyr3cfC6YPYvxq0MHhN7sL/LJbBBQ6wjQEDuhFhaizWi2UQruI3446IG3T ioMQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=QQA6rNt+OgnKsPgTRglVhOFUm85DD6f/Al1S1wOAPPM=; fh=25kVo4cotgMzE250R6E3K5ES7E7C2JawiavlW0h5mKU=; b=0sENp5ruo1MUrPyCJvth/cQAja2oLbPyseTiw1UvXv5oBfE/aitrfO45Hip5MSAFdh eHCzsN3B6BOBjCaZBVQHabD4K0l3PApoPP+MH44eEJR4T2oTSrWZKbc7C7BikDtKbumA PqvGH/q4TCC0WlGEiZ2O+cGK7Qizsm8MsBPuMZ/akRJUcLPSgh+7dKbPujq2GuZA0zWf lzd5bMCroD0Q3fPI6YcaoqZHsuZlyao1T6qee03LCnA+zbXsh6BEEV3cU1Gnb4kby0gB HaNdGtdxMh5mmsBv+CQSS5fX5rx7VECPiUFHyrMF+ae3cn+InXzdBqCX6rBXmvGsW/qD O3hg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@intel.com header.s=Intel header.b=Pw68uaC2; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=intel.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id w32-20020a634920000000b0056383a7ddbcsi3118644pga.103.2023.08.11.00.44.20; Fri, 11 Aug 2023 00:44:34 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@intel.com header.s=Intel header.b=Pw68uaC2; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=intel.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233672AbjHKHPU (ORCPT + 99 others); Fri, 11 Aug 2023 03:15:20 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:41258 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233647AbjHKHPS (ORCPT ); Fri, 11 Aug 2023 03:15:18 -0400 Received: from mgamail.intel.com (mgamail.intel.com [192.55.52.151]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id ED75E2D62; Fri, 11 Aug 2023 00:15:13 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1691738114; x=1723274114; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=gCJktmK5o0cydziEmxh2sPqTHYC5v83xLEcNI/dUrtw=; b=Pw68uaC2OQ6m5A18hBhRdQmIYXERuXksxYwHhW+SJGoE2DKUUnzMYsET 6DfoK0M2GgQ1wo1N0FffeyIDNO3UFXcedIJX40wwMvYCGPJRyf1jsIOtt XLePt3qjs3mUL5UeLYzVmHcH3RNQdaxv32zBBVVw81CmT71OzakiMP/YW RsC/rYFDI49XNX03wA9IVGgvruTMEwNyZVTJPjN1+vg/nB7eTNwmfdoN3 vy/LQlnNv5882BOvxN7iPJBiE6RV2fs4RC8247+D7ujVIspS5If6Q514J CsbCyBSNKmMwku1ul8eskEcowi3CE9bgX7shYISJNZL1OYyU1iciWtWBX Q==; X-IronPort-AV: E=McAfee;i="6600,9927,10798"; a="351937694" X-IronPort-AV: E=Sophos;i="6.01,164,1684825200"; d="scan'208";a="351937694" Received: from fmsmga006.fm.intel.com ([10.253.24.20]) by fmsmga107.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 11 Aug 2023 00:15:07 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6600,9927,10798"; a="979142007" X-IronPort-AV: E=Sophos;i="6.01,164,1684825200"; d="scan'208";a="979142007" Received: from 984fee00a4c6.jf.intel.com ([10.165.58.231]) by fmsmga006.fm.intel.com with ESMTP; 11 Aug 2023 00:15:06 -0700 From: Yi Liu To: joro@8bytes.org, alex.williamson@redhat.com, jgg@nvidia.com, kevin.tian@intel.com, robin.murphy@arm.com, baolu.lu@linux.intel.com Cc: cohuck@redhat.com, eric.auger@redhat.com, nicolinc@nvidia.com, kvm@vger.kernel.org, mjrosato@linux.ibm.com, chao.p.peng@linux.intel.com, yi.l.liu@intel.com, yi.y.sun@linux.intel.com, peterx@redhat.com, jasowang@redhat.com, shameerali.kolothum.thodi@huawei.com, lulu@redhat.com, suravee.suthikulpanit@amd.com, iommu@lists.linux.dev, linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org, zhenzhong.duan@intel.com Subject: [PATCH v7 3/4] iommufd: Add IOMMU_GET_HW_INFO Date: Fri, 11 Aug 2023 00:15:00 -0700 Message-Id: <20230811071501.4126-4-yi.l.liu@intel.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230811071501.4126-1-yi.l.liu@intel.com> References: <20230811071501.4126-1-yi.l.liu@intel.com> MIME-Version: 1.0 X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF, RCVD_IN_DNSWL_BLOCKED,SPF_HELO_NONE,SPF_NONE,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1773917830254648960 X-GMAIL-MSGID: 1773917830254648960 Under nested IOMMU translation, userspace owns the stage-1 translation table (e.g. the stage-1 page table of Intel VT-d or the context table of ARM SMMUv3, and etc.). Stage-1 translation tables are vendor specific, and need to be compatible with the underlying IOMMU hardware. Hence, userspace should know the IOMMU hardware capability before creating and configuring the stage-1 translation table to kernel. This adds IOMMU_GET_HW_INFO ioctl to query the IOMMU hardware information (a.k.a capability) for a given device. The returned data is vendor specific, userspace needs to decode it with the structure mapped by the @out_data_type field. As only physical devices have IOMMU hardware, so this will return error if the given device is not a physical device. Reviewed-by: Lu Baolu Co-developed-by: Nicolin Chen Signed-off-by: Nicolin Chen Signed-off-by: Yi Liu --- drivers/iommu/iommufd/main.c | 85 ++++++++++++++++++++++++++++++++++++ include/uapi/linux/iommufd.h | 36 +++++++++++++++ 2 files changed, 121 insertions(+) diff --git a/drivers/iommu/iommufd/main.c b/drivers/iommu/iommufd/main.c index 94c498b8fdf6..d459811c5381 100644 --- a/drivers/iommu/iommufd/main.c +++ b/drivers/iommu/iommufd/main.c @@ -17,6 +17,7 @@ #include #include #include +#include "../iommu-priv.h" #include "io_pagetable.h" #include "iommufd_private.h" @@ -177,6 +178,87 @@ static int iommufd_destroy(struct iommufd_ucmd *ucmd) return 0; } +static int iommufd_fill_hw_info(struct device *dev, void __user *user_ptr, + unsigned int *length, u32 *type) +{ + const struct iommu_ops *ops; + unsigned int data_len; + void *data; + int rc = 0; + + ops = dev_iommu_ops(dev); + if (!ops->hw_info) { + *length = 0; + *type = IOMMU_HW_INFO_TYPE_NONE; + return 0; + } + + data = ops->hw_info(dev, &data_len, type); + if (IS_ERR(data)) + return PTR_ERR(data); + + /* + * drivers that have hw_info callback should have a unique + * iommu_hw_info_type. + */ + if (WARN_ON_ONCE(*type == IOMMU_HW_INFO_TYPE_NONE)) { + rc = -ENODEV; + goto err_free; + } + + *length = min(*length, data_len); + if (copy_to_user(user_ptr, data, *length)) { + rc = -EFAULT; + goto err_free; + } + +err_free: + kfree(data); + return rc; +} + +static int iommufd_get_hw_info(struct iommufd_ucmd *ucmd) +{ + struct iommu_hw_info *cmd = ucmd->cmd; + unsigned int length = cmd->data_len; + struct iommufd_device *idev; + void __user *user_ptr; + u32 hw_info_type; + int rc = 0; + + if (cmd->flags || cmd->__reserved || !cmd->data_len) + return -EOPNOTSUPP; + + idev = iommufd_get_device(ucmd, cmd->dev_id); + if (IS_ERR(idev)) + return PTR_ERR(idev); + + user_ptr = u64_to_user_ptr(cmd->data_ptr); + + rc = iommufd_fill_hw_info(idev->dev, user_ptr, + &length, &hw_info_type); + if (rc) + goto err_put; + + /* + * Zero the trailing bytes if the user buffer is bigger than the + * data size kernel actually has. + */ + if (length < cmd->data_len) { + rc = clear_user(user_ptr + length, cmd->data_len - length); + if (rc) + goto err_put; + } + + cmd->data_len = length; + cmd->out_data_type = hw_info_type; + rc = iommufd_ucmd_respond(ucmd, sizeof(*cmd)); + +err_put: + iommufd_put_object(&idev->obj); + return rc; +} + static int iommufd_fops_open(struct inode *inode, struct file *filp) { struct iommufd_ctx *ictx; @@ -265,6 +347,7 @@ static int iommufd_option(struct iommufd_ucmd *ucmd) union ucmd_buffer { struct iommu_destroy destroy; + struct iommu_hw_info info; struct iommu_hwpt_alloc hwpt; struct iommu_ioas_alloc alloc; struct iommu_ioas_allow_iovas allow_iovas; @@ -297,6 +380,8 @@ struct iommufd_ioctl_op { } static const struct iommufd_ioctl_op iommufd_ioctl_ops[] = { IOCTL_OP(IOMMU_DESTROY, iommufd_destroy, struct iommu_destroy, id), + IOCTL_OP(IOMMU_GET_HW_INFO, iommufd_get_hw_info, struct iommu_hw_info, + __reserved), IOCTL_OP(IOMMU_HWPT_ALLOC, iommufd_hwpt_alloc, struct iommu_hwpt_alloc, __reserved), IOCTL_OP(IOMMU_IOAS_ALLOC, iommufd_ioas_alloc_ioctl, diff --git a/include/uapi/linux/iommufd.h b/include/uapi/linux/iommufd.h index ac11ace21edb..4a00f8fb2d54 100644 --- a/include/uapi/linux/iommufd.h +++ b/include/uapi/linux/iommufd.h @@ -46,6 +46,7 @@ enum { IOMMUFD_CMD_OPTION, IOMMUFD_CMD_VFIO_IOAS, IOMMUFD_CMD_HWPT_ALLOC, + IOMMUFD_CMD_GET_HW_INFO, }; /** @@ -379,4 +380,39 @@ struct iommu_hwpt_alloc { enum iommu_hw_info_type { IOMMU_HW_INFO_TYPE_NONE, }; + +/** + * struct iommu_hw_info - ioctl(IOMMU_GET_HW_INFO) + * @size: sizeof(struct iommu_hw_info) + * @flags: Must be 0 + * @dev_id: The device bound to the iommufd + * @data_len: Input the length of the user buffer in bytes. Output the length + * of data filled in the user buffer. + * @data_ptr: Pointer to the user buffer + * @out_data_type: Output the iommu hardware info type as defined in the enum + * iommu_hw_info_type. + * @__reserved: Must be 0 + * + * Query the hardware information from an iommu behind a given device that has + * been bound to iommufd. @data_len is the size of the buffer, which captures an + * iommu type specific input data and a filled output data. Trailing bytes will + * be zeroed if the user buffer is larger than the data kernel has. + * + * The type specific data would be used to sync capabilities between the virtual + * IOMMU and the hardware IOMMU, e.g. a nested translation setup needs to check + * the hardware information, so the guest stage-1 page table will be compatible. + * + * The @out_data_type will be filled if the ioctl succeeds. It would be used to + * decode the data filled in the buffer pointed by @data_ptr. + */ +struct iommu_hw_info { + __u32 size; + __u32 flags; + __u32 dev_id; + __u32 data_len; + __aligned_u64 data_ptr; + __u32 out_data_type; + __u32 __reserved; +}; +#define IOMMU_GET_HW_INFO _IO(IOMMUFD_TYPE, IOMMUFD_CMD_GET_HW_INFO) #endif From patchwork Fri Aug 11 07:15:01 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yi Liu X-Patchwork-Id: 134362 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:b824:0:b0:3f2:4152:657d with SMTP id z4csp932129vqi; Fri, 11 Aug 2023 01:14:30 -0700 (PDT) X-Google-Smtp-Source: AGHT+IGc30CcNXhK8Grx8nzeF+9SPdHz3/f5vjVW7mfweObxMCcovAwyIJ7CSK8o7V1iNQRjnugd X-Received: by 2002:a17:906:59:b0:99c:55c0:acfd with SMTP id 25-20020a170906005900b0099c55c0acfdmr1098231ejg.62.1691741669829; Fri, 11 Aug 2023 01:14:29 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1691741669; cv=none; d=google.com; s=arc-20160816; b=rtZaBCl7OxHTwiP8LrAHGokJicqAGaaJqf7zKB1zT0kyqQw3ZOBp7nVf4bG7HsvKNn LlBd4DbkdlZinaex6nAwt6YGIReoJ0odcWdFJ/O9kLbvkXRJ/zfyzUQ2o42BTsBpxb2o 2bqEaZyM6Ys9i0loJD/GmBHTm6ktRJM/kYzCyU2a9ScgcF9bCVAqKnHXd0BiLy6pbJ42 v/ikv1gPzPLlze9J+zZYDkBgn9LjU3Q23utqbCPgnUINVUqJreCjyCjk4lCH9KVWIFFG wXkFIExduTSi2tQbciaAXHRbSvYZTRBIo3u04TR9CTFBuPYYRvgHpE29yC+NoPIzkTit jbeA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=UDTwamCPPbDmhkUIyvYp847yPUGCPSPRQ9Y/RUP5MY4=; fh=25kVo4cotgMzE250R6E3K5ES7E7C2JawiavlW0h5mKU=; b=1HvfsTQVHnoog0JUAG8Oz+MAnbul3lP7pyoCZzjSLKlR3Dd+SDbBostpePMId/u8Am 5ymS7A8eYm+Z1kmOYSl0DDmqiAewnsqr1zJWIOqgO/QMhAs03DEo2Z2sSXXZGpnaGIgY f3FVX4He1elUUWmxSA/aJktxSfVzV6x+E9/pvp8qkVv7wJ9QZzuM+4GIwlZzKr9pvzxk z2rhdqO72s9FT0tTXH7aIoofLoxOh4ujEP3DG6uWNXOMei5yOD2xwoUWjarHNuQEBRKH 9znhVtOhynKUtTYM3PRK7nF3KnnH733MsGX04gxvpvWlLggM1xF8Z4070+UTFwwgHLzw JT0w== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@intel.com header.s=Intel header.b=K+u0O+5V; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=intel.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id l26-20020a1709061c5a00b009980c2658desi3029275ejg.76.2023.08.11.01.14.05; Fri, 11 Aug 2023 01:14:29 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@intel.com header.s=Intel header.b=K+u0O+5V; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=intel.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233528AbjHKHPc (ORCPT + 99 others); Fri, 11 Aug 2023 03:15:32 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:41272 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233755AbjHKHPU (ORCPT ); Fri, 11 Aug 2023 03:15:20 -0400 Received: from mgamail.intel.com (mgamail.intel.com [192.55.52.151]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 800F530D3; Fri, 11 Aug 2023 00:15:16 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1691738116; x=1723274116; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=xXnjiBk5Rm1Wh/mIr4DvEInc/Fi8Guc3wJK5YvAkue4=; b=K+u0O+5VCi5YzKvqgyeFsA5FM6tsBrIoM8fojZnBXH7o5OoMGeL8HFpv Rw1N7u0/34/ddFlwpcfLA0cdVtf2bkknwkfEedhxIk+EY9b6msqV7RFtZ XE5I+RsISZLTcPzQBAlLfkQdL20scFoi4HfzWXjjYa6KT7nqtsW3hFhbX QYnVABSSDOBJX2qfm0cG4SczzhWjuGO5TE4lV1UQ//nPUgI3veGVgMBdS ULi012+rZeLpBwOYWfXzhlt6IdZLBJRlKxE33QCBBmEWP97AJZ1pqPEeO RovjHxdlUw9zQPWfkUdbHuz+UBcTgtWq5loS8hXmT3KiVgfvo71btkYcU Q==; X-IronPort-AV: E=McAfee;i="6600,9927,10798"; a="351937717" X-IronPort-AV: E=Sophos;i="6.01,164,1684825200"; d="scan'208";a="351937717" Received: from fmsmga006.fm.intel.com ([10.253.24.20]) by fmsmga107.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 11 Aug 2023 00:15:08 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6600,9927,10798"; a="979142010" X-IronPort-AV: E=Sophos;i="6.01,164,1684825200"; d="scan'208";a="979142010" Received: from 984fee00a4c6.jf.intel.com ([10.165.58.231]) by fmsmga006.fm.intel.com with ESMTP; 11 Aug 2023 00:15:07 -0700 From: Yi Liu To: joro@8bytes.org, alex.williamson@redhat.com, jgg@nvidia.com, kevin.tian@intel.com, robin.murphy@arm.com, baolu.lu@linux.intel.com Cc: cohuck@redhat.com, eric.auger@redhat.com, nicolinc@nvidia.com, kvm@vger.kernel.org, mjrosato@linux.ibm.com, chao.p.peng@linux.intel.com, yi.l.liu@intel.com, yi.y.sun@linux.intel.com, peterx@redhat.com, jasowang@redhat.com, shameerali.kolothum.thodi@huawei.com, lulu@redhat.com, suravee.suthikulpanit@amd.com, iommu@lists.linux.dev, linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org, zhenzhong.duan@intel.com Subject: [PATCH v7 4/4] iommufd/selftest: Add coverage for IOMMU_GET_HW_INFO ioctl Date: Fri, 11 Aug 2023 00:15:01 -0700 Message-Id: <20230811071501.4126-5-yi.l.liu@intel.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230811071501.4126-1-yi.l.liu@intel.com> References: <20230811071501.4126-1-yi.l.liu@intel.com> MIME-Version: 1.0 X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF, RCVD_IN_DNSWL_BLOCKED,SPF_HELO_NONE,SPF_NONE,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1773919713173001193 X-GMAIL-MSGID: 1773919713173001193 From: Nicolin Chen Add a mock_domain_hw_info function and an iommu_test_hw_info data structure. This allows to test the IOMMU_GET_HW_INFO ioctl passing the test_reg value for the mock_dev. Signed-off-by: Nicolin Chen Signed-off-by: Yi Liu --- drivers/iommu/iommufd/iommufd_test.h | 9 ++++ drivers/iommu/iommufd/selftest.c | 16 +++++++ tools/testing/selftests/iommu/iommufd.c | 28 ++++++++++- .../selftests/iommu/iommufd_fail_nth.c | 4 ++ tools/testing/selftests/iommu/iommufd_utils.h | 47 +++++++++++++++++++ 5 files changed, 103 insertions(+), 1 deletion(-) diff --git a/drivers/iommu/iommufd/iommufd_test.h b/drivers/iommu/iommufd/iommufd_test.h index 258de2253b61..3f3644375bf1 100644 --- a/drivers/iommu/iommufd/iommufd_test.h +++ b/drivers/iommu/iommufd/iommufd_test.h @@ -100,4 +100,13 @@ struct iommu_test_cmd { }; #define IOMMU_TEST_CMD _IO(IOMMUFD_TYPE, IOMMUFD_CMD_BASE + 32) +/* Mock structs for IOMMU_DEVICE_GET_HW_INFO ioctl */ +#define IOMMU_HW_INFO_TYPE_SELFTEST 0xfeedbeef +#define IOMMU_HW_INFO_SELFTEST_REGVAL 0xdeadbeef + +struct iommu_test_hw_info { + __u32 flags; + __u32 test_reg; +}; + #endif diff --git a/drivers/iommu/iommufd/selftest.c b/drivers/iommu/iommufd/selftest.c index bb2cd54ca7b6..ab4011e3a7c6 100644 --- a/drivers/iommu/iommufd/selftest.c +++ b/drivers/iommu/iommufd/selftest.c @@ -128,6 +128,21 @@ static struct iommu_domain mock_blocking_domain = { .ops = &mock_blocking_ops, }; +static void *mock_domain_hw_info(struct device *dev, u32 *length, u32 *type) +{ + struct iommu_test_hw_info *info; + + info = kzalloc(sizeof(*info), GFP_KERNEL); + if (!info) + return ERR_PTR(-ENOMEM); + + info->test_reg = IOMMU_HW_INFO_SELFTEST_REGVAL; + *length = sizeof(*info); + *type = IOMMU_HW_INFO_TYPE_SELFTEST; + + return info; +} + static struct iommu_domain *mock_domain_alloc(unsigned int iommu_domain_type) { struct mock_iommu_domain *mock; @@ -279,6 +294,7 @@ static void mock_domain_set_plaform_dma_ops(struct device *dev) static const struct iommu_ops mock_ops = { .owner = THIS_MODULE, .pgsize_bitmap = MOCK_IO_PAGE_SIZE, + .hw_info = mock_domain_hw_info, .domain_alloc = mock_domain_alloc, .capable = mock_domain_capable, .set_platform_dma_ops = mock_domain_set_plaform_dma_ops, diff --git a/tools/testing/selftests/iommu/iommufd.c b/tools/testing/selftests/iommu/iommufd.c index 8acd0af37aa5..7e0fdf372c12 100644 --- a/tools/testing/selftests/iommu/iommufd.c +++ b/tools/testing/selftests/iommu/iommufd.c @@ -113,6 +113,7 @@ TEST_F(iommufd, cmd_length) } TEST_LENGTH(iommu_destroy, IOMMU_DESTROY); + TEST_LENGTH(iommu_hw_info, IOMMU_GET_HW_INFO); TEST_LENGTH(iommu_ioas_alloc, IOMMU_IOAS_ALLOC); TEST_LENGTH(iommu_ioas_iova_ranges, IOMMU_IOAS_IOVA_RANGES); TEST_LENGTH(iommu_ioas_allow_iovas, IOMMU_IOAS_ALLOW_IOVAS); @@ -185,6 +186,7 @@ FIXTURE(iommufd_ioas) uint32_t ioas_id; uint32_t stdev_id; uint32_t hwpt_id; + uint32_t device_id; uint64_t base_iova; }; @@ -211,7 +213,7 @@ FIXTURE_SETUP(iommufd_ioas) for (i = 0; i != variant->mock_domains; i++) { test_cmd_mock_domain(self->ioas_id, &self->stdev_id, - &self->hwpt_id, NULL); + &self->hwpt_id, &self->device_id); self->base_iova = MOCK_APERTURE_START; } } @@ -290,6 +292,30 @@ TEST_F(iommufd_ioas, ioas_area_auto_destroy) } } +TEST_F(iommufd_ioas, get_hw_info) +{ + struct iommu_test_hw_info buffer_exact; + struct iommu_test_hw_info_buffer { + struct iommu_test_hw_info info; + uint64_t trailing_bytes; + } buffer_larger; + + if (self->device_id) { + /* Provide a user_buffer with exact size */ + test_cmd_get_hw_info(self->device_id, &buffer_exact, sizeof(buffer_exact)); + /* + * Provide a user_buffer with size larger than the exact size to check if + * kernel zero the trailing bytes. + */ + test_cmd_get_hw_info(self->device_id, &buffer_larger, sizeof(buffer_larger)); + } else { + test_err_get_hw_info(ENOENT, self->device_id, + &buffer_exact, sizeof(buffer_exact)); + test_err_get_hw_info(ENOENT, self->device_id, + &buffer_larger, sizeof(buffer_larger)); + } +} + TEST_F(iommufd_ioas, area) { int i; diff --git a/tools/testing/selftests/iommu/iommufd_fail_nth.c b/tools/testing/selftests/iommu/iommufd_fail_nth.c index d4c552e56948..a220ca2a689d 100644 --- a/tools/testing/selftests/iommu/iommufd_fail_nth.c +++ b/tools/testing/selftests/iommu/iommufd_fail_nth.c @@ -576,6 +576,7 @@ TEST_FAIL_NTH(basic_fail_nth, access_pin_domain) /* device.c */ TEST_FAIL_NTH(basic_fail_nth, device) { + struct iommu_test_hw_info info; uint32_t ioas_id; uint32_t ioas_id2; uint32_t stdev_id; @@ -611,6 +612,9 @@ TEST_FAIL_NTH(basic_fail_nth, device) &idev_id)) return -1; + if (_test_cmd_get_hw_info(self->fd, idev_id, &info, sizeof(info))) + return -1; + if (_test_cmd_hwpt_alloc(self->fd, idev_id, ioas_id, &hwpt_id)) return -1; diff --git a/tools/testing/selftests/iommu/iommufd_utils.h b/tools/testing/selftests/iommu/iommufd_utils.h index 70353e68e599..ccd0ef7833a0 100644 --- a/tools/testing/selftests/iommu/iommufd_utils.h +++ b/tools/testing/selftests/iommu/iommufd_utils.h @@ -348,3 +348,50 @@ static void teardown_iommufd(int fd, struct __test_metadata *_metadata) }) #endif + +static int _test_cmd_get_hw_info(int fd, __u32 device_id, + void *data, size_t data_len) +{ + struct iommu_hw_info cmd = { + .size = sizeof(cmd), + .dev_id = device_id, + .data_len = data_len, + .data_ptr = (uint64_t)data, + }; + struct iommu_test_hw_info *info = (struct iommu_test_hw_info *)data; + int ret; + + ret = ioctl(fd, IOMMU_GET_HW_INFO, &cmd); + if (ret) + return ret; + + assert(cmd.out_data_type == IOMMU_HW_INFO_TYPE_SELFTEST); + + /* + * Trailing bytes should be 0 if user buffer is larger than + * the data that kernel reports. + */ + if (data_len > cmd.data_len) { + char *ptr = (char *)(data + cmd.data_len); + int idx = 0; + + while (idx < data_len - cmd.data_len) { + assert(!*(ptr + idx)); + idx++; + } + } + + assert(info->test_reg == IOMMU_HW_INFO_SELFTEST_REGVAL); + assert(!info->flags); + + return 0; +} + +#define test_cmd_get_hw_info(device_id, data, data_len) \ + ASSERT_EQ(0, _test_cmd_get_hw_info(self->fd, device_id, \ + data, data_len)) + +#define test_err_get_hw_info(_errno, device_id, data, data_len) \ + EXPECT_ERRNO(_errno, \ + _test_cmd_get_hw_info(self->fd, device_id, \ + data, data_len))