Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'for-linus-iommufd' of git://git.kernel.org/pub/scm/linux/kernel/git/jgg/iommufd
Pull iommufd fixes from Jason Gunthorpe:
"Some changes to the userspace selftest framework cause the iommufd
tests to start failing. This turned out to be bugs in the iommufd side
that were just getting uncovered.
- Deal with MAP_HUGETLB mmaping more than requested even when in
MAP_FIXED mode
- Fixup missing error flow cleanup in the test
- Check that the memory allocations suceeded
- Suppress some bogus gcc 'may be used uninitialized' warnings"
* tag 'for-linus-iommufd' of git://git.kernel.org/pub/scm/linux/kernel/git/jgg/iommufd:
iommufd/selftest: Fix build warnings due to uninitialized mfd
iommufd/selftest: Add asserts testing global mfd
iommufd/selftest: Add missing close(mfd) in memfd_mmap()
iommufd/selftest: Fix iommufd_dirty_tracking with large hugepage sizes
+36
-13
+29
-11
tools/testing/selftests/iommu/iommufd.c
+29
-11
tools/testing/selftests/iommu/iommufd.c
···
54
54
55
55
mfd_buffer = memfd_mmap(BUFFER_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED,
56
56
&mfd);
57
+
assert(mfd_buffer != MAP_FAILED);
58
+
assert(mfd > 0);
57
59
}
58
60
59
61
FIXTURE(iommufd)
···
1748
1746
unsigned int end;
1749
1747
uint8_t *buf;
1750
1748
int prot = PROT_READ | PROT_WRITE;
1751
-
int mfd;
1749
+
int mfd = -1;
1752
1750
1753
1751
if (variant->file)
1754
1752
buf = memfd_mmap(buf_size, prot, MAP_SHARED, &mfd);
1755
1753
else
1756
1754
buf = mmap(0, buf_size, prot, self->mmap_flags, -1, 0);
1757
1755
ASSERT_NE(MAP_FAILED, buf);
1756
+
if (variant->file)
1757
+
ASSERT_GT(mfd, 0);
1758
1758
check_refs(buf, buf_size, 0);
1759
1759
1760
1760
/*
···
1802
1798
unsigned int end;
1803
1799
uint8_t *buf;
1804
1800
int prot = PROT_READ | PROT_WRITE;
1805
-
int mfd;
1801
+
int mfd = -1;
1806
1802
1807
1803
if (variant->file)
1808
1804
buf = memfd_mmap(buf_size, prot, MAP_SHARED, &mfd);
1809
1805
else
1810
1806
buf = mmap(0, buf_size, prot, self->mmap_flags, -1, 0);
1811
1807
ASSERT_NE(MAP_FAILED, buf);
1808
+
if (variant->file)
1809
+
ASSERT_GT(mfd, 0);
1812
1810
check_refs(buf, buf_size, 0);
1813
1811
1814
1812
/*
···
2014
2008
2015
2009
FIXTURE_SETUP(iommufd_dirty_tracking)
2016
2010
{
2011
+
size_t mmap_buffer_size;
2017
2012
unsigned long size;
2018
2013
int mmap_flags;
2019
2014
void *vrc;
···
2029
2022
self->fd = open("/dev/iommu", O_RDWR);
2030
2023
ASSERT_NE(-1, self->fd);
2031
2024
2032
-
rc = posix_memalign(&self->buffer, HUGEPAGE_SIZE, variant->buffer_size);
2033
-
if (rc || !self->buffer) {
2034
-
SKIP(return, "Skipping buffer_size=%lu due to errno=%d",
2035
-
variant->buffer_size, rc);
2036
-
}
2037
-
2038
2025
mmap_flags = MAP_SHARED | MAP_ANONYMOUS | MAP_FIXED;
2026
+
mmap_buffer_size = variant->buffer_size;
2039
2027
if (variant->hugepages) {
2040
2028
/*
2041
2029
* MAP_POPULATE will cause the kernel to fail mmap if THPs are
2042
2030
* not available.
2043
2031
*/
2044
2032
mmap_flags |= MAP_HUGETLB | MAP_POPULATE;
2033
+
2034
+
/*
2035
+
* Allocation must be aligned to the HUGEPAGE_SIZE, because the
2036
+
* following mmap() will automatically align the length to be a
2037
+
* multiple of the underlying huge page size. Failing to do the
2038
+
* same at this allocation will result in a memory overwrite by
2039
+
* the mmap().
2040
+
*/
2041
+
if (mmap_buffer_size < HUGEPAGE_SIZE)
2042
+
mmap_buffer_size = HUGEPAGE_SIZE;
2043
+
}
2044
+
2045
+
rc = posix_memalign(&self->buffer, HUGEPAGE_SIZE, mmap_buffer_size);
2046
+
if (rc || !self->buffer) {
2047
+
SKIP(return, "Skipping buffer_size=%lu due to errno=%d",
2048
+
mmap_buffer_size, rc);
2045
2049
}
2046
2050
assert((uintptr_t)self->buffer % HUGEPAGE_SIZE == 0);
2047
-
vrc = mmap(self->buffer, variant->buffer_size, PROT_READ | PROT_WRITE,
2051
+
vrc = mmap(self->buffer, mmap_buffer_size, PROT_READ | PROT_WRITE,
2048
2052
mmap_flags, -1, 0);
2049
2053
assert(vrc == self->buffer);
2050
2054
···
2084
2066
2085
2067
FIXTURE_TEARDOWN(iommufd_dirty_tracking)
2086
2068
{
2087
-
munmap(self->buffer, variant->buffer_size);
2088
-
munmap(self->bitmap, DIV_ROUND_UP(self->bitmap_size, BITS_PER_BYTE));
2069
+
free(self->buffer);
2070
+
free(self->bitmap);
2089
2071
teardown_iommufd(self->fd, _metadata);
2090
2072
}
2091
2073
+7
-2
tools/testing/selftests/iommu/iommufd_utils.h
+7
-2
tools/testing/selftests/iommu/iommufd_utils.h
···
60
60
{
61
61
int mfd_flags = (flags & MAP_HUGETLB) ? MFD_HUGETLB : 0;
62
62
int mfd = memfd_create("buffer", mfd_flags);
63
+
void *buf = MAP_FAILED;
63
64
64
65
if (mfd <= 0)
65
66
return MAP_FAILED;
66
67
if (ftruncate(mfd, length))
67
-
return MAP_FAILED;
68
+
goto out;
68
69
*mfd_p = mfd;
69
-
return mmap(0, length, prot, flags, mfd, 0);
70
+
buf = mmap(0, length, prot, flags, mfd, 0);
71
+
out:
72
+
if (buf == MAP_FAILED)
73
+
close(mfd);
74
+
return buf;
70
75
}
71
76
72
77
/*