Index: lib/sanitizer_common/sanitizer_common.h =================================================================== --- lib/sanitizer_common/sanitizer_common.h +++ lib/sanitizer_common/sanitizer_common.h @@ -128,6 +128,20 @@ void RunMallocHooks(const void *ptr, uptr size); void RunFreeHooks(const void *ptr); +class ReservedAddressRange { + public: + uptr Init(uptr size, const char *name = nullptr, uptr fixed_addr = 0); + uptr Map(uptr fixed_addr, uptr size, bool tolerate_enomem = false); + void Unmap(uptr addr, uptr size); + const void *base() { return base_; } + const uptr size() { return size_; } + + private: + void* base_; + uptr size_; + const char* name_; +}; + typedef void (*fill_profile_f)(uptr start, uptr rss, bool file, /*out*/uptr *stats, uptr stats_size); Index: lib/sanitizer_common/sanitizer_fuchsia.cc =================================================================== --- lib/sanitizer_common/sanitizer_fuchsia.cc +++ lib/sanitizer_common/sanitizer_fuchsia.cc @@ -236,6 +236,32 @@ return DoAnonymousMmapOrDie(size, mem_type, false, false); } +uptr ReservedAddressRange::Init(uptr init_size, const char* name, + uptr fixed_addr) { + base_ = MmapNoAccess(init_size); + size_ = init_size; + name_ = name; + return reinterpret_cast(base_); +} + +// Uses fixed_addr for now. +// Will use offset instead once we've implemented this function for real. +uptr ReservedAddressRange::Map(uptr fixed_addr, uptr map_size, + bool tolerate_enomem) { + return reinterpret_cast(MmapFixedOrDie(fixed_addr, map_size)); +} + +void ReservedAddressRange::Unmap(uptr addr, uptr size) { + void* addr_as_void = reinterpret_cast(addr); + uptr base_as_uptr = reinterpret_cast(base_); + // Only unmap at the beginning or end of the range. + CHECK_EQ((addr_as_void == base_) || (addr + size == base_as_uptr + size_), + true); + // Detect overflows. + CHECK_LE(size, (base_as_uptr + size_) - addr); + UnmapOrDie(reinterpret_cast(addr), size); +} + // MmapNoAccess and MmapFixedOrDie are used only by sanitizer_allocator. // Instead of doing exactly what they say, we make MmapNoAccess actually // just allocate a VMAR to reserve the address space. Then MmapFixedOrDie Index: lib/sanitizer_common/sanitizer_posix_libcdep.cc =================================================================== --- lib/sanitizer_common/sanitizer_posix_libcdep.cc +++ lib/sanitizer_common/sanitizer_posix_libcdep.cc @@ -337,6 +337,38 @@ return (void *)p; } +uptr ReservedAddressRange::Init(uptr size, const char *name, uptr fixed_addr) { + if (fixed_addr) { + base_ = MmapFixedNoAccess(fixed_addr, size, name); + } else { + base_ = MmapNoAccess(size); + } + size_ = size; + name_ = name; + return reinterpret_cast(base_); +} + +// Uses fixed_addr for now. +// Will use offset instead once we've implemented this function for real. +uptr ReservedAddressRange::Map(uptr fixed_addr, uptr size, + bool tolerate_enomem) { + if (tolerate_enomem) { + return reinterpret_cast(MmapFixedOrDieOnFatalError(fixed_addr, size)); + } + return reinterpret_cast(MmapFixedOrDie(fixed_addr, size)); +} + +void ReservedAddressRange::Unmap(uptr addr, uptr size) { + void* addr_as_void = reinterpret_cast(addr); + uptr base_as_uptr = reinterpret_cast(base_); + // Only unmap at the beginning or end of the range. + CHECK_EQ((addr_as_void == base_) || (addr + size == base_as_uptr + size_), + true); + // Detect overflows. + CHECK_LE(size, (base_as_uptr + size_) - addr); + UnmapOrDie(reinterpret_cast(addr), size); +} + void *MmapFixedNoAccess(uptr fixed_addr, uptr size, const char *name) { int fd = name ? GetNamedMappingFd(name, size) : -1; unsigned flags = MAP_PRIVATE | MAP_FIXED | MAP_NORESERVE; Index: lib/sanitizer_common/sanitizer_win.cc =================================================================== --- lib/sanitizer_common/sanitizer_win.cc +++ lib/sanitizer_common/sanitizer_win.cc @@ -235,6 +235,26 @@ return p; } +// Uses fixed_addr for now. +// Will use offset instead once we've implemented this function for real. +uptr ReservedAddressRange::Map(uptr fixed_addr, uptr size, + bool tolerate_enomem) { + if (tolerate_enomem) { + return reinterpret_cast(MmapFixedOrDieOnFatalError(fixed_addr, size)); + } + return reinterpret_cast(MmapFixedOrDie(uptr fixed_addr, uptr size)); +} + +void ReservedAddressRange::Unmap(uptr addr, uptr size) { + void* addr_as_void = reinterpret_cast(addr); + uptr base_as_uptr = reinterpret_cast(base_); + // Only unmap if it covers the entire range. + CHECK_EQ((addr_as_void == base_) && (size == size_), true); + // Detect overflows. + CHECK_LE(size, (base_as_uptr + size_) - addr); + UnmapOrDie(reinterpret_cast(addr), size); +} + void *MmapFixedOrDieOnFatalError(uptr fixed_addr, uptr size) { void *p = VirtualAlloc((LPVOID)fixed_addr, size, MEM_COMMIT, PAGE_READWRITE); @@ -252,6 +272,18 @@ return MmapOrDie(size, mem_type); } +uptr ReservedAddressRange::Init(uptr size, const char *name, uptr fixed_addr) { + if (fixed_addr) { + base_ = MmapFixedNoAccess(fixed_addr, size, name); + } else { + base_ = MmapNoAccess(size); + } + size_ = size; + name_ = name; + return reinterpret_cast(base_); +} + + void *MmapFixedNoAccess(uptr fixed_addr, uptr size, const char *name) { (void)name; // unsupported void *res = VirtualAlloc((LPVOID)fixed_addr, size, Index: lib/sanitizer_common/tests/sanitizer_common_test.cc =================================================================== --- lib/sanitizer_common/tests/sanitizer_common_test.cc +++ lib/sanitizer_common/tests/sanitizer_common_test.cc @@ -11,6 +11,9 @@ // //===----------------------------------------------------------------------===// #include +#if !SANITIZER_WINDOWS +#include +#endif #include "sanitizer_common/sanitizer_allocator_internal.h" #include "sanitizer_common/sanitizer_common.h" @@ -320,4 +323,89 @@ } #endif +TEST(SanitizerCommon, ReservedAddressRangeInit) { + uptr init_size = 0xffff; + ReservedAddressRange address_range; + uptr res = address_range.Init(init_size); + CHECK_NE(res, (void*)-1); + UnmapOrDie((void*)res, init_size); + // Should be able to map into the same space now. + ReservedAddressRange address_range2; + uptr res2 = address_range2.Init(init_size, nullptr, res); + CHECK_EQ(res, res2); + + // TODO(flowerhack): Once this is switched to the "real" implementation + // (rather than passing through to MmapNoAccess*), enforce and test "no + // double initializations allowed" +} + +TEST(SanitizerCommon, ReservedAddressRangeMap) { + constexpr uptr init_size = 0xffff; + ReservedAddressRange address_range; + uptr res = address_range.Init(init_size); + CHECK_NE(res, (void*) -1); + + // Valid mappings should succeed. + CHECK_EQ(res, address_range.Map(res, init_size)); + + // Valid mappings should be readable. + unsigned char buffer[init_size]; + memcpy(buffer, &res, sizeof(buffer)); + + // Invalid mappings should fail. + EXPECT_DEATH(address_range.Map(res, 0), ".*"); + + // TODO(flowerhack): Once this is switched to the "real" implementation, make + // sure you can only mmap into offsets in the Init range. +} + +TEST(SanitizerCommon, ReservedAddressRangeUnmap) { + uptr PageSize = GetPageSizeCached(); + uptr init_size = PageSize * 4; + ReservedAddressRange address_range; + uptr base_addr = address_range.Init(init_size); + CHECK_NE(base_addr, (void*)-1); + CHECK_EQ(base_addr, address_range.Map(base_addr, init_size)); + + // Unmapping the entire range should succeed. + #if !SANITIZER_WINDOWS + EXPECT_EQ(msync(reinterpret_cast(base_addr), PageSize * 4, + MS_ASYNC), 0); + #else + EXPECT_NE(FlushViewOfFile(reinterpret_cast(base_addr), PageSize * 4), + 0); + #endif + address_range.Unmap(base_addr, PageSize * 4); + #if !SANITIZER_WINDOWS + EXPECT_EQ(msync(reinterpret_cast(base_addr), PageSize * 4, + MS_ASYNC), -1); + #else + EXPECT_EQ(FlushViewOfFile(reinterpret_cast(base_addr), PageSize * 4), + 0); + #endif + + // Remap that range in. + CHECK_EQ(base_addr, address_range.Map(base_addr, init_size)); + + // Windows doesn't allow partial unmappings. + #if !SANITIZER_WINDOWS + + // Unmapping at the beginning should succeed. + EXPECT_EQ(msync(reinterpret_cast(base_addr), PageSize, MS_ASYNC), 0); + address_range.Unmap(base_addr, PageSize); + EXPECT_EQ(msync(reinterpret_cast(base_addr), PageSize, MS_ASYNC), -1); + + // Unmapping at the end should succeed. + uptr new_start = reinterpret_cast(address_range.base()) + + address_range.size() - PageSize; + EXPECT_EQ(msync(reinterpret_cast(new_start), PageSize, MS_ASYNC), 0); + address_range.Unmap(new_start, PageSize); + EXPECT_EQ(msync(reinterpret_cast(new_start), PageSize, MS_ASYNC), -1); + + #endif + + // Unmapping in the middle of the ReservedAddressRange should fail. + EXPECT_DEATH(address_range.Unmap(base_addr + 0xf, 0xff), ".*"); +} + } // namespace __sanitizer