From patchwork Wed May 10 14:03:06 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Oleksandr Tyshchenko X-Patchwork-Id: 9719915 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork.web.codeaurora.org (Postfix) with ESMTP id 77B436035D for ; Wed, 10 May 2017 14:06:14 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 6699428609 for ; Wed, 10 May 2017 14:06:14 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 5B2542860F; Wed, 10 May 2017 14:06:14 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-4.1 required=2.0 tests=BAYES_00, DKIM_ADSP_CUSTOM_MED, DKIM_SIGNED, FREEMAIL_FROM, RCVD_IN_DNSWL_MED, T_DKIM_INVALID autolearn=ham version=3.3.1 Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id 1833128609 for ; Wed, 10 May 2017 14:06:13 +0000 (UTC) Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.84_2) (envelope-from ) id 1d8SDN-00077q-5S; Wed, 10 May 2017 14:03:41 +0000 Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xenproject.org with esmtp (Exim 4.84_2) (envelope-from ) id 1d8SDM-00076U-6N for xen-devel@lists.xenproject.org; Wed, 10 May 2017 14:03:40 +0000 Received: from [85.158.139.211] by server-9.bemta-5.messagelabs.com id 3D/0A-01999-BBD13195; Wed, 10 May 2017 14:03:39 +0000 X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFlrIIsWRWlGSWpSXmKPExsXiVRvkqLtDVjj SYMVpFovvWyYzOTB6HP5whSWAMYo1My8pvyKBNeP03LOsBSsuMFbsezONpYFxfx9jFyMXh5DA VEaJaTPbwRwWgZcsEj8OvWIBcSQE+lklNq58CuRwAjlxEifObGTvYuQAssslNh4oBwkLCShJv N65mQli0iwmiWWrH7KBJNgEDCT2v3vCDmKLABXdWzWZCcRmBurtmbkMrEZYIEli2qlWsBoWAV WJDfu3gNm8As4ST7tnMELslZO4ea6TGcTmFHCR2PH6DgvEYmeJ/x+/s05gFFjAyLCKUb04tag stUjXWC+pKDM9oyQ3MTNH19DAVC83tbg4MT01JzGpWC85P3cTIzC4GIBgB+Pef06HGCU5mJRE eXV3CUUK8SXlp1RmJBZnxBeV5qQWH2KU4eBQkuD1khGOFBIsSk1PrUjLzAGGOUxagoNHSYT3q ARQmre4IDG3ODMdInWKUZfj0cof75mEWPLy81KlxHm7QGYIgBRllObBjYDF3CVGWSlhXkago4 R4ClKLcjNLUOVfMYpzMCoJ804FmcKTmVcCt+kV0BFMQEcEMgiAHFGSiJCSamDUy9rbVXBcaPL 9vtpTjnW/MzzPPl57ceeT4DcTX96Yx2py+taukoybxsu0dvkJeq0+wxi89c4p/i+LesONbRjz 30wLcXRhXfoyqL9HekJKY51Gq/LmGWe/B6l9CN3A0Cdx5hGr2KMnt7+tDfdo7r19ZC23wr5H7 q/fekmu/1USKdZT8nySglyNEktxRqKhFnNRcSIA7GCpFrQCAAA= X-Env-Sender: olekstysh@gmail.com X-Msg-Ref: server-5.tower-206.messagelabs.com!1494425015!95679118!1 X-Originating-IP: [74.125.82.65] X-SpamReason: No, hits=0.5 required=7.0 tests=BODY_RANDOM_LONG X-StarScan-Received: X-StarScan-Version: 9.4.12; banners=-,-,- X-VirusChecked: Checked Received: (qmail 33651 invoked from network); 10 May 2017 14:03:36 -0000 Received: from mail-wm0-f65.google.com (HELO mail-wm0-f65.google.com) (74.125.82.65) by server-5.tower-206.messagelabs.com with AES128-GCM-SHA256 encrypted SMTP; 10 May 2017 14:03:36 -0000 Received: by mail-wm0-f65.google.com with SMTP id u65so43280wmu.3 for ; Wed, 10 May 2017 07:03:35 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=ALTszbJn9Bgh1FHAYVJo2Q/dte4BtXg2FtqRFG5lAc8=; b=VQC6zp2JmmyGyUgPAGRH0AiXg0165LBfcUXWIDiiHyymM1A/KBDpUGzcmBo+h5FxMm LjMzwjO1J4lCavWQZ246+AABo3k8bmbGC0wWho4/RxW7AKWVcmenpAC3Pz0Ejt6ljxSo wHbQSiOYnTl0VKruAmDsrDibxf2N53URHSEB610ec9xZWYC8VS/VP2fXx79M36rhE3NN g/12KUBtR6yS9SxUcqa1jQPznC/aIs18CnxxEdhZp6P6d9DXPri1iqNBgO53PuLpxmrQ 1Hz1WFfgasVw+makZH/bezjP0O69vGo/WPvr4pr3w63UBURTos66rAOLnwSwmI4l0lxz NNAg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=ALTszbJn9Bgh1FHAYVJo2Q/dte4BtXg2FtqRFG5lAc8=; b=HKuQA+Qu9lwd0jK2aus33wgv2iALh38uEoRZ6x7LqmzxOPIitxNcgsT9yBs3SWTIyJ loMV3xnXjzAUGsJo8sZ2mz8bNPVs34SLj+q3VT2IWl6k3XZq6WMCuZtRmo71VDLXsEgR PeB3l7VqigioM/h7BAX2v747AAwRNJQjfet0X/90+5N0BXuyUzEkRl5NxUHLtKjheIMP 6Qlvgv+3azEKDkwngjB9kI8wXHJb2Xud7zhQZ3656Bcv4bL//JSZe6SkwIyPE1angmBL rF6YN1NZN/0WDSWb4gxalPB/346qx+Ga+onKwlHgSX/Fqe8byjOVuKOwKAk18qI6BRmu SpWA== X-Gm-Message-State: AODbwcDcInATTEb37PRnhoi0nXdogWzDwG6Ct32YoX1hfidJdSBbQqYt mczXVxsnRCniRQ== X-Received: by 10.28.210.9 with SMTP id j9mr3359505wmg.120.1494425015281; Wed, 10 May 2017 07:03:35 -0700 (PDT) Received: from otyshchenko.kyiv.epam.com (ll-54.209.223.85.sovam.net.ua. [85.223.209.54]) by smtp.gmail.com with ESMTPSA id c34sm3378304wrc.7.2017.05.10.07.03.33 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Wed, 10 May 2017 07:03:34 -0700 (PDT) From: Oleksandr Tyshchenko To: xen-devel@lists.xenproject.org Date: Wed, 10 May 2017 17:03:06 +0300 Message-Id: <1494424994-26232-3-git-send-email-olekstysh@gmail.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1494424994-26232-1-git-send-email-olekstysh@gmail.com> References: <1494424994-26232-1-git-send-email-olekstysh@gmail.com> Cc: wei.liu2@citrix.com, julien.grall@arm.com, sstabellini@kernel.org, ian.jackson@eu.citrix.com, jbeulich@suse.com Subject: [Xen-devel] [PATCH v1 02/10] iommu: Add extra order argument to the IOMMU APIs and platform callbacks X-BeenThere: xen-devel@lists.xen.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" X-Virus-Scanned: ClamAV using ClamSMTP From: Oleksandr Tyshchenko Replace existing single-page stuff (IOMMU APIs and platform callbacks) with the multi-page one followed by modifications of all related parts. These new map_pages/unmap_pages APIs do almost the same thing as old map_page/unmap_page ones except the formers have extra order argument and as the result can handle the number of pages. So have new platform callbacks. Although the current behavior was retained in all places (I hope), it should be noted that the rollback logic was moved from the common code to the IOMMU drivers. Now the IOMMU drivers are responsible for unmapping already mapped pages if something went wrong during mapping the number of pages (order > 0). Signed-off-by: Oleksandr Tyshchenko CC: Jan Beulich CC: Julien Grall Reviewed-by: Jan Beulich --- Changes in v1: - Replace existing single-page IOMMU APIs/platform callbacks with multi-page ones instead of just keeping both variants of them. - Use order argument instead of page_count. - Clarify patch subject/description. --- xen/arch/x86/mm.c | 11 +++--- xen/arch/x86/mm/p2m-ept.c | 21 ++---------- xen/arch/x86/mm/p2m-pt.c | 26 +++----------- xen/arch/x86/mm/p2m.c | 38 ++++----------------- xen/arch/x86/x86_64/mm.c | 5 +-- xen/common/grant_table.c | 10 +++--- xen/drivers/passthrough/amd/iommu_map.c | 49 +++++++++++++++++++++++++-- xen/drivers/passthrough/amd/pci_amd_iommu.c | 8 ++--- xen/drivers/passthrough/arm/smmu.c | 41 ++++++++++++++++++++-- xen/drivers/passthrough/iommu.c | 21 ++++++------ xen/drivers/passthrough/vtd/iommu.c | 48 ++++++++++++++++++++++++-- xen/drivers/passthrough/vtd/x86/vtd.c | 4 +-- xen/drivers/passthrough/x86/iommu.c | 6 ++-- xen/include/asm-x86/hvm/svm/amd-iommu-proto.h | 8 +++-- xen/include/xen/iommu.h | 20 ++++++----- 15 files changed, 195 insertions(+), 121 deletions(-) diff --git a/xen/arch/x86/mm.c b/xen/arch/x86/mm.c index 96bc280..c5bc3a5 100644 --- a/xen/arch/x86/mm.c +++ b/xen/arch/x86/mm.c @@ -2623,11 +2623,14 @@ static int __get_page_type(struct page_info *page, unsigned long type, if ( d && is_pv_domain(d) && unlikely(need_iommu(d)) ) { if ( (x & PGT_type_mask) == PGT_writable_page ) - iommu_ret = iommu_unmap_page(d, mfn_to_gmfn(d, page_to_mfn(page))); + iommu_ret = iommu_unmap_pages(d, + mfn_to_gmfn(d, page_to_mfn(page)), + 0); else if ( type == PGT_writable_page ) - iommu_ret = iommu_map_page(d, mfn_to_gmfn(d, page_to_mfn(page)), - page_to_mfn(page), - IOMMUF_readable|IOMMUF_writable); + iommu_ret = iommu_map_pages(d, + mfn_to_gmfn(d, page_to_mfn(page)), + page_to_mfn(page), 0, + IOMMUF_readable|IOMMUF_writable); } } diff --git a/xen/arch/x86/mm/p2m-ept.c b/xen/arch/x86/mm/p2m-ept.c index f37a1f2..3a4b6b8 100644 --- a/xen/arch/x86/mm/p2m-ept.c +++ b/xen/arch/x86/mm/p2m-ept.c @@ -869,26 +869,9 @@ out: else { if ( iommu_flags ) - for ( i = 0; i < (1 << order); i++ ) - { - rc = iommu_map_page(d, gfn + i, mfn_x(mfn) + i, iommu_flags); - if ( unlikely(rc) ) - { - while ( i-- ) - /* If statement to satisfy __must_check. */ - if ( iommu_unmap_page(p2m->domain, gfn + i) ) - continue; - - break; - } - } + rc = iommu_map_pages(d, gfn, mfn_x(mfn), order, iommu_flags); else - for ( i = 0; i < (1 << order); i++ ) - { - ret = iommu_unmap_page(d, gfn + i); - if ( !rc ) - rc = ret; - } + rc = iommu_unmap_pages(d, gfn, order); } } diff --git a/xen/arch/x86/mm/p2m-pt.c b/xen/arch/x86/mm/p2m-pt.c index 5079b59..51f3e10 100644 --- a/xen/arch/x86/mm/p2m-pt.c +++ b/xen/arch/x86/mm/p2m-pt.c @@ -507,7 +507,7 @@ p2m_pt_set_entry(struct p2m_domain *p2m, unsigned long gfn, mfn_t mfn, { /* XXX -- this might be able to be faster iff current->domain == d */ void *table; - unsigned long i, gfn_remainder = gfn; + unsigned long gfn_remainder = gfn; l1_pgentry_t *p2m_entry, entry_content; /* Intermediate table to free if we're replacing it with a superpage. */ l1_pgentry_t intermediate_entry = l1e_empty(); @@ -718,28 +718,10 @@ p2m_pt_set_entry(struct p2m_domain *p2m, unsigned long gfn, mfn_t mfn, amd_iommu_flush_pages(p2m->domain, gfn, page_order); } else if ( iommu_pte_flags ) - for ( i = 0; i < (1UL << page_order); i++ ) - { - rc = iommu_map_page(p2m->domain, gfn + i, mfn_x(mfn) + i, - iommu_pte_flags); - if ( unlikely(rc) ) - { - while ( i-- ) - /* If statement to satisfy __must_check. */ - if ( iommu_unmap_page(p2m->domain, gfn + i) ) - continue; - - break; - } - } + rc = iommu_map_pages(p2m->domain, gfn, mfn_x(mfn), page_order, + iommu_pte_flags); else - for ( i = 0; i < (1UL << page_order); i++ ) - { - int ret = iommu_unmap_page(p2m->domain, gfn + i); - - if ( !rc ) - rc = ret; - } + rc = iommu_unmap_pages(p2m->domain, gfn, page_order); } /* diff --git a/xen/arch/x86/mm/p2m.c b/xen/arch/x86/mm/p2m.c index 1d57e5c..15ba71d 100644 --- a/xen/arch/x86/mm/p2m.c +++ b/xen/arch/x86/mm/p2m.c @@ -705,20 +705,9 @@ p2m_remove_page(struct p2m_domain *p2m, unsigned long gfn, unsigned long mfn, if ( !paging_mode_translate(p2m->domain) ) { - int rc = 0; - if ( need_iommu(p2m->domain) ) - { - for ( i = 0; i < (1 << page_order); i++ ) - { - int ret = iommu_unmap_page(p2m->domain, mfn + i); - - if ( !rc ) - rc = ret; - } - } - - return rc; + return iommu_unmap_pages(p2m->domain, mfn, page_order); + return 0; } ASSERT(gfn_locked_by_me(p2m, gfn)); @@ -765,23 +754,8 @@ guest_physmap_add_entry(struct domain *d, gfn_t gfn, mfn_t mfn, if ( !paging_mode_translate(d) ) { if ( need_iommu(d) && t == p2m_ram_rw ) - { - for ( i = 0; i < (1 << page_order); i++ ) - { - rc = iommu_map_page(d, mfn_x(mfn_add(mfn, i)), - mfn_x(mfn_add(mfn, i)), - IOMMUF_readable|IOMMUF_writable); - if ( rc != 0 ) - { - while ( i-- > 0 ) - /* If statement to satisfy __must_check. */ - if ( iommu_unmap_page(d, mfn_x(mfn_add(mfn, i))) ) - continue; - - return rc; - } - } - } + return iommu_map_pages(d, mfn_x(mfn), mfn_x(mfn), page_order, + IOMMUF_readable|IOMMUF_writable); return 0; } @@ -1134,7 +1108,7 @@ int set_identity_p2m_entry(struct domain *d, unsigned long gfn, { if ( !need_iommu(d) ) return 0; - return iommu_map_page(d, gfn, gfn, IOMMUF_readable|IOMMUF_writable); + return iommu_map_pages(d, gfn, gfn, 0, IOMMUF_readable|IOMMUF_writable); } gfn_lock(p2m, gfn, 0); @@ -1222,7 +1196,7 @@ int clear_identity_p2m_entry(struct domain *d, unsigned long gfn) { if ( !need_iommu(d) ) return 0; - return iommu_unmap_page(d, gfn); + return iommu_unmap_pages(d, gfn, 0); } gfn_lock(p2m, gfn, 0); diff --git a/xen/arch/x86/x86_64/mm.c b/xen/arch/x86/x86_64/mm.c index 34f3250..24aaf88 100644 --- a/xen/arch/x86/x86_64/mm.c +++ b/xen/arch/x86/x86_64/mm.c @@ -1443,13 +1443,14 @@ int memory_add(unsigned long spfn, unsigned long epfn, unsigned int pxm) if ( iommu_enabled && !iommu_passthrough && !need_iommu(hardware_domain) ) { for ( i = spfn; i < epfn; i++ ) - if ( iommu_map_page(hardware_domain, i, i, IOMMUF_readable|IOMMUF_writable) ) + if ( iommu_map_pages(hardware_domain, i, i, 0, + IOMMUF_readable|IOMMUF_writable) ) break; if ( i != epfn ) { while (i-- > old_max) /* If statement to satisfy __must_check. */ - if ( iommu_unmap_page(hardware_domain, i) ) + if ( iommu_unmap_pages(hardware_domain, i, 0) ) continue; goto destroy_m2p; diff --git a/xen/common/grant_table.c b/xen/common/grant_table.c index 4fe9544..ecf8f82 100644 --- a/xen/common/grant_table.c +++ b/xen/common/grant_table.c @@ -964,13 +964,13 @@ __gnttab_map_grant_ref( !(old_pin & (GNTPIN_hstw_mask|GNTPIN_devw_mask)) ) { if ( !(kind & MAPKIND_WRITE) ) - err = iommu_map_page(ld, frame, frame, - IOMMUF_readable|IOMMUF_writable); + err = iommu_map_pages(ld, frame, frame, 0, + IOMMUF_readable|IOMMUF_writable); } else if ( act_pin && !old_pin ) { if ( !kind ) - err = iommu_map_page(ld, frame, frame, IOMMUF_readable); + err = iommu_map_pages(ld, frame, frame, 0, IOMMUF_readable); } if ( err ) { @@ -1190,9 +1190,9 @@ __gnttab_unmap_common( kind = mapkind(lgt, rd, op->frame); if ( !kind ) - err = iommu_unmap_page(ld, op->frame); + err = iommu_unmap_pages(ld, op->frame, 0); else if ( !(kind & MAPKIND_WRITE) ) - err = iommu_map_page(ld, op->frame, op->frame, IOMMUF_readable); + err = iommu_map_pages(ld, op->frame, op->frame, 0, IOMMUF_readable); double_gt_unlock(lgt, rgt); diff --git a/xen/drivers/passthrough/amd/iommu_map.c b/xen/drivers/passthrough/amd/iommu_map.c index fd2327d..87ab99c 100644 --- a/xen/drivers/passthrough/amd/iommu_map.c +++ b/xen/drivers/passthrough/amd/iommu_map.c @@ -631,8 +631,9 @@ static int update_paging_mode(struct domain *d, unsigned long gfn) return 0; } -int amd_iommu_map_page(struct domain *d, unsigned long gfn, unsigned long mfn, - unsigned int flags) +static int __must_check amd_iommu_map_page(struct domain *d, unsigned long gfn, + unsigned long mfn, + unsigned int flags) { bool_t need_flush = 0; struct domain_iommu *hd = dom_iommu(d); @@ -720,7 +721,8 @@ out: return 0; } -int amd_iommu_unmap_page(struct domain *d, unsigned long gfn) +static int __must_check amd_iommu_unmap_page(struct domain *d, + unsigned long gfn) { unsigned long pt_mfn[7]; struct domain_iommu *hd = dom_iommu(d); @@ -771,6 +773,47 @@ int amd_iommu_unmap_page(struct domain *d, unsigned long gfn) return 0; } +/* TODO: Optimize by squashing map_pages/unmap_pages with map_page/unmap_page */ +int __must_check amd_iommu_map_pages(struct domain *d, unsigned long gfn, + unsigned long mfn, unsigned int order, + unsigned int flags) +{ + unsigned long i; + int rc = 0; + + for ( i = 0; i < (1UL << order); i++ ) + { + rc = amd_iommu_map_page(d, gfn + i, mfn + i, flags); + if ( unlikely(rc) ) + { + while ( i-- ) + /* If statement to satisfy __must_check. */ + if ( amd_iommu_unmap_page(d, gfn + i) ) + continue; + + break; + } + } + + return rc; +} + +int __must_check amd_iommu_unmap_pages(struct domain *d, unsigned long gfn, + unsigned int order) +{ + unsigned long i; + int rc = 0; + + for ( i = 0; i < (1UL << order); i++ ) + { + int ret = amd_iommu_unmap_page(d, gfn + i); + if ( !rc ) + rc = ret; + } + + return rc; +} + int amd_iommu_reserve_domain_unity_map(struct domain *domain, u64 phys_addr, unsigned long size, int iw, int ir) diff --git a/xen/drivers/passthrough/amd/pci_amd_iommu.c b/xen/drivers/passthrough/amd/pci_amd_iommu.c index 8c25110..fe744d2 100644 --- a/xen/drivers/passthrough/amd/pci_amd_iommu.c +++ b/xen/drivers/passthrough/amd/pci_amd_iommu.c @@ -296,8 +296,8 @@ static void __hwdom_init amd_iommu_hwdom_init(struct domain *d) */ if ( mfn_valid(_mfn(pfn)) ) { - int ret = amd_iommu_map_page(d, pfn, pfn, - IOMMUF_readable|IOMMUF_writable); + int ret = amd_iommu_map_pages(d, pfn, pfn, 0, + IOMMUF_readable|IOMMUF_writable); if ( !rc ) rc = ret; @@ -620,8 +620,8 @@ const struct iommu_ops amd_iommu_ops = { .remove_device = amd_iommu_remove_device, .assign_device = amd_iommu_assign_device, .teardown = amd_iommu_domain_destroy, - .map_page = amd_iommu_map_page, - .unmap_page = amd_iommu_unmap_page, + .map_pages = amd_iommu_map_pages, + .unmap_pages = amd_iommu_unmap_pages, .free_page_table = deallocate_page_table, .reassign_device = reassign_device, .get_device_group_id = amd_iommu_group_id, diff --git a/xen/drivers/passthrough/arm/smmu.c b/xen/drivers/passthrough/arm/smmu.c index 1082fcf..527a592 100644 --- a/xen/drivers/passthrough/arm/smmu.c +++ b/xen/drivers/passthrough/arm/smmu.c @@ -2780,6 +2780,43 @@ static int __must_check arm_smmu_unmap_page(struct domain *d, unsigned long gfn) return 0; } +/* TODO: Optimize by squashing map_pages/unmap_pages with map_page/unmap_page */ +static int __must_check arm_smmu_map_pages(struct domain *d, unsigned long gfn, + unsigned long mfn, unsigned int order, unsigned int flags) +{ + unsigned long i; + int rc = 0; + + for (i = 0; i < (1UL << order); i++) { + rc = arm_smmu_map_page(d, gfn + i, mfn + i, flags); + if (unlikely(rc)) { + while (i--) + /* If statement to satisfy __must_check. */ + if (arm_smmu_unmap_page(d, gfn + i)) + continue; + + break; + } + } + + return rc; +} + +static int __must_check arm_smmu_unmap_pages(struct domain *d, + unsigned long gfn, unsigned int order) +{ + unsigned long i; + int rc = 0; + + for (i = 0; i < (1UL << order); i++) { + int ret = arm_smmu_unmap_page(d, gfn + i); + if (!rc) + rc = ret; + } + + return rc; +} + static const struct iommu_ops arm_smmu_iommu_ops = { .init = arm_smmu_iommu_domain_init, .hwdom_init = arm_smmu_iommu_hwdom_init, @@ -2788,8 +2825,8 @@ static const struct iommu_ops arm_smmu_iommu_ops = { .iotlb_flush_all = arm_smmu_iotlb_flush_all, .assign_device = arm_smmu_assign_dev, .reassign_device = arm_smmu_reassign_dev, - .map_page = arm_smmu_map_page, - .unmap_page = arm_smmu_unmap_page, + .map_pages = arm_smmu_map_pages, + .unmap_pages = arm_smmu_unmap_pages, }; static __init const struct arm_smmu_device *find_smmu(const struct device *dev) diff --git a/xen/drivers/passthrough/iommu.c b/xen/drivers/passthrough/iommu.c index 5e81813..3e9e4c3 100644 --- a/xen/drivers/passthrough/iommu.c +++ b/xen/drivers/passthrough/iommu.c @@ -188,7 +188,7 @@ void __hwdom_init iommu_hwdom_init(struct domain *d) == PGT_writable_page) ) mapping |= IOMMUF_writable; - ret = hd->platform_ops->map_page(d, gfn, mfn, mapping); + ret = hd->platform_ops->map_pages(d, gfn, mfn, 0, mapping); if ( !rc ) rc = ret; @@ -249,8 +249,8 @@ void iommu_domain_destroy(struct domain *d) arch_iommu_domain_destroy(d); } -int iommu_map_page(struct domain *d, unsigned long gfn, unsigned long mfn, - unsigned int flags) +int iommu_map_pages(struct domain *d, unsigned long gfn, unsigned long mfn, + unsigned int order, unsigned int flags) { const struct domain_iommu *hd = dom_iommu(d); int rc; @@ -258,13 +258,13 @@ int iommu_map_page(struct domain *d, unsigned long gfn, unsigned long mfn, if ( !iommu_enabled || !hd->platform_ops ) return 0; - rc = hd->platform_ops->map_page(d, gfn, mfn, flags); + rc = hd->platform_ops->map_pages(d, gfn, mfn, order, flags); if ( unlikely(rc) ) { if ( !d->is_shutting_down && printk_ratelimit() ) printk(XENLOG_ERR - "d%d: IOMMU mapping gfn %#lx to mfn %#lx failed: %d\n", - d->domain_id, gfn, mfn, rc); + "d%d: IOMMU mapping gfn %#lx to mfn %#lx order %u failed: %d\n", + d->domain_id, gfn, mfn, order, rc); if ( !is_hardware_domain(d) ) domain_crash(d); @@ -273,7 +273,8 @@ int iommu_map_page(struct domain *d, unsigned long gfn, unsigned long mfn, return rc; } -int iommu_unmap_page(struct domain *d, unsigned long gfn) +int iommu_unmap_pages(struct domain *d, unsigned long gfn, + unsigned int order) { const struct domain_iommu *hd = dom_iommu(d); int rc; @@ -281,13 +282,13 @@ int iommu_unmap_page(struct domain *d, unsigned long gfn) if ( !iommu_enabled || !hd->platform_ops ) return 0; - rc = hd->platform_ops->unmap_page(d, gfn); + rc = hd->platform_ops->unmap_pages(d, gfn, order); if ( unlikely(rc) ) { if ( !d->is_shutting_down && printk_ratelimit() ) printk(XENLOG_ERR - "d%d: IOMMU unmapping gfn %#lx failed: %d\n", - d->domain_id, gfn, rc); + "d%d: IOMMU unmapping gfn %#lx order %u failed: %d\n", + d->domain_id, gfn, order, rc); if ( !is_hardware_domain(d) ) domain_crash(d); diff --git a/xen/drivers/passthrough/vtd/iommu.c b/xen/drivers/passthrough/vtd/iommu.c index a5c61c6..6c7f4c6 100644 --- a/xen/drivers/passthrough/vtd/iommu.c +++ b/xen/drivers/passthrough/vtd/iommu.c @@ -1816,6 +1816,50 @@ static int __must_check intel_iommu_unmap_page(struct domain *d, return dma_pte_clear_one(d, (paddr_t)gfn << PAGE_SHIFT_4K); } +/* TODO: Optimize by squashing map_pages/unmap_pages with map_page/unmap_page */ +static int __must_check intel_iommu_map_pages(struct domain *d, + unsigned long gfn, + unsigned long mfn, + unsigned int order, + unsigned int flags) +{ + unsigned long i; + int rc = 0; + + for ( i = 0; i < (1UL << order); i++ ) + { + rc = intel_iommu_map_page(d, gfn + i, mfn + i, flags); + if ( unlikely(rc) ) + { + while ( i-- ) + /* If statement to satisfy __must_check. */ + if ( intel_iommu_unmap_page(d, gfn + i) ) + continue; + + break; + } + } + + return rc; +} + +static int __must_check intel_iommu_unmap_pages(struct domain *d, + unsigned long gfn, + unsigned int order) +{ + unsigned long i; + int rc = 0; + + for ( i = 0; i < (1UL << order); i++ ) + { + int ret = intel_iommu_unmap_page(d, gfn + i); + if ( !rc ) + rc = ret; + } + + return rc; +} + int iommu_pte_flush(struct domain *d, u64 gfn, u64 *pte, int order, int present) { @@ -2639,8 +2683,8 @@ const struct iommu_ops intel_iommu_ops = { .remove_device = intel_iommu_remove_device, .assign_device = intel_iommu_assign_device, .teardown = iommu_domain_teardown, - .map_page = intel_iommu_map_page, - .unmap_page = intel_iommu_unmap_page, + .map_pages = intel_iommu_map_pages, + .unmap_pages = intel_iommu_unmap_pages, .free_page_table = iommu_free_page_table, .reassign_device = reassign_device_ownership, .get_device_group_id = intel_iommu_group_id, diff --git a/xen/drivers/passthrough/vtd/x86/vtd.c b/xen/drivers/passthrough/vtd/x86/vtd.c index 88a60b3..62a6ee6 100644 --- a/xen/drivers/passthrough/vtd/x86/vtd.c +++ b/xen/drivers/passthrough/vtd/x86/vtd.c @@ -143,8 +143,8 @@ void __hwdom_init vtd_set_hwdom_mapping(struct domain *d) tmp = 1 << (PAGE_SHIFT - PAGE_SHIFT_4K); for ( j = 0; j < tmp; j++ ) { - int ret = iommu_map_page(d, pfn * tmp + j, pfn * tmp + j, - IOMMUF_readable|IOMMUF_writable); + int ret = iommu_map_pages(d, pfn * tmp + j, pfn * tmp + j, 0, + IOMMUF_readable|IOMMUF_writable); if ( !rc ) rc = ret; diff --git a/xen/drivers/passthrough/x86/iommu.c b/xen/drivers/passthrough/x86/iommu.c index 0253823..973b72f 100644 --- a/xen/drivers/passthrough/x86/iommu.c +++ b/xen/drivers/passthrough/x86/iommu.c @@ -65,9 +65,9 @@ int arch_iommu_populate_page_table(struct domain *d) { ASSERT(!(gfn >> DEFAULT_DOMAIN_ADDRESS_WIDTH)); BUG_ON(SHARED_M2P(gfn)); - rc = hd->platform_ops->map_page(d, gfn, mfn, - IOMMUF_readable | - IOMMUF_writable); + rc = hd->platform_ops->map_pages(d, gfn, mfn, 0, + IOMMUF_readable | + IOMMUF_writable); } if ( rc ) { diff --git a/xen/include/asm-x86/hvm/svm/amd-iommu-proto.h b/xen/include/asm-x86/hvm/svm/amd-iommu-proto.h index 99bc21c..8f44489 100644 --- a/xen/include/asm-x86/hvm/svm/amd-iommu-proto.h +++ b/xen/include/asm-x86/hvm/svm/amd-iommu-proto.h @@ -52,9 +52,11 @@ int amd_iommu_init(void); int amd_iommu_update_ivrs_mapping_acpi(void); /* mapping functions */ -int __must_check amd_iommu_map_page(struct domain *d, unsigned long gfn, - unsigned long mfn, unsigned int flags); -int __must_check amd_iommu_unmap_page(struct domain *d, unsigned long gfn); +int __must_check amd_iommu_map_pages(struct domain *d, unsigned long gfn, + unsigned long mfn, unsigned int order, + unsigned int flags); +int __must_check amd_iommu_unmap_pages(struct domain *d, unsigned long gfn, + unsigned int order); u64 amd_iommu_get_next_table_from_pte(u32 *entry); int __must_check amd_iommu_alloc_root(struct domain_iommu *hd); int amd_iommu_reserve_domain_unity_map(struct domain *domain, diff --git a/xen/include/xen/iommu.h b/xen/include/xen/iommu.h index 5803e3f..3297998 100644 --- a/xen/include/xen/iommu.h +++ b/xen/include/xen/iommu.h @@ -71,14 +71,16 @@ int iommu_construct(struct domain *d); /* Function used internally, use iommu_domain_destroy */ void iommu_teardown(struct domain *d); -/* iommu_map_page() takes flags to direct the mapping operation. */ +/* iommu_map_pages() takes flags to direct the mapping operation. */ #define _IOMMUF_readable 0 #define IOMMUF_readable (1u<<_IOMMUF_readable) #define _IOMMUF_writable 1 #define IOMMUF_writable (1u<<_IOMMUF_writable) -int __must_check iommu_map_page(struct domain *d, unsigned long gfn, - unsigned long mfn, unsigned int flags); -int __must_check iommu_unmap_page(struct domain *d, unsigned long gfn); +int __must_check iommu_map_pages(struct domain *d, unsigned long gfn, + unsigned long mfn, unsigned int order, + unsigned int flags); +int __must_check iommu_unmap_pages(struct domain *d, unsigned long gfn, + unsigned int order); enum iommu_feature { @@ -168,9 +170,11 @@ struct iommu_ops { #endif /* HAS_PCI */ void (*teardown)(struct domain *d); - int __must_check (*map_page)(struct domain *d, unsigned long gfn, - unsigned long mfn, unsigned int flags); - int __must_check (*unmap_page)(struct domain *d, unsigned long gfn); + int __must_check (*map_pages)(struct domain *d, unsigned long gfn, + unsigned long mfn, unsigned int order, + unsigned int flags); + int __must_check (*unmap_pages)(struct domain *d, unsigned long gfn, + unsigned int order); void (*free_page_table)(struct page_info *); #ifdef CONFIG_X86 void (*update_ire_from_apic)(unsigned int apic, unsigned int reg, unsigned int value); @@ -213,7 +217,7 @@ void iommu_dev_iotlb_flush_timeout(struct domain *d, struct pci_dev *pdev); * The purpose of the iommu_dont_flush_iotlb optional cpu flag is to * avoid unecessary iotlb_flush in the low level IOMMU code. * - * iommu_map_page/iommu_unmap_page must flush the iotlb but somethimes + * iommu_map_pages/iommu_unmap_pages must flush the iotlb but somethimes * this operation can be really expensive. This flag will be set by the * caller to notify the low level IOMMU code to avoid the iotlb flushes. * iommu_iotlb_flush/iommu_iotlb_flush_all will be explicitly called by