tree 1a83148c8d955087a2c1a218c85aed10e906426c
parent 3cedd7d75f9ac397d20efa80a3d5f74bb52befcd
author Kirti Wankhede <kwankhede@nvidia.com> 1481048814 +0530
committer Alex Williamson <alex.williamson@redhat.com> 1481052484 -0700

vfio iommu type1: Fix size argument to vfio_find_dma() during DMA UNMAP.

Passing zero for the size to vfio_find_dma() isn't compatible with
matching the start address of an existing vfio_dma. Doing so triggers a
corner case. In vfio_find_dma(), when the start address is equal to
dma->iova and size is 0, check for the end of search range makes it to
take wrong side of RB-tree. That fails the search even though the address
is present in mapped dma ranges. Due to this, in vfio_dma_do_unmap(),
while checking boundary conditions, size should be set to 1 for verifying
start address of unmap range.
vfio_find_dma() is also used to verify last address in unmap range with
size = 0, but in that case address to be searched is calculated with
start + size - 1 and so it works correctly.

Signed-off-by: Kirti Wankhede <kwankhede@nvidia.com>
Signed-off-by: Neo Jia <cjia@nvidia.com>
[aw: changelog tweak]
Signed-off-by: Alex Williamson <alex.williamson@redhat.com>
