lkml.org 
[lkml]   [2022]   [Mar]   [14]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 5.16 100/121] swiotlb: rework "fix info leak with DMA_FROM_DEVICE"
    Date
    From: Halil Pasic <pasic@linux.ibm.com>

    commit aa6f8dcbab473f3a3c7454b74caa46d36cdc5d13 upstream.

    Unfortunately, we ended up merging an old version of the patch "fix info
    leak with DMA_FROM_DEVICE" instead of merging the latest one. Christoph
    (the swiotlb maintainer), he asked me to create an incremental fix
    (after I have pointed this out the mix up, and asked him for guidance).
    So here we go.

    The main differences between what we got and what was agreed are:
    * swiotlb_sync_single_for_device is also required to do an extra bounce
    * We decided not to introduce DMA_ATTR_OVERWRITE until we have exploiters
    * The implantation of DMA_ATTR_OVERWRITE is flawed: DMA_ATTR_OVERWRITE
    must take precedence over DMA_ATTR_SKIP_CPU_SYNC

    Thus this patch removes DMA_ATTR_OVERWRITE, and makes
    swiotlb_sync_single_for_device() bounce unconditionally (that is, also
    when dir == DMA_TO_DEVICE) in order do avoid synchronising back stale
    data from the swiotlb buffer.

    Let me note, that if the size used with dma_sync_* API is less than the
    size used with dma_[un]map_*, under certain circumstances we may still
    end up with swiotlb not being transparent. In that sense, this is no
    perfect fix either.

    To get this bullet proof, we would have to bounce the entire
    mapping/bounce buffer. For that we would have to figure out the starting
    address, and the size of the mapping in
    swiotlb_sync_single_for_device(). While this does seem possible, there
    seems to be no firm consensus on how things are supposed to work.

    Signed-off-by: Halil Pasic <pasic@linux.ibm.com>
    Fixes: ddbd89deb7d3 ("swiotlb: fix info leak with DMA_FROM_DEVICE")
    Cc: stable@vger.kernel.org
    Reviewed-by: Christoph Hellwig <hch@lst.de>
    Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
    Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
    ---
    Documentation/core-api/dma-attributes.rst | 8 --------
    include/linux/dma-mapping.h | 8 --------
    kernel/dma/swiotlb.c | 23 +++++++++++++++--------
    3 files changed, 15 insertions(+), 24 deletions(-)

    --- a/Documentation/core-api/dma-attributes.rst
    +++ b/Documentation/core-api/dma-attributes.rst
    @@ -130,11 +130,3 @@ accesses to DMA buffers in both privileg
    subsystem that the buffer is fully accessible at the elevated privilege
    level (and ideally inaccessible or at least read-only at the
    lesser-privileged levels).
    -
    -DMA_ATTR_OVERWRITE
    -------------------
    -
    -This is a hint to the DMA-mapping subsystem that the device is expected to
    -overwrite the entire mapped size, thus the caller does not require any of the
    -previous buffer contents to be preserved. This allows bounce-buffering
    -implementations to optimise DMA_FROM_DEVICE transfers.
    --- a/include/linux/dma-mapping.h
    +++ b/include/linux/dma-mapping.h
    @@ -62,14 +62,6 @@
    #define DMA_ATTR_PRIVILEGED (1UL << 9)

    /*
    - * This is a hint to the DMA-mapping subsystem that the device is expected
    - * to overwrite the entire mapped size, thus the caller does not require any
    - * of the previous buffer contents to be preserved. This allows
    - * bounce-buffering implementations to optimise DMA_FROM_DEVICE transfers.
    - */
    -#define DMA_ATTR_OVERWRITE (1UL << 10)
    -
    -/*
    * A dma_addr_t can hold any valid DMA or bus address for the platform. It can
    * be given to a device to use as a DMA source or target. It is specific to a
    * given device and there may be a translation between the CPU physical address
    --- a/kernel/dma/swiotlb.c
    +++ b/kernel/dma/swiotlb.c
    @@ -581,10 +581,14 @@ phys_addr_t swiotlb_tbl_map_single(struc
    for (i = 0; i < nr_slots(alloc_size + offset); i++)
    mem->slots[index + i].orig_addr = slot_addr(orig_addr, i);
    tlb_addr = slot_addr(mem->start, index) + offset;
    - if (!(attrs & DMA_ATTR_SKIP_CPU_SYNC) &&
    - (!(attrs & DMA_ATTR_OVERWRITE) || dir == DMA_TO_DEVICE ||
    - dir == DMA_BIDIRECTIONAL))
    - swiotlb_bounce(dev, tlb_addr, mapping_size, DMA_TO_DEVICE);
    + /*
    + * When dir == DMA_FROM_DEVICE we could omit the copy from the orig
    + * to the tlb buffer, if we knew for sure the device will
    + * overwirte the entire current content. But we don't. Thus
    + * unconditional bounce may prevent leaking swiotlb content (i.e.
    + * kernel memory) to user-space.
    + */
    + swiotlb_bounce(dev, tlb_addr, mapping_size, DMA_TO_DEVICE);
    return tlb_addr;
    }

    @@ -651,10 +655,13 @@ void swiotlb_tbl_unmap_single(struct dev
    void swiotlb_sync_single_for_device(struct device *dev, phys_addr_t tlb_addr,
    size_t size, enum dma_data_direction dir)
    {
    - if (dir == DMA_TO_DEVICE || dir == DMA_BIDIRECTIONAL)
    - swiotlb_bounce(dev, tlb_addr, size, DMA_TO_DEVICE);
    - else
    - BUG_ON(dir != DMA_FROM_DEVICE);
    + /*
    + * Unconditional bounce is necessary to avoid corruption on
    + * sync_*_for_cpu or dma_ummap_* when the device didn't overwrite
    + * the whole lengt of the bounce buffer.
    + */
    + swiotlb_bounce(dev, tlb_addr, size, DMA_TO_DEVICE);
    + BUG_ON(!valid_dma_direction(dir));
    }

    void swiotlb_sync_single_for_cpu(struct device *dev, phys_addr_t tlb_addr,

    \
     
     \ /
      Last update: 2022-03-14 13:40    [W:3.451 / U:0.100 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site