iommu: Bounce page for untrusted devices
Subsystems (7)
v8 cover iommu: Bounce page for untrusted devices
The Thunderbolt vulnerabilities are public and have a nice name as Thunderclap [1] [3] nowadays. This patch series aims to mitigate those concerns.
An external PCI device is a PCI peripheral device connected to the system through an external bus, such as Thunderbolt. What makes it different is that it can't be trusted to the same degree as the devices build into the system. Generally, a trusted PCIe device will DMA into the designated buffers and not overrun or otherwise write outside the specified bounds. But it's different for an external device.
The minimum IOMMU mapping granularity is one page (4k), so for DMA transfers smaller than that a malicious PCIe device can access the whole page of memory even if it does not belong to the driver in question. This opens a possibility for DMA attack. For more information about DMA attacks imposed by an untrusted PCI/PCIe device, please refer to [2].
This implements bounce buffer for the untrusted external devices. The transfers should be limited in isolated pages so the IOMMU window does not cover memory outside of what the driver expects. Previously (v3 and before), we proposed an optimisation to only copy the head and tail of the buffer if it spans multiple pages, and directly map the ones in the middle. Figure 1 gives a big picture about this solution.
swiotlb System
IOVA bounce page Memory
.---------. .---------. .---------.
| | | | | |
| | | | | |
buffer_start .---------. .---------. .---------.
| |----->| |*******>| |
| | | | swiotlb| |
| | | | mapping| |
IOMMU Page '---------' '---------' '---------'
Boundary | | | |
| | | |
| | | |
| |------------------------>| |
| | IOMMU mapping | |
| | | |
IOMMU Page .---------. .---------.
Boundary | | | |
| | | |
| |------------------------>| |
| | IOMMU mapping | |
| | | |
| | | |
IOMMU Page .---------. .---------. .---------.
Boundary | | | | | |
| | | | | |
| |----->| |*******>| |
buffer_end '---------' '---------' swiotlb'---------'
| | | | mapping| |
| | | | | |
'---------' '---------' '---------'Figure 1: A big view of iommu bounce page
As Robin Murphy pointed out, this ties us to using strict mode for TLB maintenance, which may not be an overall win depending on the balance between invalidation bandwidth vs. memcpy bandwidth. If we use standard SWIOTLB logic to always copy the whole thing, we should be able to release the bounce pages via the flush queue to allow 'safe' lazy unmaps. So since v4 we start to use the standard swiotlb logic.
swiotlb System
IOVA bounce page Memory
buffer_start .---------. .---------. .---------.
| | | | | |
| | | | | |
| | | | .---------.physical
| |----->| | ------>| |_start
| |iommu | | swiotlb| |
| | map | | map | |
IOMMU Page .---------. .---------. '---------'
Boundary | | | | | |
| | | | | |
| |----->| | | |
| |iommu | | | |
| | map | | | |
| | | | | |
IOMMU Page .---------. .---------. .---------.
Boundary | | | | | |
| |----->| | | |
| |iommu | | | |
| | map | | | |
| | | | | |
IOMMU Page | | | | | |
Boundary .---------. .---------. .---------.
| | | |------->| |
buffer_end '---------' '---------' swiotlb| |
| |----->| | map | |
| |iommu | | | |
| | map | | '---------' physical
| | | | | | _end
'---------' '---------' '---------'Figure 2: A big view of simplified iommu bounce page
The implementation of bounce buffers for untrusted devices will cause a little performance overhead, but we didn't see any user experience problems. The users could use the kernel parameter defined in the IOMMU driver to remove the performance overhead if they trust their devices enough.
This series introduces below APIs for bounce page:
* iommu_bounce_map(dev, addr, paddr, size, dir, attrs)
- Map a buffer start at DMA address @addr in bounce page manner. For buffer that doesn't cross whole minimal IOMMU pages, the bounce buffer policy is applied. A bounce page mapped by swiotlb will be used as the DMA target in the IOMMU page table.
* iommu_bounce_unmap(dev, addr, size, dir, attrs)
- Unmap the buffer mapped with iommu_bounce_map(). The bounce page will be torn down after the bounced data get synced.
* iommu_bounce_sync_single(dev, addr, size, dir, target)
- Synce the bounced data in case the bounce mapped buffer is reused.
The bounce page idea:
The patch series has been tested by:
Reference:
[1] https://thunderclap.io/
[2] https://thunderclap.io/thunderclap-paper-ndss2019.pdf
[3] https://christian.kellner.me/2019/02/27/thunderclap-and-linux/
[4] https://lkml.org/lkml/2019/3/4/644
Best regards,
Baolu
Change log:
v7->v8:
- The previous v7 was posted here:
https://lkml.org/lkml/2019/8/23/83
- Keep the swiotlb pre-allocated pages only if intel-iommu driver needs bounce buffers, a.k.a. system has untrusted devices or external ports.
v6->v7:
- The previous v6 was posted here:
https://lkml.org/lkml/2019/7/30/18
- Remove the unnecessary bounce page iommu APIs
v5->v6:
- The previous v5 was posted here:
https://lkml.org/lkml/2019/7/24/2134
- Move the per-device dma ops into another seperated series.
- Christoph Hellwig reviewed the patches and add his Reviewed-bys.
- Add Steven Rostedt's Review-by for the trace patch.
- Adress the review comments from Christoph Hellwig.
- This patch series is now based on v5.3-rc2.
v4->v5:
- The previous v4 was posted here:
https://lkml.org/lkml/2019/6/2/187 - Add per-device dma ops and use bounce buffer specific dma ops for those untrusted devices. devices with identity domains -> system default dma ops trusted devices with dma domains -> iommu/vt-d dma ops untrusted devices -> bounced dma ops
- Address various review comments received since v4.
- This patch series is based on v5.3-rc1.
v3->v4:
- The previous v3 was posted here:
https://lkml.org/lkml/2019/4/20/213
- Discard the optimization of only mapping head and tail partial pages, use the standard swiotlb in order to achieve iotlb flush efficiency.
- This patch series is based on the top of the vt-d branch of Joerg's iommu tree.
v2->v3:
- The previous v2 was posed here:
https://lkml.org/lkml/2019/3/27/157
- Reuse the existing swiotlb APIs for bounce buffer by extending it to support bounce page.
- Move the bouce page APIs into iommu generic layer.
- This patch series is based on 5.1-rc1.
v1->v2:
- The previous v1 was posted here:
https://lkml.org/lkml/2019/3/12/66
- Refactor the code to remove struct bounce_param;
- During the v1 review cycle, we discussed the possibility of reusing swiotlb code to avoid code dumplication, but we found the swiotlb implementations are not ready for the use of bounce page pool.
https://lkml.org/lkml/2019/3/19/259
- This patch series has been rebased to v5.1-rc2.
Lu Baolu (7):
PCI: Add dev_is_untrusted helper
swiotlb: Split size parameter to map/unmap APIs
swiotlb: Zero out bounce buffer for untrusted device iommu/vt-d: Check whether device requires bounce buffer iommu/vt-d: Don't switch off swiotlb if bounce page is used iommu/vt-d: Add trace events for device dma map/unmap iommu/vt-d: Use bounce buffer for untrusted devices
.../admin-guide/kernel-parameters.txt | 5 + drivers/iommu/Kconfig | 1 + drivers/iommu/Makefile | 1 + drivers/iommu/intel-iommu.c | 282 +++++++++++++++++- drivers/iommu/intel-trace.c | 14 + drivers/xen/swiotlb-xen.c | 8 +- include/linux/pci.h | 2 + include/linux/swiotlb.h | 8 +- include/trace/events/intel_iommu.h | 84 ++++++ kernel/dma/direct.c | 2 +- kernel/dma/swiotlb.c | 46 ++- 11 files changed, 419 insertions(+), 34 deletions(-) create mode 100644 drivers/iommu/intel-trace.c create mode 100644 include/trace/events/intel_iommu.h
Signature · 1 line
2.17.1
PATCH v8 1/7 PCI: Add dev_is_untrusted helper
There are several places in the kernel where it is necessary to check whether a device is a pci untrusted device. Add a helper to simplify the callers.
--- include/linux/pci.h | 2 ++ 1 file changed, 2 insertions(+)
include/linux/pci.h +2 -0
@@ -1029,6 +1029,7 @@ void pcibios_setup_bridge(struct pci_bus *bus, unsigned long type);void pci_sort_breadthfirst (void );#define dev_is_pci (d) ((d)->bus == &pci_bus_type)#define dev_is_pf (d) ((dev_is_pci(d) ? to_pci_dev(d)->is_physfn : false)) +#define dev_is_untrusted (d) ((dev_is_pci(d) ? to_pci_dev(d)->untrusted : false))/* Generic PCI functions exported to card drivers */
@@ -1768,6 +1769,7 @@ static inline struct pci_dev *pci_dev_get(struct pci_dev *dev) { return NULL; }#define dev_is_pci (d) (false)#define dev_is_pf (d) (false) +#define dev_is_untrusted (d) (false)static inline bool pci_acs_enabled (struct pci_dev *pdev,u16 acs_flags) {return false; } static inline int pci_irqd_intx_xlate(struct irq_domain *d,
Signature · 1 line
2.17.1
PATCH v8 2/7 swiotlb: Split size parameter to map/unmap APIs
In reply to Lu BaoluThis splits the size parameter to swiotlb_tbl_map_single() and swiotlb_tbl_unmap_single() into an alloc_size and a mapping_size parameter, where the latter one is rounded up to the iommu page size.
--- drivers/xen/swiotlb-xen.c | 8 ++++---- include/linux/swiotlb.h | 8 ++++++-- kernel/dma/direct.c | 2 +- kernel/dma/swiotlb.c | 30 +++++++++++++++++++----------- 4 files changed, 30 insertions(+), 18 deletions(-)
drivers/xen/swiotlb-xen.c +4 -4
@@ -386,8 +386,8 @@ static dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page,*/ trace_swiotlb_bounced (dev, dev_addr, size, swiotlb_force); - map =swiotlb_tbl_map_single (dev, start_dma_addr, phys, size, dir, - attrs); + map =swiotlb_tbl_map_single (dev, start_dma_addr, phys, + size, size, dir, attrs);if (map == (phys_addr_t )DMA_MAPPING_ERROR )return DMA_MAPPING_ERROR ;
@@ -397,7 +397,7 @@ static dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page,* Ensure that the address returned is DMA'ble */ if (unlikely (!dma_capable (dev, dev_addr, size))) { -swiotlb_tbl_unmap_single (dev, map, size, dir, +swiotlb_tbl_unmap_single (dev, map, size, size, dir, attrs |DMA_ATTR_SKIP_CPU_SYNC );return DMA_MAPPING_ERROR ; }
@@ -433,7 +433,7 @@ static void xen_unmap_single(struct device *hwdev, dma_addr_t dev_addr,/* NOTE: We use dev_addr here, not paddr! */ if (is_xen_swiotlb_buffer (dev_addr)) -swiotlb_tbl_unmap_single (hwdev, paddr, size, dir, attrs); +swiotlb_tbl_unmap_single (hwdev, paddr, size, size, dir, attrs); } static void xen_swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr,
include/linux/swiotlb.h +6 -2
@@ -46,13 +46,17 @@ enum dma_sync_target {extern phys_addr_t swiotlb_tbl_map_single (struct device *hwdev,dma_addr_t tbl_dma_addr, -phys_addr_t phys,size_t size, +phys_addr_t phys, +size_t mapping_size, +size_t alloc_size,enum dma_data_direction dir,unsigned long attrs);extern void swiotlb_tbl_unmap_single (struct device *hwdev,phys_addr_t tlb_addr, -size_t size,enum dma_data_direction dir, +size_t mapping_size, +size_t alloc_size, +enum dma_data_direction dir,unsigned long attrs); extern void swiotlb_tbl_sync_single(struct device *hwdev,
kernel/dma/direct.c +1 -1
@@ -305,7 +305,7 @@ void dma_direct_unmap_page(struct device *dev, dma_addr_t addr,dma_direct_sync_single_for_cpu (dev, addr, size, dir);if (unlikely (is_swiotlb_buffer (phys))) -swiotlb_tbl_unmap_single (dev, phys, size, dir, attrs); +swiotlb_tbl_unmap_single (dev, phys, size, size, dir, attrs); }EXPORT_SYMBOL (dma_direct_unmap_page);
kernel/dma/swiotlb.c +19 -11
@@ -444,7 +444,9 @@ static void swiotlb_bounce(phys_addr_t orig_addr, phys_addr_t tlb_addr,phys_addr_t swiotlb_tbl_map_single (struct device *hwdev,dma_addr_t tbl_dma_addr, -phys_addr_t orig_addr,size_t size, +phys_addr_t orig_addr, +size_t mapping_size, +size_t alloc_size,enum dma_data_direction dir,unsigned long attrs) {
@@ -464,6 +466,9 @@ phys_addr_t swiotlb_tbl_map_single(struct device *hwdev,pr_warn_once ("%s is active and system is using DMA bounce buffers\n" ,sme_active () ?"SME" :"SEV" ); +if (WARN_ON (mapping_size > alloc_size)) +return (phys_addr_t )DMA_MAPPING_ERROR ; + mask =dma_get_seg_boundary (hwdev); tbl_dma_addr &= mask;
@@ -481,8 +486,8 @@ phys_addr_t swiotlb_tbl_map_single(struct device *hwdev,* For mappings greater than or equal to a page, we limit the stride * (and hence alignment) to a page size. */ - nslots =ALIGN (size,1 <<IO_TLB_SHIFT ) >>IO_TLB_SHIFT ; -if (size >=PAGE_SIZE ) + nslots =ALIGN (alloc_size,1 <<IO_TLB_SHIFT ) >>IO_TLB_SHIFT ; +if (alloc_size >=PAGE_SIZE ) stride = (1 << (PAGE_SHIFT -IO_TLB_SHIFT ));else stride =1 ;
@@ -547,7 +552,7 @@ phys_addr_t swiotlb_tbl_map_single(struct device *hwdev,spin_unlock_irqrestore (&io_tlb_lock, flags);if (!(attrs &DMA_ATTR_NO_WARN ) &&printk_ratelimit ())dev_warn (hwdev,"swiotlb buffer is full (sz: %zd bytes), total %lu (slots), used %lu (slots)\n" , - size, io_tlb_nslabs, tmp_io_tlb_used); + alloc_size, io_tlb_nslabs, tmp_io_tlb_used);return (phys_addr_t )DMA_MAPPING_ERROR ; found: io_tlb_used += nslots;
@@ -562,7 +567,7 @@ phys_addr_t swiotlb_tbl_map_single(struct device *hwdev, io_tlb_orig_addr[index+i] = orig_addr + (i <<IO_TLB_SHIFT );if (!(attrs &DMA_ATTR_SKIP_CPU_SYNC ) && (dir ==DMA_TO_DEVICE || dir ==DMA_BIDIRECTIONAL )) -swiotlb_bounce (orig_addr, tlb_addr, size,DMA_TO_DEVICE ); +swiotlb_bounce (orig_addr, tlb_addr, mapping_size,DMA_TO_DEVICE );return tlb_addr; }
@@ -571,21 +576,24 @@ phys_addr_t swiotlb_tbl_map_single(struct device *hwdev,* tlb_addr is the physical address of the bounce buffer to unmap. */ void swiotlb_tbl_unmap_single (struct device *hwdev,phys_addr_t tlb_addr, -size_t size,enum dma_data_direction dir, -unsigned long attrs) +size_t mapping_size,size_t alloc_size, +enum dma_data_direction dir,unsigned long attrs) {unsigned long flags; -int i, count, nslots =ALIGN (size,1 <<IO_TLB_SHIFT ) >>IO_TLB_SHIFT ; +int i, count, nslots =ALIGN (alloc_size,1 <<IO_TLB_SHIFT ) >>IO_TLB_SHIFT ;int index = (tlb_addr - io_tlb_start) >>IO_TLB_SHIFT ;phys_addr_t orig_addr = io_tlb_orig_addr[index]; +if (WARN_ON (mapping_size > alloc_size)) +return ; +/* * First, sync the memory before unmapping the entry */ if (orig_addr !=INVALID_PHYS_ADDR && !(attrs &DMA_ATTR_SKIP_CPU_SYNC ) && ((dir ==DMA_FROM_DEVICE ) || (dir ==DMA_BIDIRECTIONAL ))) -swiotlb_bounce (orig_addr, tlb_addr, size,DMA_FROM_DEVICE ); +swiotlb_bounce (orig_addr, tlb_addr, mapping_size,DMA_FROM_DEVICE );/* * Return the buffer to the free list by setting the corresponding
@@ -665,14 +673,14 @@ bool swiotlb_map(struct device *dev, phys_addr_t *phys, dma_addr_t *dma_addr,/* Oh well, have to allocate and map a bounce buffer. */ *phys =swiotlb_tbl_map_single (dev,__phys_to_dma (dev, io_tlb_start), - *phys, size, dir, attrs); + *phys, size, size, dir, attrs);if (*phys == (phys_addr_t )DMA_MAPPING_ERROR )return false;/* Ensure that the address returned is DMA'ble */ *dma_addr =__phys_to_dma (dev, *phys);if (unlikely (!dma_capable (dev, *dma_addr, size))) { -swiotlb_tbl_unmap_single (dev, *phys, size, dir, +swiotlb_tbl_unmap_single (dev, *phys, size, size, dir, attrs |DMA_ATTR_SKIP_CPU_SYNC );return false; }
Signature · 1 line
2.17.1
PATCH v8 3/7 swiotlb: Zero out bounce buffer for untrusted device
In reply to Lu BaoluThis is necessary to avoid exposing valid kernel data to any malicious device.
--- kernel/dma/swiotlb.c | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-)
kernel/dma/swiotlb.c +15 -1
@@ -35,6 +35,7 @@#include <linux/scatterlist.h> #include <linux/mem_encrypt.h> #include <linux/set_memory.h> +#include <linux/pci.h> #ifdef CONFIG_DEBUG_FS #include <linux/debugfs.h> #endif
@@ -458,6 +459,8 @@ phys_addr_t swiotlb_tbl_map_single(struct device *hwdev,unsigned long offset_slots;unsigned long max_slots;unsigned long tmp_io_tlb_used; +void *zero_addr; +size_t zero_size;if (no_iotlb_memory)panic ("Can not allocate SWIOTLB buffer earlier and can't now provide you with the DMA bounce buffer" );
@@ -565,9 +568,20 @@ phys_addr_t swiotlb_tbl_map_single(struct device *hwdev,*/ for (i =0 ; i < nslots; i++) io_tlb_orig_addr[index+i] = orig_addr + (i <<IO_TLB_SHIFT ); + + zero_addr =phys_to_virt (tlb_addr); + zero_size = alloc_size; +if (!(attrs &DMA_ATTR_SKIP_CPU_SYNC ) && - (dir ==DMA_TO_DEVICE || dir ==DMA_BIDIRECTIONAL )) + (dir ==DMA_TO_DEVICE || dir ==DMA_BIDIRECTIONAL )) {swiotlb_bounce (orig_addr, tlb_addr, mapping_size,DMA_TO_DEVICE ); + zero_addr += mapping_size; + zero_size -= mapping_size; + } + +/* Zero out the bounce buffer if the consumer is untrusted. */ +if (dev_is_untrusted (hwdev) && zero_size) +memset (zero_addr,0 , zero_size);return tlb_addr; }
Signature · 1 line
2.17.1
Re: [PATCH v8 3/7] swiotlb: Zero out bounce buffer for untrusted device
kernel/dma/swiotlb.c phys_addr_t swiotlb_tbl_map_single(struct device *hwdev, · line 584
Quoted 4 lines · Lu Baolu
kernel/dma/swiotlb.c +3
-0+#include <linux/pci.h> +if (dev_is_untrusted (hwdev) && zero_size) +memset (zero_addr,0 , zero_size);
As said before swiotlb must not grow pci dependencies like this. Please move the untrusted flag to struct device.
Re: [PATCH v8 3/7] swiotlb: Zero out bounce buffer for untrusted device
Hi Christoph,
Quoted 7 lines · Christoph Hellwig
kernel/dma/swiotlb.c phys_addr_t swiotlb_tbl_map_single(struct device *hwdev, · line 584
Quoted 4 lines · Lu Baolu
kernel/dma/swiotlb.c +3
-0+#include <linux/pci.h> +if (dev_is_untrusted (hwdev) && zero_size) +memset (zero_addr,0 , zero_size);As said before swiotlb must not grow pci dependencies like this.
I understand your concern. I will try to remove this dependency in the next version.
Quoted 1 line
Please move the untrusted flag to struct device.
The untrusted flag is introduced in another series. I agree that we could consider to move it to struct device, but I think making it in a separated patch looks better.
Best regards,
Lu Baolu
Re: [PATCH v8 3/7] swiotlb: Zero out bounce buffer for untrusted device
Quoted 3 lines · Lu Baolu
The untrusted flag is introduced in another series. I agree that we could consider to move it to struct device, but I think making it in a separated patch looks better.
A separate patch is of course a good idea. But it needs to happen before we can use the flag in the swiotlb code.
PATCH v8 4/7 iommu/vt-d: Check whether device requires bounce buffer
In reply to Lu BaoluThis adds a helper to check whether a device needs to use bounce buffer. It also provides a boot time option to disable the bounce buffer. Users can use this to prevent the iommu driver from using the bounce buffer for performance gain.
--- Documentation/admin-guide/kernel-parameters.txt | 5 +++++ drivers/iommu/intel-iommu.c | 6 ++++++ 2 files changed, 11 insertions(+)
Documentation/admin-guide/kernel-parameters.txt +5 -0
@@ -1732,6 +1732,11 @@ Note that using this option lowers the security provided by tboot because it makes the system vulnerable to DMA attacks. + nobounce [Default off] + Disable bounce buffer for unstrusted devices such as + the Thunderbolt devices. This will treat the untrusted + devices as the trusted ones, hence might expose security + risks of DMA attacks. intel_idle.max_cstate= [KNL,HW,ACPI,X86] 0 disables intel_idle and fall back on acpi_idle.
drivers/iommu/intel-iommu.c +6 -0
@@ -362,6 +362,7 @@ static int dmar_forcedac;static int intel_iommu_strict;static int intel_iommu_superpage =1 ;static int iommu_identity_mapping; +static int intel_no_bounce;#define IDENTMAP_ALL 1#define IDENTMAP_GFX 2
@@ -375,6 +376,8 @@ EXPORT_SYMBOL_GPL(intel_iommu_gfx_mapped);static DEFINE_SPINLOCK (device_domain_lock);static LIST_HEAD (device_domain_list); +#define device_needs_bounce (d) (!intel_no_bounce && dev_is_untrusted(d)) +/* * Iterate over elements in device_domain_list and call the specified * callback @fn against each element.
@@ -457,6 +460,9 @@ static int __init intel_iommu_setup(char *str)printk (KERN_INFO "Intel-IOMMU: not forcing on after tboot. This could expose security risk for tboot\n" ); intel_iommu_tboot_noforce =1 ; + }else if (!strncmp (str,"nobounce" ,8 )) { +pr_info ("Intel-IOMMU: No bounce buffer. This could expose security risks of DMA attacks\n" ); + intel_no_bounce =1 ; } str +=strcspn (str,"," );
Signature · 1 line
2.17.1
PATCH v8 5/7 iommu/vt-d: Don't switch off swiotlb if bounce page is used
In reply to Lu BaoluThe bounce page implementation depends on swiotlb. Hence, don't switch off swiotlb if the system has untrusted devices or could potentially be hot-added with any untrusted devices.
--- drivers/iommu/Kconfig | 1 + drivers/iommu/intel-iommu.c | 32 +++++++++++++++++--------------- 2 files changed, 18 insertions(+), 15 deletions(-)
drivers/iommu/Kconfig +1 -0
@@ -182,6 +182,7 @@ config INTEL_IOMMU select IOMMU_IOVA select NEED_DMA_MAP_STATE select DMAR_TABLE + select SWIOTLB help DMA remapping (DMAR) devices support enables independent address translations for Direct Memory Access (DMA) from devices.
drivers/iommu/intel-iommu.c +17 -15
@@ -4575,22 +4575,20 @@ const struct attribute_group *intel_iommu_groups[] = { NULL, }; -static int __init platform_optin_force_iommu (void ) +static inline bool has_untrusted_dev (void ) {struct pci_dev *pdev =NULL ; -bool has_untrusted_dev = false; -if (!dmar_platform_optin () || no_platform_optin) -return 0 ; +for_each_pci_dev (pdev) +if (pdev->untrusted) +return true; -for_each_pci_dev (pdev) { -if (pdev->untrusted) { - has_untrusted_dev = true; -break ; - } - } +return false; +} -if (!has_untrusted_dev) +static int __init platform_optin_force_iommu (void ) +{ +if (!dmar_platform_optin () || no_platform_optin || !has_untrusted_dev ())return 0 ;if (no_iommu || dmar_disabled)
@@ -4604,9 +4602,6 @@ static int __init platform_optin_force_iommu(void) iommu_identity_mapping |=IDENTMAP_ALL ; dmar_disabled =0 ; -#if defined(CONFIG_X86 ) && defined(CONFIG_SWIOTLB ) - swiotlb =0 ; -#endif no_iommu =0 ;return 1 ;
@@ -4746,7 +4741,14 @@ int __init intel_iommu_init(void)up_write (&dmar_global_lock);#if defined(CONFIG_X86 ) && defined(CONFIG_SWIOTLB ) - swiotlb =0 ; +/* +* If the system has no untrusted device or the user has decided +* to disable the bounce page mechanisms, we don't need swiotlb. +* Mark this and the pre-allocated bounce pages will be released +* later. +*/ +if (!has_untrusted_dev () || intel_no_bounce) + swiotlb =0 ;#endif dma_ops = &intel_dma_ops;
Signature · 1 line
2.17.1
PATCH v8 6/7 iommu/vt-d: Add trace events for device dma map/unmap
In reply to Lu BaoluThis adds trace support for the Intel IOMMU driver. It also declares some events which could be used to trace the events when an IOVA is being mapped or unmapped in a domain.
--- drivers/iommu/Makefile | 1 + drivers/iommu/intel-trace.c | 14 +++++ include/trace/events/intel_iommu.h | 84 ++++++++++++++++++++++++++++++ 3 files changed, 99 insertions(+) create mode 100644 drivers/iommu/intel-trace.c create mode 100644 include/trace/events/intel_iommu.h
drivers/iommu/Makefile +1 -0
@@ -17,6 +17,7 @@ obj-$(CONFIG_ARM_SMMU) += arm-smmu.o obj-$(CONFIG_ARM_SMMU_V3) += arm-smmu-v3.o obj-$(CONFIG_DMAR_TABLE) += dmar.o obj-$(CONFIG_INTEL_IOMMU) += intel-iommu.o intel-pasid.o +obj-$(CONFIG_INTEL_IOMMU) += intel-trace.o obj-$(CONFIG_INTEL_IOMMU_DEBUGFS) += intel-iommu-debugfs.o obj-$(CONFIG_INTEL_IOMMU_SVM) += intel-svm.o obj-$(CONFIG_IPMMU_VMSA) += ipmmu-vmsa.o
drivers/iommu/intel-trace.c new file +14 -0
@@ -0,0 +1,14 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Intel IOMMU trace support +* +* Copyright (C) 2019 Intel Corporation +* +* Author: Lu Baolu <[email protected]> +*/ + +#include <linux/string.h> +#include <linux/types.h> + +#define CREATE_TRACE_POINTS +#include <trace/events/intel_iommu.h>
include/trace/events/intel_iommu.h new file +84 -0
84 lines not on this page · raw message
Signature · 1 line
2.17.1
Steven Rostedt
maintainerRe: [PATCH v8 6/7] iommu/vt-d: Add trace events for device dma map/unmap
Quoted 97 lines · On Fri, 30 Aug 2019 15:17:17 +0800 Lu Baolu <[email protected]> wrote:
This adds trace support for the Intel IOMMU driver. It also declares some events which could be used to trace the events when an IOVA is being mapped or unmapped in a domain.
Cc Ashok Raj <[email protected]>Cc Jacob Pan <[email protected]>Cc Kevin Tian <[email protected]>Signed-off-by Mika Westerberg <[email protected]>Signed-off-by Lu Baolu <[email protected]>Reviewed-by Steven Rostedt (VMware) <[email protected]>--- drivers/iommu/Makefile | 1 + drivers/iommu/intel-trace.c | 14 +++++ include/trace/events/intel_iommu.h | 84 ++++++++++++++++++++++++++++++ 3 files changed, 99 insertions(+) create mode 100644 drivers/iommu/intel-trace.c create mode 100644 include/trace/events/intel_iommu.hdrivers/iommu/Makefile +1
-0@@ -17,6 +17,7 @@ obj-$(CONFIG_ARM_SMMU) += arm-smmu.o obj-$(CONFIG_ARM_SMMU_V3) += arm-smmu-v3.o obj-$(CONFIG_DMAR_TABLE) += dmar.o obj-$(CONFIG_INTEL_IOMMU) += intel-iommu.o intel-pasid.o +obj-$(CONFIG_INTEL_IOMMU) += intel-trace.o obj-$(CONFIG_INTEL_IOMMU_DEBUGFS) += intel-iommu-debugfs.o obj-$(CONFIG_INTEL_IOMMU_SVM) += intel-svm.o obj-$(CONFIG_IPMMU_VMSA) += ipmmu-vmsa.odrivers/iommu/intel-trace.c new file +14
-0@@ -0,0 +1,14 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Intel IOMMU trace support +* +* Copyright (C) 2019 Intel Corporation +* +* Author: Lu Baolu <[email protected]> +*/ + +#include <linux/string.h> +#include <linux/types.h> + +#define CREATE_TRACE_POINTS +#include <trace/events/intel_iommu.h> include/trace/events/intel_iommu.h new file +40
-0@@ -0,0 +1,84 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Intel IOMMU trace support +* +* Copyright (C) 2019 Intel Corporation +* +* Author: Lu Baolu <[email protected]> +*/ +#ifdef CONFIG_INTEL_IOMMU +#undef TRACE_SYSTEM +#define TRACE_SYSTEM intel_iommu + +#if !defined(_TRACE_INTEL_IOMMU_H) || defined(TRACE_HEADER_MULTI_READ ) +#define _TRACE_INTEL_IOMMU_H + +#include <linux/tracepoint.h> +#include <linux/intel-iommu.h> + +DECLARE_EVENT_CLASS(dma_map, + TP_PROTO(struct device *dev, dma_addr_t dev_addr, phys_addr_t phys_addr, + size_t size), + + TP_ARGS(dev, dev_addr, phys_addr, size), + + TP_STRUCT__entry( + __string(dev_name, dev_name(dev)) + __field(dma_addr_t, dev_addr) + __field(phys_addr_t, phys_addr) + __field(size_t, size) + ), + + TP_fast_assign( + __assign_str(dev_name, dev_name(dev)); + __entry->dev_addr = dev_addr; + __entry->phys_addr = phys_addr; + __entry->size = size; + ), + + TP_printk("dev=%s dev_addr=0x%llx phys_addr=0x%llx size=%zu", + __get_str(dev_name),
include/trace/events/intel_iommu.h line 50
Quoted 10 lines
include/trace/events/intel_iommu.h new file +10
-0+ (unsigned long long )__entry->dev_addr, + (unsigned long long )__entry->phys_addr, + __entry->size) +); + +DEFINE_EVENT (dma_map, bounce_map_single, + TP_PROTO(struct device *dev, dma_addr_t dev_addr, phys_addr_t phys_addr, + size_t size), +TP_ARGS (dev, dev_addr, phys_addr, size) +);
Do you plan on adding more events to these classes? This patch has two distinct DECLARE_EVENT_CLASS() calls, and each has one DEFINE_EVENT() for them.
It's fine to do this, but I'm curious to why you did not use the "TRACE_EVENT()" macro, which basically is just a single DECLARE_EVENT_CLASS() followed by a single DEFINE_EVENT(). In other words, you just open coded TRACE_EVENT().
-- Steve
Quoted 34 lines
include/trace/events/intel_iommu.h new file +34
-0+ +DECLARE_EVENT_CLASS (dma_unmap, + TP_PROTO(struct device *dev, dma_addr_t dev_addr, size_t size), + +TP_ARGS (dev, dev_addr, size), + +TP_STRUCT__entry ( + __string(dev_name, dev_name(dev)) + __field(dma_addr_t, dev_addr) +__field (size_t, size) + ), + +TP_fast_assign ( + __assign_str(dev_name, dev_name(dev)); + __entry->dev_addr = dev_addr; + __entry->size = size; + ), + +TP_printk ("dev=%s dev_addr=0x%llx size=%zu" , +__get_str (dev_name), + (unsigned long long )__entry->dev_addr, + __entry->size) +); + +DEFINE_EVENT (dma_unmap, bounce_unmap_single, + TP_PROTO(struct device *dev, dma_addr_t dev_addr, size_t size), +TP_ARGS (dev, dev_addr, size) +); + +#endif /* _TRACE_INTEL_IOMMU_H */ + +/* This part must be outside protection */ +#include <trace/define_trace.h> +#endif /* CONFIG_INTEL_IOMMU */
Re: [PATCH v8 6/7] iommu/vt-d: Add trace events for device dma map/unmap
Hi Steve,
Quoted 106 lines · Steven Rostedt
Quoted 103 lines · On Fri, 30 Aug 2019 15:17:17 +0800 Lu Baolu <[email protected]> wrote:
This adds trace support for the Intel IOMMU driver. It also declares some events which could be used to trace the events when an IOVA is being mapped or unmapped in a domain.
Cc Ashok Raj <[email protected]>Cc Jacob Pan <[email protected]>Cc Kevin Tian <[email protected]>Signed-off-by Mika Westerberg <[email protected]>Signed-off-by Lu Baolu <[email protected]>Reviewed-by Steven Rostedt (VMware) <[email protected]>--- drivers/iommu/Makefile | 1 + drivers/iommu/intel-trace.c | 14 +++++ include/trace/events/intel_iommu.h | 84 ++++++++++++++++++++++++++++++ 3 files changed, 99 insertions(+)create mode 100644
drivers/iommu/intel-trace.ccreate mode 100644include/trace/events/intel_iommu.hdrivers/iommu/Makefile +1
-0@@ -17,6 +17,7 @@ obj-$(CONFIG_ARM_SMMU) += arm-smmu.o obj-$(CONFIG_ARM_SMMU_V3) += arm-smmu-v3.o obj-$(CONFIG_DMAR_TABLE) += dmar.o obj-$(CONFIG_INTEL_IOMMU) += intel-iommu.o intel-pasid.o +obj-$(CONFIG_INTEL_IOMMU) += intel-trace.o obj-$(CONFIG_INTEL_IOMMU_DEBUGFS) += intel-iommu-debugfs.o obj-$(CONFIG_INTEL_IOMMU_SVM) += intel-svm.o obj-$(CONFIG_IPMMU_VMSA) += ipmmu-vmsa.odrivers/iommu/intel-trace.c new file +14
-0@@ -0,0 +1,14 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Intel IOMMU trace support +* +* Copyright (C) 2019 Intel Corporation +* +* Author: Lu Baolu <[email protected]> +*/ + +#include <linux/string.h> +#include <linux/types.h> + +#define CREATE_TRACE_POINTS +#include <trace/events/intel_iommu.h> include/trace/events/intel_iommu.h new file +46
-0@@ -0,0 +1,84 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Intel IOMMU trace support +* +* Copyright (C) 2019 Intel Corporation +* +* Author: Lu Baolu <[email protected]> +*/ +#ifdef CONFIG_INTEL_IOMMU +#undef TRACE_SYSTEM +#define TRACE_SYSTEM intel_iommu + +#if !defined(_TRACE_INTEL_IOMMU_H) || defined(TRACE_HEADER_MULTI_READ ) +#define _TRACE_INTEL_IOMMU_H + +#include <linux/tracepoint.h> +#include <linux/intel-iommu.h> + +DECLARE_EVENT_CLASS (dma_map, + TP_PROTO(struct device *dev, dma_addr_t dev_addr, phys_addr_t phys_addr, + size_t size), + +TP_ARGS (dev, dev_addr, phys_addr, size), + +TP_STRUCT__entry ( + __string(dev_name, dev_name(dev)) + __field(dma_addr_t, dev_addr) + __field(phys_addr_t, phys_addr) +__field (size_t, size) + ), + +TP_fast_assign ( + __assign_str(dev_name, dev_name(dev)); + __entry->dev_addr = dev_addr; + __entry->phys_addr = phys_addr; + __entry->size = size; + ), + +TP_printk ("dev=%s dev_addr=0x%llx phys_addr=0x%llx size=%zu" , +__get_str (dev_name), + (unsigned long long )__entry->dev_addr, + (unsigned long long )__entry->phys_addr, + __entry->size) +); + +DEFINE_EVENT(dma_map, bounce_map_single,
Quoted 8 lines
include/trace/events/intel_iommu.h line 50
Quoted 4 lines
include/trace/events/intel_iommu.h new file +4
-0+ TP_PROTO(struct device *dev, dma_addr_t dev_addr, phys_addr_t phys_addr, + size_t size), +TP_ARGS (dev, dev_addr, phys_addr, size) +);Do you plan on adding more events to these classes? This patch has two distinct
DECLARE_EVENT_CLASS()calls, and each has oneDEFINE_EVENT()for them.
Yes, we will add more. This patch only adds the trace events that are necessary for this patch series's development. It's easy to extend to other events.
Quoted 5 lines
It's fine to do this, but I'm curious to why you did not use the "
TRACE_EVENT()" macro, which basically is just a singleDECLARE_EVENT_CLASS()followed by a singleDEFINE_EVENT(). In other words, you just open codedTRACE_EVENT().
Fair enough.
Quoted 2 lines
-- Steve
Best regards,
Lu Baolu
Quoted 37 lines
Quoted 35 lines
include/trace/events/intel_iommu.h new file +34
-0+ +DECLARE_EVENT_CLASS (dma_unmap, + TP_PROTO(struct device *dev, dma_addr_t dev_addr, size_t size), + +TP_ARGS (dev, dev_addr, size), + +TP_STRUCT__entry ( + __string(dev_name, dev_name(dev)) + __field(dma_addr_t, dev_addr) +__field (size_t, size) + ), + +TP_fast_assign ( + __assign_str(dev_name, dev_name(dev)); + __entry->dev_addr = dev_addr; + __entry->size = size; + ), + +TP_printk ("dev=%s dev_addr=0x%llx size=%zu" , +__get_str (dev_name), + (unsigned long long )__entry->dev_addr, + __entry->size) +); + +DEFINE_EVENT (dma_unmap, bounce_unmap_single, + TP_PROTO(struct device *dev, dma_addr_t dev_addr, size_t size), +TP_ARGS (dev, dev_addr, size) +); + +#endif /* _TRACE_INTEL_IOMMU_H */ + +/* This part must be outside protection */ +#include <trace/define_trace.h> +#endif /* CONFIG_INTEL_IOMMU */
PATCH v8 7/7 iommu/vt-d: Use bounce buffer for untrusted devices
In reply to Lu BaoluThe Intel VT-d hardware uses paging for DMA remapping. The minimum mapped window is a page size. The device drivers may map buffers not filling the whole IOMMU window. This allows the device to access to possibly unrelated memory and a malicious device could exploit this to perform DMA attacks. To address this, the Intel IOMMU driver will use bounce pages for those buffers which don't fill whole IOMMU pages.
--- drivers/iommu/intel-iommu.c | 244 ++++++++++++++++++++++++++++++++++++ 1 file changed, 244 insertions(+)
drivers/iommu/intel-iommu.c +244 -0
@@ -41,9 +41,11 @@#include <linux/dma-direct.h> #include <linux/crash_dump.h> #include <linux/numa.h> +#include <linux/swiotlb.h> #include <asm/irq_remapping.h> #include <asm/cacheflush.h> #include <asm/iommu.h> +#include <trace/events/intel_iommu.h> #include "irq_remapping.h" #include "intel-pasid.h"
@@ -346,6 +348,8 @@ static int domain_detach_iommu(struct dmar_domain *domain,static bool device_is_rmrr_locked (struct device *dev);static int intel_iommu_attach_device (struct iommu_domain *domain,struct device *dev); +static phys_addr_t intel_iommu_iova_to_phys (struct iommu_domain *domain, +dma_addr_t iova);#ifdef CONFIG_INTEL_IOMMU_DEFAULT_ON int dmar_disabled =0 ;
@@ -3775,6 +3779,238 @@ static const struct dma_map_ops intel_dma_ops = { .dma_supported = dma_direct_supported, }; +static void +bounce_sync_single (struct device *dev,dma_addr_t addr,size_t size, +enum dma_data_direction dir,enum dma_sync_target target) +{ +struct dmar_domain *domain; +phys_addr_t tlb_addr; + + domain =find_domain (dev); +if (WARN_ON (!domain)) +return ; + + tlb_addr =intel_iommu_iova_to_phys (&domain->domain, addr); +if (is_swiotlb_buffer (tlb_addr)) +swiotlb_tbl_sync_single (dev, tlb_addr, size, dir, target); +} + +static dma_addr_t +bounce_map_single (struct device *dev,phys_addr_t paddr,size_t size, +enum dma_data_direction dir,unsigned long attrs, +u64 dma_mask) +{ +size_t aligned_size =ALIGN (size,VTD_PAGE_SIZE ); +struct dmar_domain *domain; +struct intel_iommu *iommu; +unsigned long iova_pfn; +unsigned long nrpages; +phys_addr_t tlb_addr; +int prot =0 ; +int ret; + + domain =find_domain (dev); +if (WARN_ON (dir ==DMA_NONE || !domain)) +return DMA_MAPPING_ERROR ; + + iommu =domain_get_iommu (domain); +if (WARN_ON (!iommu)) +return DMA_MAPPING_ERROR ; + + nrpages =aligned_nrpages (0 , size); + iova_pfn =intel_alloc_iova (dev, domain, +dma_to_mm_pfn (nrpages), dma_mask); +if (!iova_pfn) +return DMA_MAPPING_ERROR ; + +/* +* Check if DMAR supports zero-length reads on write only +* mappings.. +*/ +if (dir ==DMA_TO_DEVICE || dir ==DMA_BIDIRECTIONAL || + !cap_zlr (iommu->cap)) + prot |=DMA_PTE_READ ; +if (dir ==DMA_FROM_DEVICE || dir ==DMA_BIDIRECTIONAL ) + prot |=DMA_PTE_WRITE ; + +/* +* If both the physical buffer start address and size are +* page aligned, we don't need to use a bounce page. +*/ +if (!IS_ALIGNED (paddr | size,VTD_PAGE_SIZE )) { + tlb_addr =swiotlb_tbl_map_single (dev, +__phys_to_dma (dev, io_tlb_start), + paddr, size, aligned_size, dir, attrs); +if (tlb_addr ==DMA_MAPPING_ERROR ) + goto swiotlb_error; + }else { + tlb_addr = paddr; + } + + ret =domain_pfn_mapping (domain,mm_to_dma_pfn (iova_pfn), + tlb_addr >>VTD_PAGE_SHIFT , nrpages, prot); +if (ret) + goto mapping_error; + +trace_bounce_map_single (dev, iova_pfn <<PAGE_SHIFT , paddr, size); + +return (phys_addr_t )iova_pfn <<PAGE_SHIFT ; + +mapping_error: +if (is_swiotlb_buffer (tlb_addr)) +swiotlb_tbl_unmap_single (dev, tlb_addr, size, + aligned_size, dir, attrs); +swiotlb_error: +free_iova_fast (&domain->iovad, iova_pfn,dma_to_mm_pfn (nrpages)); +dev_err (dev,"Device bounce map: %zx@%llx dir %d --- failed\n" , + size, (unsigned long long )paddr, dir); + +return DMA_MAPPING_ERROR ; +} + +static void +bounce_unmap_single (struct device *dev,dma_addr_t dev_addr,size_t size, +enum dma_data_direction dir,unsigned long attrs) +{ +size_t aligned_size =ALIGN (size,VTD_PAGE_SIZE ); +struct dmar_domain *domain; +phys_addr_t tlb_addr; + + domain =find_domain (dev); +if (WARN_ON (!domain)) +return ; + + tlb_addr =intel_iommu_iova_to_phys (&domain->domain, dev_addr); +if (WARN_ON (!tlb_addr)) +return ; + +intel_unmap (dev, dev_addr, size); +if (is_swiotlb_buffer (tlb_addr)) +swiotlb_tbl_unmap_single (dev, tlb_addr, size, + aligned_size, dir, attrs); + +trace_bounce_unmap_single (dev, dev_addr, size); +} + +static dma_addr_t +bounce_map_page (struct device *dev,struct page *page,unsigned long offset, +size_t size,enum dma_data_direction dir,unsigned long attrs) +{ +return bounce_map_single (dev,page_to_phys (page) + offset, + size, dir, attrs, *dev->dma_mask); +} + +static dma_addr_t +bounce_map_resource (struct device *dev,phys_addr_t phys_addr,size_t size, +enum dma_data_direction dir,unsigned long attrs) +{ +return bounce_map_single (dev, phys_addr, size, + dir, attrs, *dev->dma_mask); +} + +static void +bounce_unmap_page (struct device *dev,dma_addr_t dev_addr,size_t size, +enum dma_data_direction dir,unsigned long attrs) +{ +bounce_unmap_single (dev, dev_addr, size, dir, attrs); +} + +static void +bounce_unmap_resource (struct device *dev,dma_addr_t dev_addr,size_t size, +enum dma_data_direction dir,unsigned long attrs) +{ +bounce_unmap_single (dev, dev_addr, size, dir, attrs); +} + +static void +bounce_unmap_sg (struct device *dev,struct scatterlist *sglist,int nelems, +enum dma_data_direction dir,unsigned long attrs) +{ +struct scatterlist *sg; +int i; + +for_each_sg (sglist, sg, nelems, i) +bounce_unmap_page (dev, sg->dma_address, +sg_dma_len (sg), dir, attrs); +} + +static int +bounce_map_sg (struct device *dev,struct scatterlist *sglist,int nelems, +enum dma_data_direction dir,unsigned long attrs) +{ +int i; +struct scatterlist *sg; + +for_each_sg (sglist, sg, nelems, i) { + sg->dma_address =bounce_map_page (dev,sg_page (sg), + sg->offset, sg->length, + dir, attrs); +if (sg->dma_address ==DMA_MAPPING_ERROR ) + goto out_unmap; +sg_dma_len (sg) = sg->length; + } + +return nelems; + +out_unmap: +bounce_unmap_sg (dev, sglist, i, dir, attrs |DMA_ATTR_SKIP_CPU_SYNC ); +return 0 ; +} + +static void +bounce_sync_single_for_cpu (struct device *dev,dma_addr_t addr, +size_t size,enum dma_data_direction dir) +{ +bounce_sync_single (dev, addr, size, dir,SYNC_FOR_CPU ); +} + +static void +bounce_sync_single_for_device (struct device *dev,dma_addr_t addr, +size_t size,enum dma_data_direction dir) +{ +bounce_sync_single (dev, addr, size, dir,SYNC_FOR_DEVICE ); +} + +static void +bounce_sync_sg_for_cpu (struct device *dev,struct scatterlist *sglist, +int nelems,enum dma_data_direction dir) +{ +struct scatterlist *sg; +int i; + +for_each_sg (sglist, sg, nelems, i) +bounce_sync_single (dev,sg_dma_address (sg), +sg_dma_len (sg), dir,SYNC_FOR_CPU ); +} + +static void +bounce_sync_sg_for_device (struct device *dev,struct scatterlist *sglist, +int nelems,enum dma_data_direction dir) +{ +struct scatterlist *sg; +int i; + +for_each_sg (sglist, sg, nelems, i) +bounce_sync_single (dev,sg_dma_address (sg), +sg_dma_len (sg), dir,SYNC_FOR_DEVICE ); +} + +static const struct dma_map_ops bounce_dma_ops = { + .alloc = intel_alloc_coherent, + .free = intel_free_coherent, + .map_sg = bounce_map_sg, + .unmap_sg = bounce_unmap_sg, + .map_page = bounce_map_page, + .unmap_page = bounce_unmap_page, + .sync_single_for_cpu = bounce_sync_single_for_cpu, + .sync_single_for_device = bounce_sync_single_for_device, + .sync_sg_for_cpu = bounce_sync_sg_for_cpu, + .sync_sg_for_device = bounce_sync_sg_for_device, + .map_resource = bounce_map_resource, + .unmap_resource = bounce_unmap_resource, + .dma_supported = dma_direct_supported, +}; +static inline int iommu_domain_cache_init (void ) {int ret =0 ;
@@ -5368,6 +5604,11 @@ static int intel_iommu_add_device(struct device *dev) } } +if (device_needs_bounce (dev)) { +dev_info (dev,"Use Intel IOMMU bounce page dma_ops\n" ); +set_dma_ops (dev, &bounce_dma_ops); + } +return 0 ; }
@@ -5385,6 +5626,9 @@ static void intel_iommu_remove_device(struct device *dev)iommu_group_remove_device (dev);iommu_device_unlink (&iommu->iommu, dev); + +if (device_needs_bounce (dev)) +set_dma_ops (dev,NULL ); } static void intel_iommu_get_resv_regions(struct device *device,
Signature · 1 line
2.17.1
RE: [PATCH v8 7/7] iommu/vt-d: Use bounce buffer for untrusted devices
From: Lu Baolu
Quoted 10 lines
Sent: 30 August 2019 08:17
The Intel VT-d hardware uses paging for DMA remapping. The minimum mapped window is a page size. The device drivers may map buffers not filling the whole IOMMU window. This allows the device to access to possibly unrelated memory and a malicious device could exploit this to perform DMA attacks. To address this, the Intel IOMMU driver will use bounce pages for those buffers which don't fill whole IOMMU pages.
Won't this completely kill performance?
I'd expect to see something for dma_alloc_coherent() (etc) that tries to give the driver page sized buffers.
Either that or the driver could allocate page sized buffers even though it only passes fragments of these buffers to the dma functions (to avoid excessive cache invalidates).
Since you have to trust the driver, why not actually trust it?
David
-
Registered Address Lakeside, Bramley Road, Mount Farm, Milton Keynes, MK1 1PT, UK Registration No: 1397386 (Wales)
Robin Murphy
reviewerRe: [PATCH v8 7/7] iommu/vt-d: Use bounce buffer for untrusted devices
Quoted 12 lines · David Laight
From: Lu Baolu
Quoted 10 lines
Sent: 30 August 2019 08:17
The Intel VT-d hardware uses paging for DMA remapping. The minimum mapped window is a page size. The device drivers may map buffers not filling the whole IOMMU window. This allows the device to access to possibly unrelated memory and a malicious device could exploit this to perform DMA attacks. To address this, the Intel IOMMU driver will use bounce pages for those buffers which don't fill whole IOMMU pages.
Quoted 1 line
Won't this completely kill performance?
Yes it will.
Though hopefully by now we're all well aware that speed and security being inversely proportional is the universal truth of modern computing.
Quoted 2 lines
I'd expect to see something for
dma_alloc_coherent()(etc) that tries to give the driver page sized buffers.
Coherent DMA already works in PAGE_SIZE units under the covers (at least in the DMA API implementations relevant here) - that's not an issue. The problem is streaming DMA, where we have to give the device access to, say, some pre-existing 64-byte data packet, from right in the middle of who knows what else. Since we do not necessarily have control over the who knows what else, the only universally-practical way to isolate the DMA data is to copy it away to some safe sanitised page which we *do* control, and make the actual DMA accesses target that.
Quoted 3 lines
Either that or the driver could allocate page sized buffers even though it only passes fragments of these buffers to the dma functions (to avoid excessive cache invalidates).
Where, since we can't easily second-guess users' systems, "the driver" turns out to be every DMA-capable driver, every subsystem-level buffer manager, every userspace application which could possibly make use of some kind of zero-copy I/O call...
Compared to a single effectively-transparent implementation in a single place at the lowest level with a single switch for the user to turn it on or off depending on how security-critical their particular system is, I know which approach I'd rather review, maintain and rely on.
Robin.
Quoted 8 lines
Since you have to trust the driver, why not actually trust it?
David
-
Registered Address Lakeside, Bramley Road, Mount Farm, Milton Keynes, MK1 1PT, UK Registration No: 1397386 (Wales)
Re: [PATCH v8 7/7] iommu/vt-d: Use bounce buffer for untrusted devices
In reply to David LaightHi David,
Quoted 12 lines · David Laight
From: Lu Baolu
Quoted 10 lines
Sent: 30 August 2019 08:17
The Intel VT-d hardware uses paging for DMA remapping. The minimum mapped window is a page size. The device drivers may map buffers not filling the whole IOMMU window. This allows the device to access to possibly unrelated memory and a malicious device could exploit this to perform DMA attacks. To address this, the Intel IOMMU driver will use bounce pages for those buffers which don't fill whole IOMMU pages.
Quoted 4 lines
Won't this completely kill performance?
I'd expect to see something for
dma_alloc_coherent()(etc) that tries to give the driver page sized buffers.
Bounce page won't be used if driver request page sized buffers.
Quoted 4 lines
Either that or the driver could allocate page sized buffers even though it only passes fragments of these buffers to the dma functions (to avoid excessive cache invalidates).
Yes, agreed. One possible solution is to add a dma attribution and the device driver could hint that the buffer under mapping is part of a page sized buffer and iommu driver don't need to use bounce buffer for it. This is in the todo list. We need to figure out which device driver really needs this.
Quoted 3 lines
Since you have to trust the driver, why not actually trust it?
In thunderbolt case, we trust driver, but we don't trust the hot-added devices.
Best regards,
Baolu