From patchwork Thu May 11 14:30:21 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yi Liu X-Patchwork-Id: 92663 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:b0ea:0:b0:3b6:4342:cba0 with SMTP id b10csp4429442vqo; Thu, 11 May 2023 07:44:43 -0700 (PDT) X-Google-Smtp-Source: ACHHUZ7pIoPM57wZNUjYDsbbo7LOItC+woNdBqd5iUa7gHXYokAm4t8a0029eyvxga0lOvRhPRlp X-Received: by 2002:a05:6a00:1794:b0:645:b13e:e674 with SMTP id s20-20020a056a00179400b00645b13ee674mr19773783pfg.26.1683816282901; Thu, 11 May 2023 07:44:42 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1683816282; cv=none; d=google.com; s=arc-20160816; b=wQhr5hh6hMhbmKrYYub7MmzkaLZ9ot7kOft4qoSjrnf9t2WRl9A90w9Um49sCyfObc t33aglz8Q+QokG22mak+RiKBdRwDaiACsTUmG1qUWqNvf4dbxhNCMsKAmKYHM3+Wu6o6 CZbD3Fry35cYdbhGPcSbJh58p6gxNoz+Nf5eC7HNoX3/3FyrbIPVCZXPnaloJfIJdbzw H/PFuYDD1bQ5751Wel9pFglEb2meU0EGgsBnil0by6hzDWxbPFpoo2M5cqwX3DytwJtp F9Hnu19MrVWBJF0kok7j6GJ1ZI2W5ZoBooCcQKwLGpXdfiR1zQrbyomUBLf6aGYtzku5 ZZWA== 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=dtitjxmXJFJnT79FzBXegSe6Rlflkg6yobnbM+8CyzE=; b=mby8vtlxapyb4eFYFOf+QZXIQrCNyGITer6DnNFMqV3SfdY9jRx2V+jAjAsFEa+DxY 3vglr8VJRB/9NVoJaX/qv7KhAlFW30Mq/HZr30GyqYhMwsYpOBFcgC2LxvBymK3pmePW JD5/DQGq1UXufL0xrVle/AEh2zLMHeObcu39b2kVcarkGdCnJiSeueFtM2Hb/Ip/kbTT saRZfS8uvhheydOjcIs32cGdBtz9E7wfC+c9c132KMVjJYUdNSDbNsVamsRHCENA5UKU C4Oud0DwW4eLDhXvn45KYriedpYWk0OrMzjxS1155HWlyaTIOZpVq/9OXSnGxlsqBC/O uJNg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@intel.com header.s=Intel header.b=R1rNBDog; 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 v71-20020a63894a000000b00524f08d75f5si6573598pgd.567.2023.05.11.07.44.30; Thu, 11 May 2023 07:44:42 -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=R1rNBDog; 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 S237754AbjEKOcQ (ORCPT + 99 others); Thu, 11 May 2023 10:32:16 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:47408 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S238523AbjEKObY (ORCPT ); Thu, 11 May 2023 10:31:24 -0400 Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 6DDAC10E79; Thu, 11 May 2023 07:30:50 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1683815450; x=1715351450; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=RhTctlSU8kGwAHBuYtQQX127URdk3c3vFpZE39HtnRs=; b=R1rNBDogmNgf2odVgWj9IvvWKzVe6S/eFP20tMLAwQXv50zhWtIAf2b3 MzeDMknwgRZ59AFS1lYynuvSXGmznffNlZeVeMxUt52kFzDH1q9gMMy37 E/GzqYOoXZpGdqqXm3tcsJQMmLu3kruv4tSvwA+4XEIEVcSy8JosWM36Q enDerg6LlOGJdtIFKT1QtlcGKJzNtIF2GeIKYgNaWLnDn2N0AS8LRs49J 4Hm4ksYa1djsRk87V4+hvxUbWI4GIGGWQgFxWdesBpy71wD10hHbQ+zh4 zC5w8Xqb/8YPXd5RDmjZI4wvSIfJjFb9gUWKJDIj/18UDiHPD+/ybGtJG A==; X-IronPort-AV: E=McAfee;i="6600,9927,10707"; a="378639860" X-IronPort-AV: E=Sophos;i="5.99,266,1677571200"; d="scan'208";a="378639860" Received: from orsmga005.jf.intel.com ([10.7.209.41]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 11 May 2023 07:30:30 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6600,9927,10707"; a="874004416" X-IronPort-AV: E=Sophos;i="5.99,266,1677571200"; d="scan'208";a="874004416" Received: from 984fee00a4c6.jf.intel.com ([10.165.58.231]) by orsmga005.jf.intel.com with ESMTP; 11 May 2023 07:30:28 -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 v3 1/4] iommu: Move dev_iommu_ops() to private header Date: Thu, 11 May 2023 07:30:21 -0700 Message-Id: <20230511143024.19542-2-yi.l.liu@intel.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230511143024.19542-1-yi.l.liu@intel.com> References: <20230511143024.19542-1-yi.l.liu@intel.com> MIME-Version: 1.0 X-Spam-Status: No, score=-4.4 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_MED, RCVD_IN_MSPIKE_H3,RCVD_IN_MSPIKE_WL,SPF_HELO_NONE,SPF_NONE, T_SCC_BODY_TEXT_LINE 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: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1765609342674235809?= X-GMAIL-MSGID: =?utf-8?q?1765609342674235809?= 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 Signed-off-by: Yi Liu --- drivers/iommu/iommu-priv.h | 11 +++++++++++ drivers/iommu/iommu.c | 2 ++ include/linux/iommu.h | 11 ----------- 3 files changed, 13 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/drivers/iommu/iommu.c b/drivers/iommu/iommu.c index 91573efd9488..b44fd1a76997 100644 --- a/drivers/iommu/iommu.c +++ b/drivers/iommu/iommu.c @@ -38,6 +38,8 @@ #include "iommu-sva.h" +#include "iommu-priv.h" + static struct kset *iommu_group_kset; static DEFINE_IDA(iommu_group_ida); diff --git a/include/linux/iommu.h b/include/linux/iommu.h index e8c9a7da1060..e7d70548e597 100644 --- a/include/linux/iommu.h +++ b/include/linux/iommu.h @@ -444,17 +444,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 Thu May 11 14:30:22 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yi Liu X-Patchwork-Id: 92662 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:b0ea:0:b0:3b6:4342:cba0 with SMTP id b10csp4429285vqo; Thu, 11 May 2023 07:44:31 -0700 (PDT) X-Google-Smtp-Source: ACHHUZ4NMLx0NQDaL4tDHXrCmLYmC+/0yWIV4OHW+VMInqLCFu74UkpjLIhoEjWAXNfHQ0NtfHxJ X-Received: by 2002:a05:6a21:789c:b0:100:607:b986 with SMTP id bf28-20020a056a21789c00b001000607b986mr19898344pzc.56.1683816270897; Thu, 11 May 2023 07:44:30 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1683816270; cv=none; d=google.com; s=arc-20160816; b=PPOuooopOuuEdeUrp9jRshk8AahBFm805x12HWDq2Vl0UBTx5w+X62pqx1ZDoXUdQD VDcQJRlGEBbWUTRzW0doyVdP/0TzKjPGWW2NNEk09NYiceXuoUn5X5nSRLSydIKNzvYa TNeWi37KBiYdpLWmXoZ/DyAxt1cdoBAk1Xyhl6JL83ke4MJacATtOkXByi53AXouBkno YDfUDPJTBHJ9pqK5iBM6ns2BSC9JWBmTyvhf643/EeP8DmRdu8DeZGj2WyF7izVxULGf N7wmUy2nOzAetqwPnuVOUgKwqZPtrbbQGkuW2uuqK005DcTP0wYPKVnoZY7bXyqJws45 di6w== 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=8wUyUguSznca4W4L+1Ue781UC7aKJqVn4P3/+V3vb0M=; b=QBOIGXghpzRXCEBxuzGWkrVbW5PeK6AOvawgccsAkSAbG3pOc+t/9zfsqh43DktOmu +UI8lU9iARX+HH9A3z76h5log6PiL54/EjPjsf9SsQv0fwuk8lZrqz0TKpaYZtsaXr2G 4XZ05Znh5vC5mr6sFJlMuFDuprOWSphPa8VzKfi8n4anv59C92Tu0QPAanRpwTjv45PO UuNcbgmnE0eA6Z2cbz6NrcXVhGB8vVVnl0xmiOncI/1j/ip/txqJ0B5lwDQ0G4yV4ReG B6LtRvUgdzbed+ZYS33H8dIu2BxhKNV9vh0OAys1yhwJtYOuonuBfqP88rftLn96KSGJ Sr3Q== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@intel.com header.s=Intel header.b=cLJQPurY; 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 bs126-20020a632884000000b0052023579876si6738527pgb.710.2023.05.11.07.44.18; Thu, 11 May 2023 07:44:30 -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=cLJQPurY; 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 S238579AbjEKOcU (ORCPT + 99 others); Thu, 11 May 2023 10:32:20 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:47492 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S238556AbjEKObZ (ORCPT ); Thu, 11 May 2023 10:31:25 -0400 Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0F87610E43; Thu, 11 May 2023 07:30:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1683815452; x=1715351452; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=nrDK8GkK0LqwlZMb1ilRfBE7tsHA7HCzaP978cfWRvc=; b=cLJQPurYUAVIv5cnSG9Pu51wqeg6/KQZQdmu8Ba+ekKDP5JC3iIiEJw6 CKFQ/ntTTVZrjkOZEDBHETRUZjeso56eCn0Zm0RK1qTk669nhoscpgz6K 3epAvG0J+RChqsSa+ZmWVoBbpoIzi7871U4t9IEfaUPgSD8vq35j1EioX fTs86MYPhUczPjaTJgqKXB/iBX8gysLnX8cs66qOz86ozKcvOTaqX/f92 KADb8s3Ew8PiEu1t96cuuS0UXWtQRcLRyaDZkRMNXHODo08sMrxZLOL16 SGApK93O0QgC01k6o6C4fuC4kDWg8eGhQQaIJ81IRzcHUPF/LUk97FnRd g==; X-IronPort-AV: E=McAfee;i="6600,9927,10707"; a="378639871" X-IronPort-AV: E=Sophos;i="5.99,266,1677571200"; d="scan'208";a="378639871" Received: from orsmga005.jf.intel.com ([10.7.209.41]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 11 May 2023 07:30:30 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6600,9927,10707"; a="874004429" X-IronPort-AV: E=Sophos;i="5.99,266,1677571200"; d="scan'208";a="874004429" Received: from 984fee00a4c6.jf.intel.com ([10.165.58.231]) by orsmga005.jf.intel.com with ESMTP; 11 May 2023 07:30:29 -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 v3 2/4] iommu: Add new iommu op to get iommu hardware information Date: Thu, 11 May 2023 07:30:22 -0700 Message-Id: <20230511143024.19542-3-yi.l.liu@intel.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230511143024.19542-1-yi.l.liu@intel.com> References: <20230511143024.19542-1-yi.l.liu@intel.com> MIME-Version: 1.0 X-Spam-Status: No, score=-4.4 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_MED, RCVD_IN_MSPIKE_H3,RCVD_IN_MSPIKE_WL,SPF_HELO_NONE,SPF_NONE, T_SCC_BODY_TEXT_LINE 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: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1765609330354542259?= X-GMAIL-MSGID: =?utf-8?q?1765609330354542259?= 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. The iommu_hw_info_type is stored in struct iommu_ops. For the driver doesn't report hardware information, just use IOMMU_HW_INFO_TYPE_NONE. Signed-off-by: Lu Baolu Co-developed-by: Nicolin Chen Signed-off-by: Nicolin Chen Signed-off-by: Yi Liu --- include/linux/iommu.h | 16 ++++++++++++++++ include/uapi/linux/iommufd.h | 7 +++++++ 2 files changed, 23 insertions(+) diff --git a/include/linux/iommu.h b/include/linux/iommu.h index e7d70548e597..a748d60206e7 100644 --- a/include/linux/iommu.h +++ b/include/linux/iommu.h @@ -14,6 +14,7 @@ #include #include #include +#include #define IOMMU_READ (1 << 0) #define IOMMU_WRITE (1 << 1) @@ -222,6 +223,11 @@ 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 @hw_info_type. 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 @@ -246,11 +252,20 @@ struct iommu_iotlb_gather { * @remove_dev_pasid: Remove any translation configurations of a specific * pasid, so that any DMA transactions with this pasid * will be blocked by the hardware. + * @hw_info_type: One of enum iommu_hw_info_type defined in + * include/uapi/linux/iommufd.h. It is used to tag the type + * of data returned by .hw_info callback. The drivers that + * support .hw_info callback should define a unique type + * in include/uapi/linux/iommufd.h. For the drivers that do + * not implement .hw_info callback, this field is + * IOMMU_HW_INFO_TYPE_NONE which is 0. Hence, such drivers + * do not need to care this field. * @pgsize_bitmap: bitmap of all possible supported page sizes * @owner: Driver module providing these ops */ struct iommu_ops { bool (*capable)(struct device *dev, enum iommu_cap); + void *(*hw_info)(struct device *dev, u32 *length); /* Domain allocation and freeing by the iommu driver */ struct iommu_domain *(*domain_alloc)(unsigned iommu_domain_type); @@ -279,6 +294,7 @@ struct iommu_ops { void (*remove_dev_pasid)(struct device *dev, ioasid_t pasid); const struct iommu_domain_ops *default_domain_ops; + enum iommu_hw_info_type hw_info_type; unsigned long pgsize_bitmap; struct module *owner; }; diff --git a/include/uapi/linux/iommufd.h b/include/uapi/linux/iommufd.h index 8245c01adca6..99bf0715f545 100644 --- a/include/uapi/linux/iommufd.h +++ b/include/uapi/linux/iommufd.h @@ -370,4 +370,11 @@ 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 + */ +enum iommu_hw_info_type { + IOMMU_HW_INFO_TYPE_NONE, +}; #endif From patchwork Thu May 11 14:30:23 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yi Liu X-Patchwork-Id: 92665 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:b0ea:0:b0:3b6:4342:cba0 with SMTP id b10csp4429742vqo; Thu, 11 May 2023 07:45:07 -0700 (PDT) X-Google-Smtp-Source: ACHHUZ4/Qwyel9qdJ0RLR+tlD77dLUFkA0C8MSIsBlOt8gqIFBEsMxS87wH9Df3QN5wpshHWKFKp X-Received: by 2002:a17:90a:1d42:b0:24d:fee5:6e3e with SMTP id u2-20020a17090a1d4200b0024dfee56e3emr20304683pju.25.1683816307492; Thu, 11 May 2023 07:45:07 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1683816307; cv=none; d=google.com; s=arc-20160816; b=e/pwoMz62mMC4/CIwDx4YO49wq90n/lDSaFIEI6/Dihj1S2nLr/dtRfbvhn5j3iL1N R9ZSPpCP3YV6fa0ENPc62/29teIHJsbkwig9Wq4ttaP8no6xi8XmRJXlNCUL5HVd2Lmk /IcSFHYSYkSlPiFw8cKGhQIeCJkExvrBeQQA5Ab5nnl7wfjxgi2tcAjB+r/PT9mSw8BG oKmrN8D7u30sanbNtsMoDpkgd/5keJF1CXDWHVeSFPiO5BhaRrY/B4Upr4uQWOA+uelm 5Mx1SP32HNIQ5uFc8TmcIZ8LiVzALwqFup01ZML+gaAHarY1SqcZSHNrnDmEVx19WCDn cfAw== 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=8jMPcNikXPCrcL/huvfpvueizWFe2uEgdtq2AVmftUk=; b=ignbtOnOpdW6DIXVDSV6bj99h7z0hg8GrQkniAOagBirhfL+eLwKWXjna2u1INYvNU kO3WdqUE9U9KPdCPJLDDNmYdCYefsGElelVADpfhZ38lXNN6sz1EcuZTgLFL6pj7THKw M2/6l3scdb8m+WFLG1BEQfjJSIIjq5fdDBkwm0MioRlELhI4hBCZd2RfxSmbN63fPZC9 SzDNZ51Jj2Q9GRc8V+rdrjWD1UtcSUUtiy2+6+JSM1Hsz9GneFTx0WJdgGmk5IZpHUEA QsRT/jN1s4lEojMCh7RAB93EjpOzaskLsVO/0argGOzgS8m/qW6c6f/W+R/aZQgvGDhR 58lg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@intel.com header.s=Intel header.b=LX0hhKLE; 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 w11-20020a17090a4f4b00b0024e0361745csi20020341pjl.186.2023.05.11.07.44.55; Thu, 11 May 2023 07:45:07 -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=LX0hhKLE; 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 S238149AbjEKOcZ (ORCPT + 99 others); Thu, 11 May 2023 10:32:25 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:47596 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S238490AbjEKObZ (ORCPT ); Thu, 11 May 2023 10:31:25 -0400 Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id AD9CD11577; Thu, 11 May 2023 07:30:53 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1683815453; x=1715351453; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=RL/gFeFVo8864ppAdprslg9XDSPQ0Ngd+kRHVSRHTog=; b=LX0hhKLEztkBNCyvtIyuXBZfi04gjOVGEJtef6ZqSU9cIZKgGdqO3qTh Bfob9Dv/aOGVDUomIAKty68rAffSCUlQlG0aUOvgBrnZTHp4d2ORdvn6f /exOv9E8lruDyaNW0eFV+p+SyTWBPGP1YSukwD9Oe7S8sgteUp9F1RP1r xQzy9IlzIJAjj/tWT6THiblKeyT5SgA0Y0PDyf2d6rC3cEJsQVOQjkXPm nxeubo3k6JwIjmXcrhgnU32LIBx7fsqd3+lI34QU1EbpmhuoMq6h901VE 6pdK92IOVrAmeb58sNXL3BCR86R0H9g66i4C8hEg3IEXG/5e+/Ytm1dMH w==; X-IronPort-AV: E=McAfee;i="6600,9927,10707"; a="378639890" X-IronPort-AV: E=Sophos;i="5.99,266,1677571200"; d="scan'208";a="378639890" Received: from orsmga005.jf.intel.com ([10.7.209.41]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 11 May 2023 07:30:32 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6600,9927,10707"; a="874004445" X-IronPort-AV: E=Sophos;i="5.99,266,1677571200"; d="scan'208";a="874004445" Received: from 984fee00a4c6.jf.intel.com ([10.165.58.231]) by orsmga005.jf.intel.com with ESMTP; 11 May 2023 07:30:31 -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 v3 3/4] iommufd: Add IOMMU_DEVICE_GET_HW_INFO Date: Thu, 11 May 2023 07:30:23 -0700 Message-Id: <20230511143024.19542-4-yi.l.liu@intel.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230511143024.19542-1-yi.l.liu@intel.com> References: <20230511143024.19542-1-yi.l.liu@intel.com> MIME-Version: 1.0 X-Spam-Status: No, score=-4.4 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_MED, RCVD_IN_MSPIKE_H3,RCVD_IN_MSPIKE_WL,SPF_HELO_NONE,SPF_NONE, T_SCC_BODY_TEXT_LINE 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: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1765609368333254979?= X-GMAIL-MSGID: =?utf-8?q?1765609368333254979?= 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 needs to be compatiable 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_DEVICE_GET_HW_INFO to query the IOMMU hardware information 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. Co-developed-by: Nicolin Chen Signed-off-by: Nicolin Chen Signed-off-by: Yi Liu --- drivers/iommu/iommufd/device.c | 72 +++++++++++++++++++++++++ drivers/iommu/iommufd/iommufd_private.h | 1 + drivers/iommu/iommufd/main.c | 3 ++ include/uapi/linux/iommufd.h | 37 +++++++++++++ 4 files changed, 113 insertions(+) diff --git a/drivers/iommu/iommufd/device.c b/drivers/iommu/iommufd/device.c index 051bd8e99858..bc99d092de8f 100644 --- a/drivers/iommu/iommufd/device.c +++ b/drivers/iommu/iommufd/device.c @@ -263,6 +263,78 @@ u32 iommufd_device_to_id(struct iommufd_device *idev) } EXPORT_SYMBOL_NS_GPL(iommufd_device_to_id, IOMMUFD); +static int iommufd_zero_fill_user(u64 ptr, int bytes) +{ + int index = 0; + + for (; index < bytes; index++) { + if (put_user(0, (uint8_t __user *)u64_to_user_ptr(ptr + index))) + return -EFAULT; + } + return 0; +} + +int iommufd_device_get_hw_info(struct iommufd_ucmd *ucmd) +{ + struct iommu_hw_info *cmd = ucmd->cmd; + unsigned int length = 0, data_len; + struct iommufd_device *idev; + const struct iommu_ops *ops; + void *data = NULL; + 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); + + ops = dev_iommu_ops(idev->dev); + if (!ops->hw_info) + goto done; + + /* driver has hw_info callback should have a unique hw_info_type */ + if (ops->hw_info_type == IOMMU_HW_INFO_TYPE_NONE) { + pr_warn_ratelimited("iommu driver set an invalid type\n"); + rc = -ENODEV; + goto out_err; + } + + data = ops->hw_info(idev->dev, &data_len); + if (IS_ERR(data)) { + rc = PTR_ERR(data); + goto out_err; + } + + length = min(cmd->data_len, data_len); + if (copy_to_user(u64_to_user_ptr(cmd->data_ptr), data, length)) { + rc = -EFAULT; + goto out_err; + } + + /* + * Zero the trailing bytes if the user buffer is bigger than the + * data size kernel actually has. + */ + if (length < cmd->data_len) { + rc = iommufd_zero_fill_user(cmd->data_ptr + length, + cmd->data_len - length); + if (rc) + goto out_err; + } + +done: + cmd->data_len = length; + cmd->out_data_type = ops->hw_info_type; + rc = iommufd_ucmd_respond(ucmd, sizeof(*cmd)); + +out_err: + kfree(data); + iommufd_put_object(&idev->obj); + return rc; +} + static int iommufd_group_setup_msi(struct iommufd_group *igroup, struct iommufd_hw_pagetable *hwpt) { diff --git a/drivers/iommu/iommufd/iommufd_private.h b/drivers/iommu/iommufd/iommufd_private.h index dba730129b8c..69d6bb61d387 100644 --- a/drivers/iommu/iommufd/iommufd_private.h +++ b/drivers/iommu/iommufd/iommufd_private.h @@ -308,6 +308,7 @@ iommufd_get_device(struct iommufd_ucmd *ucmd, u32 id) } void iommufd_device_destroy(struct iommufd_object *obj); +int iommufd_device_get_hw_info(struct iommufd_ucmd *ucmd); struct iommufd_access { struct iommufd_object obj; diff --git a/drivers/iommu/iommufd/main.c b/drivers/iommu/iommufd/main.c index 3932fe26522b..5c24e8971f09 100644 --- a/drivers/iommu/iommufd/main.c +++ b/drivers/iommu/iommufd/main.c @@ -269,6 +269,7 @@ static int iommufd_option(struct iommufd_ucmd *ucmd) union ucmd_buffer { struct iommu_destroy destroy; struct iommu_hwpt_alloc hwpt; + struct iommu_hw_info info; struct iommu_ioas_alloc alloc; struct iommu_ioas_allow_iovas allow_iovas; struct iommu_ioas_copy ioas_copy; @@ -302,6 +303,8 @@ static const struct iommufd_ioctl_op iommufd_ioctl_ops[] = { IOCTL_OP(IOMMU_DESTROY, iommufd_destroy, struct iommu_destroy, id), IOCTL_OP(IOMMU_HWPT_ALLOC, iommufd_hwpt_alloc, struct iommu_hwpt_alloc, __reserved), + IOCTL_OP(IOMMU_DEVICE_GET_HW_INFO, iommufd_device_get_hw_info, + struct iommu_hw_info, __reserved), IOCTL_OP(IOMMU_IOAS_ALLOC, iommufd_ioas_alloc_ioctl, struct iommu_ioas_alloc, out_ioas_id), IOCTL_OP(IOMMU_IOAS_ALLOW_IOVAS, iommufd_ioas_allow_iovas, diff --git a/include/uapi/linux/iommufd.h b/include/uapi/linux/iommufd.h index 99bf0715f545..e9d42838dcbd 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_DEVICE_GET_HW_INFO, }; /** @@ -377,4 +378,40 @@ struct iommu_hwpt_alloc { enum iommu_hw_info_type { IOMMU_HW_INFO_TYPE_NONE, }; + +/** + * struct iommu_hw_info - ioctl(IOMMU_DEVICE_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 by + * enum iommu_hw_info_type. + * @__reserved: Must be 0 + * + * Query the hardware iommu information for given device which has been + * bound to iommufd. @data_len is the size of the buffer which captures + * iommu type specific data and the data will be filled. Trailing bytes + * are zeroed if the user buffer is larger than the data kernel has. + * + * The type specific data would be used to sync capability between the + * virtual IOMMU and the hardware IOMMU. e.g. nested translation requires + * to check the hardware IOMMU capability so guest stage-1 page table + * uses a format compatible to the hardware IOMMU. + * + * 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_DEVICE_GET_HW_INFO _IO(IOMMUFD_TYPE, IOMMUFD_CMD_DEVICE_GET_HW_INFO) #endif From patchwork Thu May 11 14:30:24 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yi Liu X-Patchwork-Id: 92660 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:b0ea:0:b0:3b6:4342:cba0 with SMTP id b10csp4428716vqo; Thu, 11 May 2023 07:43:41 -0700 (PDT) X-Google-Smtp-Source: ACHHUZ6EMOsl2e3OUlqtBYbfqQt1TPkEpxuBpUGgBeXcAuZaPnt5WGpA8Rat7a2V4IQLWLVnaJU+ X-Received: by 2002:a17:90a:608f:b0:250:2384:120d with SMTP id z15-20020a17090a608f00b002502384120dmr20360542pji.19.1683816221335; Thu, 11 May 2023 07:43:41 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1683816221; cv=none; d=google.com; s=arc-20160816; b=NoWRZX4G85UPKu3msbSgMxnAgTlAsL6KFJOjTlV2EAq0bEmpHQziMEhYYdsdYryqVd tjb7PeAUs3kPANT/yhwlCQigE/MefgGEIbIGmmg7GWk8HewH6BkfHkOE5czklkAN6gzh PFPPzqLUZfy3jc+4Ccwd8lsRX54gNI+JCPRC4Jk53LiNsIez6wkKIWO8v3joR9DnDT31 U9i5xF0l3UZ44OGAexl+yBDv4yap3RwCY9ijVhDGe8CF0E/OaVqPYBugFtsOXytcPuxt U5iSF43gIwEO2omMZz+6xwdVwNSa49+EIxBcHAKifjhUiXhLwfk7fJGBITUReMYw9EGA faTA== 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=TFA8870DtQSSU3TuYZHeR21ayFdCN7oOvOhJnaOaBVk=; b=O2CdcllCXDBdF1W25F+hXtD1vK+fYRC1lTmsbowtrQJ8JKwgGSS8zNGfYB9SetU3g+ PNamd37rSiNuCfKKMDuldbKw4PrE/PdkxPqMGDC6xf3QDIXo9Xs7xpKwIopmrHN0upFV tmksy0A8pHglgW/K1GE4PnNYl84ugqJpPygIkapxoIYGlOcvTD1sL/zvncmhBaw2dNc7 /IAPvheY5RWNyoduSW2eLoMbKALswnkAkLq5JhFlLQ6I5xphX8eZ+tvFLcUfHz61RHfJ Xn1JKgO+CGqR1jJVlMmS2Fci37GN4pTd8ici/lwEHzAf2O3AAeOggPb+xPeWyWCBUlfx l9sQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@intel.com header.s=Intel header.b=Zdkcm6cL; 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 gp13-20020a17090adf0d00b0024df68db37bsi26133196pjb.158.2023.05.11.07.43.28; Thu, 11 May 2023 07:43:41 -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=Zdkcm6cL; 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 S238565AbjEKOce (ORCPT + 99 others); Thu, 11 May 2023 10:32:34 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:52840 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S238340AbjEKObo (ORCPT ); Thu, 11 May 2023 10:31:44 -0400 Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B7ABA10E70; Thu, 11 May 2023 07:30:59 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1683815459; x=1715351459; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=IlKPNhYF4zUphxpvzme0xicSOsh8D7vSbG1nRYC5sXE=; b=Zdkcm6cLPAoOgoJP2hCKfw4QGzUKPfXpv41Y5cZl/1xSjrHpJKylMH/n nBxc8lqZ+/2fgS99FEv/vNlsegzAjOS9B6iKBOuRF9AQAoe3k//ZDOs6y HEDoD2+VzSqaTWlPZ7CfOgE9E7TUvD/uAMO0ZtZUIWpFjQy/kCI1xhO3v W3H/H/zbFw2SHPWEl38If6tu38nUG94tHHw2op5BY0xv6uKcCghcLkldc 9UgqsExXKVTiQBjPrkpY0n4bip/EF1R6FHliJ5FaHC5g958GgKXFr+F8Y JJ2sfYAPrHvv3EqDlk2Y126h9FmeFuCYE4JGCZbUcYrSLMw6jbvGWBsY5 A==; X-IronPort-AV: E=McAfee;i="6600,9927,10707"; a="378639931" X-IronPort-AV: E=Sophos;i="5.99,266,1677571200"; d="scan'208";a="378639931" Received: from orsmga005.jf.intel.com ([10.7.209.41]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 11 May 2023 07:30:36 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6600,9927,10707"; a="874004479" X-IronPort-AV: E=Sophos;i="5.99,266,1677571200"; d="scan'208";a="874004479" Received: from 984fee00a4c6.jf.intel.com ([10.165.58.231]) by orsmga005.jf.intel.com with ESMTP; 11 May 2023 07:30:32 -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 v3 4/4] iommufd/selftest: Add coverage for IOMMU_DEVICE_GET_HW_INFO ioctl Date: Thu, 11 May 2023 07:30:24 -0700 Message-Id: <20230511143024.19542-5-yi.l.liu@intel.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230511143024.19542-1-yi.l.liu@intel.com> References: <20230511143024.19542-1-yi.l.liu@intel.com> MIME-Version: 1.0 X-Spam-Status: No, score=-4.4 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_MED, RCVD_IN_MSPIKE_H3,RCVD_IN_MSPIKE_WL,SPF_HELO_NONE,SPF_NONE, T_SCC_BODY_TEXT_LINE 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: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1765609278251861937?= X-GMAIL-MSGID: =?utf-8?q?1765609278251861937?= From: Nicolin Chen Add a mock_domain_hw_info function and an iommu_test_hw_info data structure. This allows to test the IOMMU_DEVICE_GET_HW_INFO ioctl by passing the test_reg value for the mock_dev. Signed-off-by: Nicolin Chen Signed-off-by: Yi Liu --- drivers/iommu/iommufd/device.c | 1 + drivers/iommu/iommufd/iommufd_test.h | 9 +++++++ drivers/iommu/iommufd/selftest.c | 16 ++++++++++++ tools/testing/selftests/iommu/iommufd.c | 17 +++++++++++- tools/testing/selftests/iommu/iommufd_utils.h | 26 +++++++++++++++++++ 5 files changed, 68 insertions(+), 1 deletion(-) diff --git a/drivers/iommu/iommufd/device.c b/drivers/iommu/iommufd/device.c index bc99d092de8f..4541d785bfd8 100644 --- a/drivers/iommu/iommufd/device.c +++ b/drivers/iommu/iommufd/device.c @@ -8,6 +8,7 @@ #include "io_pagetable.h" #include "iommufd_private.h" +#include "iommufd_test.h" static bool allow_unsafe_interrupts; module_param(allow_unsafe_interrupts, bool, S_IRUGO | S_IWUSR); 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..af7459e211ad 100644 --- a/drivers/iommu/iommufd/selftest.c +++ b/drivers/iommu/iommufd/selftest.c @@ -128,6 +128,20 @@ static struct iommu_domain mock_blocking_domain = { .ops = &mock_blocking_ops, }; +static void *mock_domain_hw_info(struct device *dev, u32 *length) +{ + 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); + + return info; +} + static struct iommu_domain *mock_domain_alloc(unsigned int iommu_domain_type) { struct mock_iommu_domain *mock; @@ -279,6 +293,8 @@ 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_type = IOMMU_HW_INFO_TYPE_SELFTEST, + .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..fa2324741ad2 100644 --- a/tools/testing/selftests/iommu/iommufd.c +++ b/tools/testing/selftests/iommu/iommufd.c @@ -121,6 +121,7 @@ TEST_F(iommufd, cmd_length) TEST_LENGTH(iommu_ioas_unmap, IOMMU_IOAS_UNMAP); TEST_LENGTH(iommu_option, IOMMU_OPTION); TEST_LENGTH(iommu_vfio_ioas, IOMMU_VFIO_IOAS); + TEST_LENGTH(iommu_hw_info, IOMMU_DEVICE_GET_HW_INFO); #undef TEST_LENGTH } @@ -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,19 @@ TEST_F(iommufd_ioas, ioas_area_auto_destroy) } } +TEST_F(iommufd_ioas, device_get_hw_info) +{ + struct iommu_test_hw_info info; + + if (self->device_id) { + test_cmd_device_get_hw_info(self->device_id, sizeof(info), &info); + assert(info.test_reg == IOMMU_HW_INFO_SELFTEST_REGVAL); + } else { + test_err_device_get_hw_info(ENOENT, self->device_id, + sizeof(info), &info); + } +} + TEST_F(iommufd_ioas, area) { int i; diff --git a/tools/testing/selftests/iommu/iommufd_utils.h b/tools/testing/selftests/iommu/iommufd_utils.h index 70353e68e599..8dced7ef9118 100644 --- a/tools/testing/selftests/iommu/iommufd_utils.h +++ b/tools/testing/selftests/iommu/iommufd_utils.h @@ -348,3 +348,29 @@ static void teardown_iommufd(int fd, struct __test_metadata *_metadata) }) #endif + +static int _test_cmd_device_get_hw_info(int fd, __u32 device_id, + __u32 data_len, void *data) +{ + struct iommu_hw_info cmd = { + .size = sizeof(cmd), + .dev_id = device_id, + .data_len = data_len, + .data_ptr = (uint64_t)data, + }; + int ret; + + ret = ioctl(fd, IOMMU_DEVICE_GET_HW_INFO, &cmd); + if (ret) + return ret; + return 0; +} + +#define test_cmd_device_get_hw_info(device_id, data_len, data) \ + ASSERT_EQ(0, _test_cmd_device_get_hw_info(self->fd, device_id, \ + data_len, data)) + +#define test_err_device_get_hw_info(_errno, device_id, data_len, data) \ + EXPECT_ERRNO(_errno, \ + _test_cmd_device_get_hw_info(self->fd, device_id, \ + data_len, data))