From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.2 required=3.0 tests=BAYES_00,DATE_IN_PAST_06_12, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1CBEEC43217 for ; Wed, 22 Sep 2021 05:13:21 +0000 (UTC) Received: from smtp2.osuosl.org (smtp2.osuosl.org [140.211.166.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id C3EDE6105A for ; Wed, 22 Sep 2021 05:13:20 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org C3EDE6105A Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=lists.linux-foundation.org Received: from localhost (localhost [127.0.0.1]) by smtp2.osuosl.org (Postfix) with ESMTP id 83E2040245; Wed, 22 Sep 2021 05:13:20 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp2.osuosl.org ([127.0.0.1]) by localhost (smtp2.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id qr7kHtGYPbLO; Wed, 22 Sep 2021 05:13:19 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by smtp2.osuosl.org (Postfix) with ESMTPS id B748840495; Wed, 22 Sep 2021 05:13:18 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 7FDE7C0025; Wed, 22 Sep 2021 05:13:18 +0000 (UTC) Received: from smtp2.osuosl.org (smtp2.osuosl.org [IPv6:2605:bc80:3010::133]) by lists.linuxfoundation.org (Postfix) with ESMTP id 1A283C000F for ; Wed, 22 Sep 2021 05:13:17 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp2.osuosl.org (Postfix) with ESMTP id 2B44440482 for ; Wed, 22 Sep 2021 05:13:15 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp2.osuosl.org ([127.0.0.1]) by localhost (smtp2.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id IWDesFnXf9HK for ; Wed, 22 Sep 2021 05:13:14 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.8.0 Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by smtp2.osuosl.org (Postfix) with ESMTPS id E8D504047C for ; Wed, 22 Sep 2021 05:13:13 +0000 (UTC) X-IronPort-AV: E=McAfee;i="6200,9189,10114"; a="287187654" X-IronPort-AV: E=Sophos;i="5.85,312,1624345200"; d="scan'208";a="287187654" Received: from fmsmga003.fm.intel.com ([10.253.24.29]) by orsmga105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 Sep 2021 22:13:13 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.85,312,1624345200"; d="scan'208";a="550107682" Received: from otc-wp-03.jf.intel.com ([10.54.39.79]) by FMSMGA003.fm.intel.com with ESMTP; 21 Sep 2021 22:13:13 -0700 From: Jacob Pan To: iommu@lists.linux-foundation.org, LKML , Joerg Roedel , Jason Gunthorpe , "Christoph Hellwig" Subject: [RFC 4/7] dma-iommu: Add support for DMA w/ PASID in KVA Date: Tue, 21 Sep 2021 13:29:38 -0700 Message-Id: <1632256181-36071-5-git-send-email-jacob.jun.pan@linux.intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1632256181-36071-1-git-send-email-jacob.jun.pan@linux.intel.com> References: <1632256181-36071-1-git-send-email-jacob.jun.pan@linux.intel.com> MIME-Version: 1.0 Cc: "Tian, Kevin" , Tony Luck , Dave Jiang , Raj Ashok , "Kumar, Sanjay K" , mike.campin@intel.com X-BeenThere: iommu@lists.linux-foundation.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Development issues for Linux IOMMU support List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: iommu-bounces@lists.linux-foundation.org Sender: "iommu" U2hhcmluZyB2aXJ0dWFsIGFkZHJlc3NlcyBiZXR3ZWVuIERNQSBhbmQgQ1BVIGhhcyBtYW55IGFk dmFudGFnZXMuIEl0CnNpbXBsaWZpZXMgdGhlIHByb2dyYW1taW5nIG1vZGVsLCBlbmhhbmNlcyBE TUEgc2VjdXJpdHkgb3ZlciBwaHlzaWNhbAphZGRyZXNzZXMuIFRoaXMgcGF0Y2ggYWRkcyBLVkEg c3VwcG9ydCBmb3IgRE1BIElPTU1VIEFQSS4gU3RyaWN0IGFuZApmYXN0IHN1Yi1tb2RlcyBhcmUg c3VwcG9ydGVkIHRyYW5zcGFyZW50bHkgYmFzZWQgb24gdGhlIGRldmljZQp0cnVzdGZ1bG5lc3Mu CgpUaGUgc3RyaWN0IG1vZGUgaXMgaW50ZW5kZWQgZm9yIHVudHJ1c3RlZCBkZXZpY2VzLiBLVkEg bWFwcGluZyBpcwplc3RhYmxpc2hlZCBvbi1kZW1hbmQgYnkgYSBzZXBhcmF0ZSBJT01NVSBwYWdl IHRhYmxlIHJlZmVyZW5jZWQgYnkgYQpzdXBlcnZpc29yIFBBU0lELiBBbiBhdXggZG9tYWluIGlz IGFsbG9jYXRlZCBwZXIgZGV2aWNlIHRvIGNhcnJ5CnRoZcKgc3VwZXJ2aXNvciBQQVNJRC4KClRo ZSBmYXN0IG1vZGUgaXMgZm9yIHRydXN0ZWQgZGV2aWNlcyB3aGVyZSBLVkEgbWFwcGluZyBpcyBz aGFyZWQgd2l0aAp0aGUgQ1BVIHZpYSBrZXJuZWwgcGFnZSB0YWJsZS4gVmVuZG9yIElPTU1VIGRy aXZlciBjYW4gY2hvb3NlIHRvIHVzZSBhCmdsb2JhbCBLVkEgZG9tYWluIGZvciBhbGwgZGV2aWNl cyBpbiBmYXN0wqBLVkEgbW9kZS4KClRoZSBmb2xsb3ctdXAgcGF0Y2hlcyB3aWxsIGludHJvZHVj ZSBpb21tdV9tYXBfa3ZhKCkgQVBJIHdoZXJlIEtWQQpkb21haW5zIHdpbGwgYmUgdXNlZC5UaGUg cGVyZm9ybWFuY2UgYWR2YW50YWdlIG9mIHRoZSBmYXN0IG1vZGUgcmVzdHMKdXBvbiB0aGUgZmFj dCB0aGF0IHRoZXJlIGlzIG5vIG5lZWQgdG8gYnVpbGQvdGVhcmRvd24gYSBzZXBhcmF0ZSBJT01N VQpwYWdlIHRhYmxlIGZvciBlYWNoIERNQSBidWZmZXIuCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgClRob3VnaCBtdWx0aXBsZSBQQVNJRHMgYW5kIGRv bWFpbnMgcGVyIGRldmljZSBjYW4gYmUgc3VwcG9ydGVkIHRoZSDCoCDCoApsYWNrIG9mIGNvbXBl bGxpbmcgdXNhZ2VzIGxlYWRzIHRvIGEgc2luZ2xlIFBBU0lEIG9wdGlvbiBmb3Igbm93LsKgIMKg IMKgIMKgCgpTaWduZWQtb2ZmLWJ5OiBKYWNvYiBQYW4gPGphY29iLmp1bi5wYW5AbGludXguaW50 ZWwuY29tPgotLS0KIGRyaXZlcnMvaW9tbXUvZG1hLWlvbW11LmMgfCA3NSArKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrLS0tLS0KIGRyaXZlcnMvaW9tbXUvaW9tbXUuYyAgICAgfCAg NiArKysrCiBpbmNsdWRlL2xpbnV4L2RtYS1pb21tdS5oIHwgIDYgKystLQogaW5jbHVkZS9saW51 eC9pb21tdS5oICAgICB8ICA2ICsrKysKIDQgZmlsZXMgY2hhbmdlZCwgODMgaW5zZXJ0aW9ucygr KSwgMTAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pb21tdS9kbWEtaW9tbXUu YyBiL2RyaXZlcnMvaW9tbXUvZG1hLWlvbW11LmMKaW5kZXggNDkwNzMxNjU5ZGVmLi41YjI1ZGJj ZWY4ZWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW9tbXUvZG1hLWlvbW11LmMKKysrIGIvZHJpdmVy cy9pb21tdS9kbWEtaW9tbXUuYwpAQCAtMTc0LDkgKzE3NCwxNSBAQCB2b2lkIGlvbW11X3B1dF9k bWFfY29va2llKHN0cnVjdCBpb21tdV9kb21haW4gKmRvbWFpbikKIH0KIEVYUE9SVF9TWU1CT0wo aW9tbXVfcHV0X2RtYV9jb29raWUpOwogCitzdGF0aWMgYm9vbCBkZXZfaXNfdW50cnVzdGVkKHN0 cnVjdCBkZXZpY2UgKmRldikKK3sKKwlyZXR1cm4gZGV2X2lzX3BjaShkZXYpICYmIHRvX3BjaV9k ZXYoZGV2KS0+dW50cnVzdGVkOworfQorCiAvKioKICAqIGlvbW11X2RtYV9wYXNpZF9lbmFibGUg LS1FbmFibGUgZGV2aWNlIERNQSByZXF1ZXN0IHdpdGggUEFTSUQKICAqIEBkZXY6CURldmljZSB0 byBiZSBlbmFibGVkCisgKiBAZG9tYWluOglJT01NVSBkb21haW4gcmV0dXJuZWQgZm9yIEtWQSBt b2RlIG1hcHBpbmcKICAqIEBtb2RlOglETUEgYWRkcmVzc2luZyBtb2RlCiAgKgogICogVGhlIGZv bGxvd2luZyBtdXR1YWxseSBleGNsdXNpdmUgRE1BIGFkZHJlc3NpbmcgbW9kZXMgYXJlIHN1cHBv cnRlZDoKQEAgLTE4OSwxMCArMTk1LDI1IEBAIEVYUE9SVF9TWU1CT0woaW9tbXVfcHV0X2RtYV9j b29raWUpOwogICogICAgIHRhYmxlcy4gUENJIHJlcXVlc3RlciBJRCAoUklEKSBhbmQgUklEK1BB U0lEIHdpbGwgYmUgcG9pbnRlZCB0byB0aGUgc2FtZQogICogICAgIFBHRC4gaS5lLiB0aGUgZGVm YXVsdCBETUEgZG9tYWluIHdpbGwgYmUgdXNlZCBieSBib3RoIFJJRCBhbmQgUklEK1BBU0lELgog ICoKKyAqICAzLiBLVkEgbW9kZS4gRE1BIGFkZHJlc3MgPT0gQ1BVIHZpcnR1YWwgYWRkcmVzcy4g VGhlcmUgYXJlIHR3byBzdWItbW9kZXM6CisgKiAgICAgc3RyaWN0IG1vZGUgYW5kIGZhc3QgbW9k ZS4KKyAqICAgICBUaGUgc3RyaWN0IG1vZGUgaXMgaW50ZW5kZWQgZm9yIHRoZSB1bnRydXN0ZWQg ZGV2aWNlcywgd2hlcmUgRE1BIGFkZHJlc3MKKyAqICAgICBpcyBpZGVudGljYWwgdG8gS1ZBIGJ1 dCByZXN0cmljdGVkIHBlciBkZXZpY2Ugb24gdGhlIHN1cGVydmlzb3IgUEFTSUQuCisgKiAgICAg VGhlIGZhc3QgbW9kZSBpcyBmb3IgdHJ1c3RlZCBkZXZpY2VzIHdoZXJlIGl0cyBETUEgaXMgb25s eSByZXN0cmljdGVkCisgKiAgICAgYnkgdGhlIGtlcm5lbCBwYWdlIHRhYmxlcyB1c2VkIGJ5IHRo ZSBDUFUuIGlvbW11X2RvbWFpbnMgd2l0aCBVTk1BTkFHRUQKKyAqICAgICBhbmQgS1ZBIHR5cGVz IGFyZSByZXR1cm5lZCByZXNwZWN0aXZlbHkuIFRoZXkgYXJlIHVzZWQgYnkgaW9tbXVfbWFwX2t2 YSgpCisgKgorICogICAgIFRoZSBwZXJmb3JtYW5jZSBhZHZhbnRhZ2Ugb2YgdGhlIGZhc3QgbW9k ZSAoYmFzZWQgb24gd2hldGhlciB0aGUgZGV2aWNlCisgKiAgICAgaXMgdHJ1c3RlZCBvciB1c2Vy IGFsbG93ZWQpLCByZWxpZXMgb24gdGhlIGZhY3QgdGhhdCB0aGVyZSBpcyBubyBuZWVkCisgKiAg ICAgdG8gYnVpbGQvdGVhcmRvd24gYSBzZXBhcmF0ZSBJT01NVSBwYWdlIHRhYmxlcyBmb3IgS1ZB IG1hcHBpbmcuCisgKgorICogICAgIFRob3VnaCBtdWx0aXBsZSBQQVNJRHMgYW5kIGRvbWFpbnMg cGVyIGRldmljZSBjYW4gYmUgc3VwcG9ydGVkIGJ1dCB0aGUKKyAqICAgICBsYWNrIG9mIGNvbXBl bGxpbmcgdXNhZ2VzIGxlYWQgdG8gYSBzaW5nbGUgUEFTSUQgb3B0aW9uIGZvciBub3cuCisgKgog ICogQHJldHVybiB0aGUgc3VwZXJ2aXNvciBQQVNJRCB0byBiZSB1c2VkIGZvciBETUEuIE9yIElO VkFMSURfSU9BU0lEIHVwb24KICAqICAgICBmYWlsdXJlLgogICovCi1pbnQgaW9tbXVfZG1hX3Bh c2lkX2VuYWJsZShzdHJ1Y3QgZGV2aWNlICpkZXYsCitpbnQgaW9tbXVfZG1hX3Bhc2lkX2VuYWJs ZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBpb21tdV9kb21haW4gKipkb21haW4sCiAJCQkg ICBlbnVtIGlvbW11X2RtYV9wYXNpZF9tb2RlIG1vZGUpCiB7CiAJaW50IHBhc2lkID0gSU5WQUxJ RF9JT0FTSUQ7CkBAIC0yMDEsOCArMjIyLDM3IEBAIGludCBpb21tdV9kbWFfcGFzaWRfZW5hYmxl KHN0cnVjdCBkZXZpY2UgKmRldiwKIAkvKiBUT0RPOiBvbmx5IGFsbG93IGEgc2luZ2xlIG1vZGUg ZWFjaCB0aW1lLCB0cmFjayBQQVNJRCBETUEgZW5hYmxpbmcKIAkgKiBzdGF0dXMgcGVyIGRldmlj ZS4gUGVyaGFwcyBhZGQgYSBmbGFnIGluIHN0cnVjdCBkZXZpY2UuZGV2X2lvbW11LgogCSAqLwor CWlmIChtb2RlID09IElPTU1VX0RNQV9QQVNJRF9LVkEpIHsKKwkJaWYgKGlvbW11X2Rldl9lbmFi bGVfZmVhdHVyZShkZXYsIElPTU1VX0RFVl9GRUFUX0FVWCkpIHsKKwkJCWRldl9lcnIoZGV2LCAi Tm8gYXV4IGRvbWFpbiBzdXBwb3J0Iik7CisJCQlnb3RvIGV4aXQ7CisJCX07CisJCS8qCisJCSAq IFVudHJ1c3RlZCBkZXZpY2VzIGdldHMgYW4gdW5tYW5hZ2VkIGRvbWFpbiB3aGljaCB3aWxsIGJl CisJCSAqIHJldHVybmVkIHRvIHRoZSBjYWxsZXIgZm9yIHN0cmljdCBJT01NVSBBUEkgS1ZBIG1h cHBpbmcuCisJCSAqIFRydXN0ZWQgZGV2aWNlIGdldHMgYSBzcGVjaWFsIEtWQSBkb21haW4gd2l0 aCBpbml0X21tLnBnZAorCQkgKiBhc3NpZ25lZC4KKwkJICovCisJCWlmIChkZXZfaXNfdW50cnVz dGVkKGRldikpCisJCQlkb20gPSBpb21tdV9kb21haW5fYWxsb2MoZGV2LT5idXMpOworCQllbHNl CisJCQlkb20gPSBpb21tdV9kb21haW5fYWxsb2Nfa3ZhKGRldi0+YnVzKTsKKwkJaWYgKCFkb20p IHsKKwkJCWRldl9lcnIoZGV2LCAiTm8gS1ZBIGlvbW11IGRvbWFpbiBhbGxvY2F0ZWQiKTsKKwkJ CWdvdG8gZXhpdF9kaXNhYmxlX2F1eDsKKwkJfQorCQlpZiAoaW9tbXVfYXV4X2F0dGFjaF9kZXZp Y2UoZG9tLCBkZXYpKSB7CisJCQlkZXZfZXJyKGRldiwgIkZhaWxlZCB0byBhdHRhY2ggS1ZBIGlv bW11IGRvbWFpbiIpOworCQkJZ290byBleGl0X2ZyZWVfZG9tYWluOworCQl9OworCQlwYXNpZCA9 IGlvbW11X2F1eF9nZXRfcGFzaWQoZG9tLCBkZXYpOworCisJCWRldl9kYmcoZGV2LCAiS1ZBIG1v ZGUgcGFzaWQgJWQiLCBwYXNpZCk7CisJCSpkb21haW4gPSBkb207CisJCWdvdG8gZXhpdDsKKwl9 CiAKLQkvKiBDYWxsIHZlbmRvciBkcml2ZXJzIHRvIGhhbmRsZSBJT1ZBLCBieXBhc3MgbW9kZSAq LworCS8qIENhbGwgdmVuZG9yIGRyaXZlcnMgdG8gaGFuZGxlIElPVkEsIGJ5cGFzcywgYW5kIEtW QSB0cnVzdGVkIG1vZGUgKi8KIAlkb20gPSBpb21tdV9nZXRfZG9tYWluX2Zvcl9kZXYoZGV2KTsK IAlpZiAoZG9tLT5vcHMtPmVuYWJsZV9wYXNpZF9kbWEoZGV2LCBJT0FTSURfRE1BX1BBU0lELCBt b2RlKSkgewogCQlkZXZfZGJnKGRldiwgIkZhaWxlZCB0byBlbmFibGUgRE1BIHBhc2lkIGluIG1v ZGUgJWQiLCBtb2RlKTsKQEAgLTIxMiwxNSArMjYyLDI5IEBAIGludCBpb21tdV9kbWFfcGFzaWRf ZW5hYmxlKHN0cnVjdCBkZXZpY2UgKmRldiwKIAogCWRldl9kYmcoZGV2LCAiRW5hYmxlIERNQSBw YXNpZCAlZCBpbiBtb2RlICVkIiwgcGFzaWQsIG1vZGUpOwogCWdvdG8gZXhpdDsKKworZXhpdF9m cmVlX2RvbWFpbjoKKwlpb21tdV9kb21haW5fZnJlZShkb20pOworZXhpdF9kaXNhYmxlX2F1eDoK Kwlpb21tdV9kZXZfZGlzYWJsZV9mZWF0dXJlKGRldiwgSU9NTVVfREVWX0ZFQVRfQVVYKTsKIGV4 aXQ6CiAJcmV0dXJuIHBhc2lkOwogfQogRVhQT1JUX1NZTUJPTChpb21tdV9kbWFfcGFzaWRfZW5h YmxlKTsKIAotaW50IGlvbW11X2RtYV9wYXNpZF9kaXNhYmxlKHN0cnVjdCBkZXZpY2UgKmRldikK K2ludCBpb21tdV9kbWFfcGFzaWRfZGlzYWJsZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBp b21tdV9kb21haW4gKmRvbWFpbikKIHsKIAlzdHJ1Y3QgaW9tbXVfZG9tYWluICpkb207CiAKKwlp ZiAoZG9tYWluKSB7CisJCS8qIHMtcGFzaWQgd2lsbCBiZSBjbGVhcmVkIGR1cmluZyBkZXRhY2gg Ki8KKwkJaW9tbXVfYXV4X2RldGFjaF9kZXZpY2UoZG9tYWluLCBkZXYpOworCQlpb21tdV9kb21h aW5fZnJlZShkb21haW4pOworCQlpb21tdV9kZXZfZGlzYWJsZV9mZWF0dXJlKGRldiwgSU9NTVVf REVWX0ZFQVRfQVVYKTsKKwkJZGV2X2RiZyhkZXYsICJLVkEgYXV4IGRvbWFpbiBmcmVlZCIpOwor CQlyZXR1cm4gMDsKKwl9CisKIAkvKiBDYWxsIHZlbmRvciBpb21tdSBvcHMgdG8gY2xlYW4gdXAg c3VwZXJ2aXNvciBQQVNJRCBjb250ZXh0ICovCiAJZG9tID0gaW9tbXVfZ2V0X2RvbWFpbl9mb3Jf ZGV2KGRldik7CiAKQEAgLTM2NCwxMSArNDI4LDYgQEAgc3RhdGljIHZvaWQgaW9tbXVfZG1hX2Zs dXNoX2lvdGxiX2FsbChzdHJ1Y3QgaW92YV9kb21haW4gKmlvdmFkKQogCWRvbWFpbi0+b3BzLT5m bHVzaF9pb3RsYl9hbGwoZG9tYWluKTsKIH0KIAotc3RhdGljIGJvb2wgZGV2X2lzX3VudHJ1c3Rl ZChzdHJ1Y3QgZGV2aWNlICpkZXYpCi17Ci0JcmV0dXJuIGRldl9pc19wY2koZGV2KSAmJiB0b19w Y2lfZGV2KGRldiktPnVudHJ1c3RlZDsKLX0KLQogLyoqCiAgKiBpb21tdV9kbWFfaW5pdF9kb21h aW4gLSBJbml0aWFsaXNlIGEgRE1BIG1hcHBpbmcgZG9tYWluCiAgKiBAZG9tYWluOiBJT01NVSBk b21haW4gcHJldmlvdXNseSBwcmVwYXJlZCBieSBpb21tdV9nZXRfZG1hX2Nvb2tpZSgpCmRpZmYg LS1naXQgYS9kcml2ZXJzL2lvbW11L2lvbW11LmMgYi9kcml2ZXJzL2lvbW11L2lvbW11LmMKaW5k ZXggODA4YWI3MGQ1ZGY1Li5hY2ZkY2Q3ZWJkNmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW9tbXUv aW9tbXUuYworKysgYi9kcml2ZXJzL2lvbW11L2lvbW11LmMKQEAgLTE5NTAsNiArMTk1MCwxMiBA QCBzdHJ1Y3QgaW9tbXVfZG9tYWluICppb21tdV9kb21haW5fYWxsb2Moc3RydWN0IGJ1c190eXBl ICpidXMpCiB9CiBFWFBPUlRfU1lNQk9MX0dQTChpb21tdV9kb21haW5fYWxsb2MpOwogCitzdHJ1 Y3QgaW9tbXVfZG9tYWluICppb21tdV9kb21haW5fYWxsb2Nfa3ZhKHN0cnVjdCBidXNfdHlwZSAq YnVzKQoreworCXJldHVybiBfX2lvbW11X2RvbWFpbl9hbGxvYyhidXMsIElPTU1VX0RPTUFJTl9L VkEpOworfQorRVhQT1JUX1NZTUJPTF9HUEwoaW9tbXVfZG9tYWluX2FsbG9jX2t2YSk7CisKIHZv aWQgaW9tbXVfZG9tYWluX2ZyZWUoc3RydWN0IGlvbW11X2RvbWFpbiAqZG9tYWluKQogewogCWRv bWFpbi0+b3BzLT5kb21haW5fZnJlZShkb21haW4pOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51 eC9kbWEtaW9tbXUuaCBiL2luY2x1ZGUvbGludXgvZG1hLWlvbW11LmgKaW5kZXggM2MxNTU1ZTBm ZDUxLi5lODU4ZDQyYTY2NjkgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvZG1hLWlvbW11LmgK KysrIGIvaW5jbHVkZS9saW51eC9kbWEtaW9tbXUuaApAQCAtMjIsMTMgKzIyLDE1IEBAIGVudW0g aW9tbXVfZG1hX3Bhc2lkX21vZGUgewogCUlPTU1VX0RNQV9QQVNJRF9CWVBBU1MgPSAxLAogCS8q IENvbXBhdGlibGUgd2l0aCBETUEgQVBJcywgc2FtZSBtYXBwaW5nIGFzIERNQSB3L28gUEFTSUQg Ki8KIAlJT01NVV9ETUFfUEFTSURfSU9WQSwKKwkvKiBVc2Uga2VybmVsIGRpcmVjdCBtYXBwaW5n IG1lbW9yeSwgcGFnZV9vZmZzZXRfYmFzZSAqLworCUlPTU1VX0RNQV9QQVNJRF9LVkEsCiB9Owog LyogRm9yIGRldmljZXMgdGhhdCBjYW4gZG8gRE1BIHJlcXVlc3Qgd2l0aCBQQVNJRCwgc2V0dXAg dGhlIHN5c3RlbQogICogYmFzZWQgb24gdGhlIGFkZHJlc3MgbW9kZSBzZWxlY3RlZC4KICAqLwot aW50IGlvbW11X2RtYV9wYXNpZF9lbmFibGUoc3RydWN0IGRldmljZSAqZGV2LAoraW50IGlvbW11 X2RtYV9wYXNpZF9lbmFibGUoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgaW9tbXVfZG9tYWlu ICoqZG9tYWluLAogCQkJICAgZW51bSBpb21tdV9kbWFfcGFzaWRfbW9kZSBtb2RlKTsKLWludCBp b21tdV9kbWFfcGFzaWRfZGlzYWJsZShzdHJ1Y3QgZGV2aWNlICpkZXYpOworaW50IGlvbW11X2Rt YV9wYXNpZF9kaXNhYmxlKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGlvbW11X2RvbWFpbiAq ZG9tYWluKTsKIAogLyogU2V0dXAgY2FsbCBmb3IgYXJjaCBETUEgbWFwcGluZyBjb2RlICovCiB2 b2lkIGlvbW11X3NldHVwX2RtYV9vcHMoc3RydWN0IGRldmljZSAqZGV2LCB1NjQgZG1hX2Jhc2Us IHU2NCBzaXplKTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvaW9tbXUuaCBiL2luY2x1ZGUv bGludXgvaW9tbXUuaAppbmRleCA2MTBjYmZkMDNlNmIuLmNkODIyNWY2YmMyMyAxMDA2NDQKLS0t IGEvaW5jbHVkZS9saW51eC9pb21tdS5oCisrKyBiL2luY2x1ZGUvbGludXgvaW9tbXUuaApAQCAt NjAsNiArNjAsNyBAQCBzdHJ1Y3QgaW9tbXVfZG9tYWluX2dlb21ldHJ5IHsKICNkZWZpbmUgX19J T01NVV9ET01BSU5fRE1BX0FQSQkoMVUgPDwgMSkgIC8qIERvbWFpbiBmb3IgdXNlIGluIERNQS1B UEkKIAkJCQkJICAgICAgaW1wbGVtZW50YXRpb24gICAgICAgICAgICAgICovCiAjZGVmaW5lIF9f SU9NTVVfRE9NQUlOX1BUCSgxVSA8PCAyKSAgLyogRG9tYWluIGlzIGlkZW50aXR5IG1hcHBlZCAg ICovCisjZGVmaW5lIF9fSU9NTVVfRE9NQUlOX0tWQQkoMVUgPDwgMykgIC8qIERvbWFpbiBzaGFy ZXMgd2l0aCBDUFUgS1ZBICovCiAKIC8qCiAgKiBUaGlzIGFyZSB0aGUgcG9zc2libGUgZG9tYWlu LXR5cGVzCkBAIC03MiwxMiArNzMsMTYgQEAgc3RydWN0IGlvbW11X2RvbWFpbl9nZW9tZXRyeSB7 CiAgKglJT01NVV9ET01BSU5fRE1BCS0gSW50ZXJuYWxseSB1c2VkIGZvciBETUEtQVBJIGltcGxl bWVudGF0aW9ucy4KICAqCQkJCSAgVGhpcyBmbGFnIGFsbG93cyBJT01NVSBkcml2ZXJzIHRvIGlt cGxlbWVudAogICoJCQkJICBjZXJ0YWluIG9wdGltaXphdGlvbnMgZm9yIHRoZXNlIGRvbWFpbnMK KyAqCUlPTU1VX0RPTUFJTl9LVkEJLSBETUEgYWRkcmVzc2VzIGFyZSBrZXJuZWwgdmlydHVhbCBh ZGRyZXNzZXMuCisgKgkJCQkgIE1hcHBpbmcgY2FuIGJlIG1hbmFnZWQgYnkgSU9NTVUgQVBJIG9y IHNoYXJlcworICoJCQkJICB0aGUgQ1BVIHBhZ2UgdGFibGUsIGkuZS4gU1ZBLgogICovCiAjZGVm aW5lIElPTU1VX0RPTUFJTl9CTE9DS0VECSgwVSkKICNkZWZpbmUgSU9NTVVfRE9NQUlOX0lERU5U SVRZCShfX0lPTU1VX0RPTUFJTl9QVCkKICNkZWZpbmUgSU9NTVVfRE9NQUlOX1VOTUFOQUdFRAko X19JT01NVV9ET01BSU5fUEFHSU5HKQogI2RlZmluZSBJT01NVV9ET01BSU5fRE1BCShfX0lPTU1V X0RPTUFJTl9QQUdJTkcgfAlcCiAJCQkJIF9fSU9NTVVfRE9NQUlOX0RNQV9BUEkpCisjZGVmaW5l IElPTU1VX0RPTUFJTl9LVkEJKF9fSU9NTVVfRE9NQUlOX0tWQSkKIAogc3RydWN0IGlvbW11X2Rv bWFpbiB7CiAJdW5zaWduZWQgdHlwZTsKQEAgLTM4OSw2ICszOTQsNyBAQCBleHRlcm4gaW50IGJ1 c19pb21tdV9wcm9iZShzdHJ1Y3QgYnVzX3R5cGUgKmJ1cyk7CiBleHRlcm4gYm9vbCBpb21tdV9w cmVzZW50KHN0cnVjdCBidXNfdHlwZSAqYnVzKTsKIGV4dGVybiBib29sIGlvbW11X2NhcGFibGUo c3RydWN0IGJ1c190eXBlICpidXMsIGVudW0gaW9tbXVfY2FwIGNhcCk7CiBleHRlcm4gc3RydWN0 IGlvbW11X2RvbWFpbiAqaW9tbXVfZG9tYWluX2FsbG9jKHN0cnVjdCBidXNfdHlwZSAqYnVzKTsK K2V4dGVybiBzdHJ1Y3QgaW9tbXVfZG9tYWluICppb21tdV9kb21haW5fYWxsb2Nfa3ZhKHN0cnVj dCBidXNfdHlwZSAqYnVzKTsKIGV4dGVybiBzdHJ1Y3QgaW9tbXVfZ3JvdXAgKmlvbW11X2dyb3Vw X2dldF9ieV9pZChpbnQgaWQpOwogZXh0ZXJuIHZvaWQgaW9tbXVfZG9tYWluX2ZyZWUoc3RydWN0 IGlvbW11X2RvbWFpbiAqZG9tYWluKTsKIGV4dGVybiBpbnQgaW9tbXVfYXR0YWNoX2RldmljZShz dHJ1Y3QgaW9tbXVfZG9tYWluICpkb21haW4sCi0tIAoyLjI1LjEKCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmlvbW11IG1haWxpbmcgbGlzdAppb21tdUBs aXN0cy5saW51eC1mb3VuZGF0aW9uLm9yZwpodHRwczovL2xpc3RzLmxpbnV4Zm91bmRhdGlvbi5v cmcvbWFpbG1hbi9saXN0aW5mby9pb21tdQ== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.2 required=3.0 tests=BAYES_00,DATE_IN_PAST_06_12, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 691E3C433F5 for ; Wed, 22 Sep 2021 05:13:22 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 4DBBA6105A for ; Wed, 22 Sep 2021 05:13:22 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232228AbhIVFOt (ORCPT ); Wed, 22 Sep 2021 01:14:49 -0400 Received: from mga12.intel.com ([192.55.52.136]:29329 "EHLO mga12.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232051AbhIVFOn (ORCPT ); Wed, 22 Sep 2021 01:14:43 -0400 X-IronPort-AV: E=McAfee;i="6200,9189,10114"; a="203012043" X-IronPort-AV: E=Sophos;i="5.85,312,1624345200"; d="scan'208";a="203012043" Received: from fmsmga003.fm.intel.com ([10.253.24.29]) by fmsmga106.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 Sep 2021 22:13:13 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.85,312,1624345200"; d="scan'208";a="550107682" Received: from otc-wp-03.jf.intel.com ([10.54.39.79]) by FMSMGA003.fm.intel.com with ESMTP; 21 Sep 2021 22:13:13 -0700 From: Jacob Pan To: iommu@lists.linux-foundation.org, LKML , Joerg Roedel , Jason Gunthorpe , "Christoph Hellwig" Cc: "Lu Baolu" , Raj Ashok , "Kumar, Sanjay K" , Dave Jiang , Tony Luck , mike.campin@intel.com, Yi Liu , "Tian, Kevin" Subject: [RFC 4/7] dma-iommu: Add support for DMA w/ PASID in KVA Date: Tue, 21 Sep 2021 13:29:38 -0700 Message-Id: <1632256181-36071-5-git-send-email-jacob.jun.pan@linux.intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1632256181-36071-1-git-send-email-jacob.jun.pan@linux.intel.com> References: <1632256181-36071-1-git-send-email-jacob.jun.pan@linux.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Sharing virtual addresses between DMA and CPU has many advantages. It simplifies the programming model, enhances DMA security over physical addresses. This patch adds KVA support for DMA IOMMU API. Strict and fast sub-modes are supported transparently based on the device trustfulness. The strict mode is intended for untrusted devices. KVA mapping is established on-demand by a separate IOMMU page table referenced by a supervisor PASID. An aux domain is allocated per device to carry the supervisor PASID. The fast mode is for trusted devices where KVA mapping is shared with the CPU via kernel page table. Vendor IOMMU driver can choose to use a global KVA domain for all devices in fast KVA mode. The follow-up patches will introduce iommu_map_kva() API where KVA domains will be used.The performance advantage of the fast mode rests upon the fact that there is no need to build/teardown a separate IOMMU page table for each DMA buffer.                                                                         Though multiple PASIDs and domains per device can be supported the     lack of compelling usages leads to a single PASID option for now.        Signed-off-by: Jacob Pan --- drivers/iommu/dma-iommu.c | 75 ++++++++++++++++++++++++++++++++++----- drivers/iommu/iommu.c | 6 ++++ include/linux/dma-iommu.h | 6 ++-- include/linux/iommu.h | 6 ++++ 4 files changed, 83 insertions(+), 10 deletions(-) diff --git a/drivers/iommu/dma-iommu.c b/drivers/iommu/dma-iommu.c index 490731659def..5b25dbcef8ee 100644 --- a/drivers/iommu/dma-iommu.c +++ b/drivers/iommu/dma-iommu.c @@ -174,9 +174,15 @@ void iommu_put_dma_cookie(struct iommu_domain *domain) } EXPORT_SYMBOL(iommu_put_dma_cookie); +static bool dev_is_untrusted(struct device *dev) +{ + return dev_is_pci(dev) && to_pci_dev(dev)->untrusted; +} + /** * iommu_dma_pasid_enable --Enable device DMA request with PASID * @dev: Device to be enabled + * @domain: IOMMU domain returned for KVA mode mapping * @mode: DMA addressing mode * * The following mutually exclusive DMA addressing modes are supported: @@ -189,10 +195,25 @@ EXPORT_SYMBOL(iommu_put_dma_cookie); * tables. PCI requester ID (RID) and RID+PASID will be pointed to the same * PGD. i.e. the default DMA domain will be used by both RID and RID+PASID. * + * 3. KVA mode. DMA address == CPU virtual address. There are two sub-modes: + * strict mode and fast mode. + * The strict mode is intended for the untrusted devices, where DMA address + * is identical to KVA but restricted per device on the supervisor PASID. + * The fast mode is for trusted devices where its DMA is only restricted + * by the kernel page tables used by the CPU. iommu_domains with UNMANAGED + * and KVA types are returned respectively. They are used by iommu_map_kva() + * + * The performance advantage of the fast mode (based on whether the device + * is trusted or user allowed), relies on the fact that there is no need + * to build/teardown a separate IOMMU page tables for KVA mapping. + * + * Though multiple PASIDs and domains per device can be supported but the + * lack of compelling usages lead to a single PASID option for now. + * * @return the supervisor PASID to be used for DMA. Or INVALID_IOASID upon * failure. */ -int iommu_dma_pasid_enable(struct device *dev, +int iommu_dma_pasid_enable(struct device *dev, struct iommu_domain **domain, enum iommu_dma_pasid_mode mode) { int pasid = INVALID_IOASID; @@ -201,8 +222,37 @@ int iommu_dma_pasid_enable(struct device *dev, /* TODO: only allow a single mode each time, track PASID DMA enabling * status per device. Perhaps add a flag in struct device.dev_iommu. */ + if (mode == IOMMU_DMA_PASID_KVA) { + if (iommu_dev_enable_feature(dev, IOMMU_DEV_FEAT_AUX)) { + dev_err(dev, "No aux domain support"); + goto exit; + }; + /* + * Untrusted devices gets an unmanaged domain which will be + * returned to the caller for strict IOMMU API KVA mapping. + * Trusted device gets a special KVA domain with init_mm.pgd + * assigned. + */ + if (dev_is_untrusted(dev)) + dom = iommu_domain_alloc(dev->bus); + else + dom = iommu_domain_alloc_kva(dev->bus); + if (!dom) { + dev_err(dev, "No KVA iommu domain allocated"); + goto exit_disable_aux; + } + if (iommu_aux_attach_device(dom, dev)) { + dev_err(dev, "Failed to attach KVA iommu domain"); + goto exit_free_domain; + }; + pasid = iommu_aux_get_pasid(dom, dev); + + dev_dbg(dev, "KVA mode pasid %d", pasid); + *domain = dom; + goto exit; + } - /* Call vendor drivers to handle IOVA, bypass mode */ + /* Call vendor drivers to handle IOVA, bypass, and KVA trusted mode */ dom = iommu_get_domain_for_dev(dev); if (dom->ops->enable_pasid_dma(dev, IOASID_DMA_PASID, mode)) { dev_dbg(dev, "Failed to enable DMA pasid in mode %d", mode); @@ -212,15 +262,29 @@ int iommu_dma_pasid_enable(struct device *dev, dev_dbg(dev, "Enable DMA pasid %d in mode %d", pasid, mode); goto exit; + +exit_free_domain: + iommu_domain_free(dom); +exit_disable_aux: + iommu_dev_disable_feature(dev, IOMMU_DEV_FEAT_AUX); exit: return pasid; } EXPORT_SYMBOL(iommu_dma_pasid_enable); -int iommu_dma_pasid_disable(struct device *dev) +int iommu_dma_pasid_disable(struct device *dev, struct iommu_domain *domain) { struct iommu_domain *dom; + if (domain) { + /* s-pasid will be cleared during detach */ + iommu_aux_detach_device(domain, dev); + iommu_domain_free(domain); + iommu_dev_disable_feature(dev, IOMMU_DEV_FEAT_AUX); + dev_dbg(dev, "KVA aux domain freed"); + return 0; + } + /* Call vendor iommu ops to clean up supervisor PASID context */ dom = iommu_get_domain_for_dev(dev); @@ -364,11 +428,6 @@ static void iommu_dma_flush_iotlb_all(struct iova_domain *iovad) domain->ops->flush_iotlb_all(domain); } -static bool dev_is_untrusted(struct device *dev) -{ - return dev_is_pci(dev) && to_pci_dev(dev)->untrusted; -} - /** * iommu_dma_init_domain - Initialise a DMA mapping domain * @domain: IOMMU domain previously prepared by iommu_get_dma_cookie() diff --git a/drivers/iommu/iommu.c b/drivers/iommu/iommu.c index 808ab70d5df5..acfdcd7ebd6a 100644 --- a/drivers/iommu/iommu.c +++ b/drivers/iommu/iommu.c @@ -1950,6 +1950,12 @@ struct iommu_domain *iommu_domain_alloc(struct bus_type *bus) } EXPORT_SYMBOL_GPL(iommu_domain_alloc); +struct iommu_domain *iommu_domain_alloc_kva(struct bus_type *bus) +{ + return __iommu_domain_alloc(bus, IOMMU_DOMAIN_KVA); +} +EXPORT_SYMBOL_GPL(iommu_domain_alloc_kva); + void iommu_domain_free(struct iommu_domain *domain) { domain->ops->domain_free(domain); diff --git a/include/linux/dma-iommu.h b/include/linux/dma-iommu.h index 3c1555e0fd51..e858d42a6669 100644 --- a/include/linux/dma-iommu.h +++ b/include/linux/dma-iommu.h @@ -22,13 +22,15 @@ enum iommu_dma_pasid_mode { IOMMU_DMA_PASID_BYPASS = 1, /* Compatible with DMA APIs, same mapping as DMA w/o PASID */ IOMMU_DMA_PASID_IOVA, + /* Use kernel direct mapping memory, page_offset_base */ + IOMMU_DMA_PASID_KVA, }; /* For devices that can do DMA request with PASID, setup the system * based on the address mode selected. */ -int iommu_dma_pasid_enable(struct device *dev, +int iommu_dma_pasid_enable(struct device *dev, struct iommu_domain **domain, enum iommu_dma_pasid_mode mode); -int iommu_dma_pasid_disable(struct device *dev); +int iommu_dma_pasid_disable(struct device *dev, struct iommu_domain *domain); /* Setup call for arch DMA mapping code */ void iommu_setup_dma_ops(struct device *dev, u64 dma_base, u64 size); diff --git a/include/linux/iommu.h b/include/linux/iommu.h index 610cbfd03e6b..cd8225f6bc23 100644 --- a/include/linux/iommu.h +++ b/include/linux/iommu.h @@ -60,6 +60,7 @@ struct iommu_domain_geometry { #define __IOMMU_DOMAIN_DMA_API (1U << 1) /* Domain for use in DMA-API implementation */ #define __IOMMU_DOMAIN_PT (1U << 2) /* Domain is identity mapped */ +#define __IOMMU_DOMAIN_KVA (1U << 3) /* Domain shares with CPU KVA */ /* * This are the possible domain-types @@ -72,12 +73,16 @@ struct iommu_domain_geometry { * IOMMU_DOMAIN_DMA - Internally used for DMA-API implementations. * This flag allows IOMMU drivers to implement * certain optimizations for these domains + * IOMMU_DOMAIN_KVA - DMA addresses are kernel virtual addresses. + * Mapping can be managed by IOMMU API or shares + * the CPU page table, i.e. SVA. */ #define IOMMU_DOMAIN_BLOCKED (0U) #define IOMMU_DOMAIN_IDENTITY (__IOMMU_DOMAIN_PT) #define IOMMU_DOMAIN_UNMANAGED (__IOMMU_DOMAIN_PAGING) #define IOMMU_DOMAIN_DMA (__IOMMU_DOMAIN_PAGING | \ __IOMMU_DOMAIN_DMA_API) +#define IOMMU_DOMAIN_KVA (__IOMMU_DOMAIN_KVA) struct iommu_domain { unsigned type; @@ -389,6 +394,7 @@ extern int bus_iommu_probe(struct bus_type *bus); extern bool iommu_present(struct bus_type *bus); extern bool iommu_capable(struct bus_type *bus, enum iommu_cap cap); extern struct iommu_domain *iommu_domain_alloc(struct bus_type *bus); +extern struct iommu_domain *iommu_domain_alloc_kva(struct bus_type *bus); extern struct iommu_group *iommu_group_get_by_id(int id); extern void iommu_domain_free(struct iommu_domain *domain); extern int iommu_attach_device(struct iommu_domain *domain, -- 2.25.1