mirror of
https://github.com/chromium/crashpad.git
synced 2025-03-09 14:06:33 +00:00
1aa478d161
This change was partially scripted and partially done manually with vim regex + manually placing the deleted constructors. The script change looked for destructors in the public: section of a class, if that existed the deleted constructors would go before the destructor. For manual placement I looked for any constructor in the public: section of the corresponding class. If there wasn't one, then it would ideally have gone as the first entry except below enums, classes and typedefs. This may not have been perfect, but is hopefully good enough. Fingers crossed. #include "base/macros.h" is removed from files that don't use ignore_result, which is the only other thing defined in base/macros.h. Bug: chromium:1010217 Change-Id: I099526255a40b1ac1264904b4ece2f3f503c9418 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/3171034 Reviewed-by: Mark Mentovai <mark@chromium.org> Commit-Queue: Peter Boström <pbos@chromium.org>
423 lines
14 KiB
C++
423 lines
14 KiB
C++
// Copyright 2017 The Crashpad Authors. All rights reserved.
|
||
//
|
||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||
// you may not use this file except in compliance with the License.
|
||
// You may obtain a copy of the License at
|
||
//
|
||
// http://www.apache.org/licenses/LICENSE-2.0
|
||
//
|
||
// Unless required by applicable law or agreed to in writing, software
|
||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
// See the License for the specific language governing permissions and
|
||
// limitations under the License.
|
||
|
||
#include "util/posix/scoped_mmap.h"
|
||
|
||
#include <stdint.h>
|
||
#include <sys/types.h>
|
||
#include <unistd.h>
|
||
|
||
#include "base/cxx17_backports.h"
|
||
#include "base/numerics/safe_conversions.h"
|
||
#include "base/rand_util.h"
|
||
#include "base/strings/stringprintf.h"
|
||
#include "gtest/gtest.h"
|
||
#include "test/gtest_death.h"
|
||
|
||
namespace crashpad {
|
||
namespace test {
|
||
namespace {
|
||
|
||
bool ScopedMmapResetMmap(ScopedMmap* mapping, size_t len) {
|
||
return mapping->ResetMmap(
|
||
nullptr, len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
|
||
}
|
||
|
||
void* BareMmap(size_t len) {
|
||
return mmap(
|
||
nullptr, len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
|
||
}
|
||
|
||
// A weird class. This is used to test that memory-mapped regions are freed
|
||
// as expected by calling munmap(). This is difficult to test well because once
|
||
// a region has been unmapped, the address space it formerly occupied becomes
|
||
// eligible for reuse.
|
||
//
|
||
// The strategy taken here is that a random 64-bit cookie value is written into
|
||
// a mapped region by SetUp(). While the mapping is active, Check() should not
|
||
// crash, or for a Google Test expectation, Expected() and Observed() should not
|
||
// crash and should be equal. After the region is unmapped, Check() should
|
||
// crash, either because the region has been unmapped and the address not
|
||
// reused, the address has been reused but is protected against reading
|
||
// (unlikely), or because the address has been reused but the cookie value is no
|
||
// longer present there.
|
||
class TestCookie {
|
||
public:
|
||
// A weird constructor for a weird class. The member variable initialization
|
||
// assures that Check() won’t crash if called on an object that hasn’t had
|
||
// SetUp() called on it.
|
||
explicit TestCookie() : address_(&cookie_), cookie_(0) {}
|
||
|
||
TestCookie(const TestCookie&) = delete;
|
||
TestCookie& operator=(const TestCookie&) = delete;
|
||
|
||
~TestCookie() {}
|
||
|
||
void SetUp(uint64_t* address) {
|
||
address_ = address, cookie_ = base::RandUint64();
|
||
*address_ = cookie_;
|
||
}
|
||
|
||
uint64_t Expected() const { return cookie_; }
|
||
uint64_t Observed() const { return *address_; }
|
||
|
||
void Check() const {
|
||
if (Observed() != Expected()) {
|
||
__builtin_trap();
|
||
}
|
||
}
|
||
|
||
private:
|
||
uint64_t* address_;
|
||
uint64_t cookie_;
|
||
};
|
||
|
||
TEST(ScopedMmap, Mmap) {
|
||
TestCookie cookie;
|
||
|
||
ScopedMmap mapping;
|
||
EXPECT_FALSE(mapping.is_valid());
|
||
EXPECT_EQ(mapping.addr(), MAP_FAILED);
|
||
EXPECT_EQ(mapping.len(), 0u);
|
||
|
||
ASSERT_TRUE(mapping.Reset());
|
||
EXPECT_FALSE(mapping.is_valid());
|
||
|
||
const size_t kPageSize = base::checked_cast<size_t>(getpagesize());
|
||
ASSERT_TRUE(ScopedMmapResetMmap(&mapping, kPageSize));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_NE(mapping.addr(), MAP_FAILED);
|
||
EXPECT_EQ(mapping.len(), kPageSize);
|
||
|
||
cookie.SetUp(mapping.addr_as<uint64_t*>());
|
||
EXPECT_EQ(cookie.Observed(), cookie.Expected());
|
||
|
||
ASSERT_TRUE(mapping.Reset());
|
||
EXPECT_FALSE(mapping.is_valid());
|
||
}
|
||
|
||
TEST(ScopedMmapDeathTest, Destructor) {
|
||
TestCookie cookie;
|
||
{
|
||
ScopedMmap mapping;
|
||
|
||
const size_t kPageSize = base::checked_cast<size_t>(getpagesize());
|
||
ASSERT_TRUE(ScopedMmapResetMmap(&mapping, kPageSize));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_NE(mapping.addr(), MAP_FAILED);
|
||
EXPECT_EQ(mapping.len(), kPageSize);
|
||
|
||
cookie.SetUp(mapping.addr_as<uint64_t*>());
|
||
}
|
||
|
||
EXPECT_DEATH_CRASH(cookie.Check(), "");
|
||
}
|
||
|
||
TEST(ScopedMmapDeathTest, Reset) {
|
||
ScopedMmap mapping;
|
||
|
||
const size_t kPageSize = base::checked_cast<size_t>(getpagesize());
|
||
ASSERT_TRUE(ScopedMmapResetMmap(&mapping, kPageSize));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_NE(mapping.addr(), MAP_FAILED);
|
||
EXPECT_EQ(mapping.len(), kPageSize);
|
||
|
||
TestCookie cookie;
|
||
cookie.SetUp(mapping.addr_as<uint64_t*>());
|
||
|
||
ASSERT_TRUE(mapping.Reset());
|
||
|
||
EXPECT_DEATH_CRASH(cookie.Check(), "");
|
||
}
|
||
|
||
TEST(ScopedMmapDeathTest, ResetAddrLen_Shrink) {
|
||
ScopedMmap mapping;
|
||
|
||
// Start with three pages mapped.
|
||
const size_t kPageSize = base::checked_cast<size_t>(getpagesize());
|
||
ASSERT_TRUE(ScopedMmapResetMmap(&mapping, 3 * kPageSize));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_NE(mapping.addr(), MAP_FAILED);
|
||
EXPECT_EQ(mapping.len(), 3 * kPageSize);
|
||
|
||
TestCookie cookies[3];
|
||
for (size_t index = 0; index < base::size(cookies); ++index) {
|
||
cookies[index].SetUp(reinterpret_cast<uint64_t*>(
|
||
mapping.addr_as<uintptr_t>() + index * kPageSize));
|
||
}
|
||
|
||
// Reset to the second page. The first and third pages should be unmapped.
|
||
void* const new_addr =
|
||
reinterpret_cast<void*>(mapping.addr_as<uintptr_t>() + kPageSize);
|
||
ASSERT_TRUE(mapping.ResetAddrLen(new_addr, kPageSize));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_EQ(mapping.addr(), new_addr);
|
||
EXPECT_EQ(mapping.len(), kPageSize);
|
||
|
||
EXPECT_EQ(cookies[1].Observed(), cookies[1].Expected());
|
||
|
||
EXPECT_DEATH_CRASH(cookies[0].Check(), "");
|
||
EXPECT_DEATH_CRASH(cookies[2].Check(), "");
|
||
}
|
||
|
||
TEST(ScopedMmap, ResetAddrLen_Grow) {
|
||
// Start with three pages mapped, but ScopedMmap only aware of the the second
|
||
// page.
|
||
const size_t kPageSize = base::checked_cast<size_t>(getpagesize());
|
||
void* pages = BareMmap(3 * kPageSize);
|
||
ASSERT_NE(pages, MAP_FAILED);
|
||
|
||
ScopedMmap mapping;
|
||
void* const old_addr =
|
||
reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(pages) + kPageSize);
|
||
ASSERT_TRUE(mapping.ResetAddrLen(old_addr, kPageSize));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_EQ(mapping.addr(), old_addr);
|
||
EXPECT_EQ(mapping.len(), kPageSize);
|
||
|
||
TestCookie cookies[3];
|
||
for (size_t index = 0; index < base::size(cookies); ++index) {
|
||
cookies[index].SetUp(reinterpret_cast<uint64_t*>(
|
||
reinterpret_cast<uintptr_t>(pages) + index * kPageSize));
|
||
}
|
||
|
||
// Reset to all three pages. Nothing should be unmapped until destruction.
|
||
ASSERT_TRUE(mapping.ResetAddrLen(pages, 3 * kPageSize));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_EQ(mapping.addr(), pages);
|
||
EXPECT_EQ(mapping.len(), 3 * kPageSize);
|
||
|
||
for (size_t index = 0; index < base::size(cookies); ++index) {
|
||
SCOPED_TRACE(base::StringPrintf("index %zu", index));
|
||
EXPECT_EQ(cookies[index].Observed(), cookies[index].Expected());
|
||
}
|
||
}
|
||
|
||
TEST(ScopedMmapDeathTest, ResetAddrLen_MoveDownAndGrow) {
|
||
// Start with three pages mapped, but ScopedMmap only aware of the third page.
|
||
const size_t kPageSize = base::checked_cast<size_t>(getpagesize());
|
||
void* pages = BareMmap(3 * kPageSize);
|
||
ASSERT_NE(pages, MAP_FAILED);
|
||
|
||
ScopedMmap mapping;
|
||
void* const old_addr = reinterpret_cast<void*>(
|
||
reinterpret_cast<uintptr_t>(pages) + 2 * kPageSize);
|
||
ASSERT_TRUE(mapping.ResetAddrLen(old_addr, kPageSize));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_EQ(mapping.addr(), old_addr);
|
||
EXPECT_EQ(mapping.len(), kPageSize);
|
||
|
||
TestCookie cookies[3];
|
||
for (size_t index = 0; index < base::size(cookies); ++index) {
|
||
cookies[index].SetUp(reinterpret_cast<uint64_t*>(
|
||
reinterpret_cast<uintptr_t>(pages) + index * kPageSize));
|
||
}
|
||
|
||
// Reset to the first two pages. The third page should be unmapped.
|
||
ASSERT_TRUE(mapping.ResetAddrLen(pages, 2 * kPageSize));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_EQ(mapping.addr(), pages);
|
||
EXPECT_EQ(mapping.len(), 2 * kPageSize);
|
||
|
||
EXPECT_EQ(cookies[0].Observed(), cookies[0].Expected());
|
||
EXPECT_EQ(cookies[1].Observed(), cookies[1].Expected());
|
||
|
||
EXPECT_DEATH_CRASH(cookies[2].Check(), "");
|
||
}
|
||
|
||
TEST(ScopedMmapDeathTest, ResetAddrLen_MoveUpAndShrink) {
|
||
// Start with three pages mapped, but ScopedMmap only aware of the first two
|
||
// pages.
|
||
const size_t kPageSize = base::checked_cast<size_t>(getpagesize());
|
||
void* pages = BareMmap(3 * kPageSize);
|
||
ASSERT_NE(pages, MAP_FAILED);
|
||
|
||
ScopedMmap mapping;
|
||
ASSERT_TRUE(mapping.ResetAddrLen(pages, 2 * kPageSize));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_EQ(mapping.addr(), pages);
|
||
EXPECT_EQ(mapping.len(), 2 * kPageSize);
|
||
|
||
TestCookie cookies[3];
|
||
for (size_t index = 0; index < base::size(cookies); ++index) {
|
||
cookies[index].SetUp(reinterpret_cast<uint64_t*>(
|
||
reinterpret_cast<uintptr_t>(pages) + index * kPageSize));
|
||
}
|
||
|
||
// Reset to the third page. The first two pages should be unmapped.
|
||
void* const new_addr =
|
||
reinterpret_cast<void*>(mapping.addr_as<uintptr_t>() + 2 * kPageSize);
|
||
ASSERT_TRUE(mapping.ResetAddrLen(new_addr, kPageSize));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_EQ(mapping.addr(), new_addr);
|
||
EXPECT_EQ(mapping.len(), kPageSize);
|
||
|
||
EXPECT_EQ(cookies[2].Observed(), cookies[2].Expected());
|
||
|
||
EXPECT_DEATH_CRASH(cookies[0].Check(), "");
|
||
EXPECT_DEATH_CRASH(cookies[1].Check(), "");
|
||
}
|
||
|
||
TEST(ScopedMmapDeathTest, ResetMmap) {
|
||
ScopedMmap mapping;
|
||
|
||
// Calling ScopedMmap::ResetMmap() frees the existing mapping before
|
||
// establishing the new one, so the new one may wind up at the same address as
|
||
// the old. In fact, this is likely. Create a two-page mapping and replace it
|
||
// with a single-page mapping, so that the test can assure that the second
|
||
// page isn’t mapped after establishing the second mapping.
|
||
const size_t kPageSize = base::checked_cast<size_t>(getpagesize());
|
||
ASSERT_TRUE(ScopedMmapResetMmap(&mapping, 2 * kPageSize));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_NE(mapping.addr(), MAP_FAILED);
|
||
EXPECT_EQ(mapping.len(), 2 * kPageSize);
|
||
|
||
TestCookie cookie;
|
||
cookie.SetUp(
|
||
reinterpret_cast<uint64_t*>(mapping.addr_as<char*>() + kPageSize));
|
||
|
||
ASSERT_TRUE(ScopedMmapResetMmap(&mapping, kPageSize));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_NE(mapping.addr(), MAP_FAILED);
|
||
EXPECT_EQ(mapping.len(), kPageSize);
|
||
|
||
EXPECT_DEATH_CRASH(cookie.Check(), "");
|
||
}
|
||
|
||
TEST(ScopedMmapDeathTest, NotIntegralNumberOfPages) {
|
||
ScopedMmap mapping;
|
||
EXPECT_FALSE(mapping.is_valid());
|
||
EXPECT_EQ(mapping.addr(), MAP_FAILED);
|
||
EXPECT_EQ(mapping.len(), 0u);
|
||
|
||
ASSERT_TRUE(mapping.Reset());
|
||
EXPECT_FALSE(mapping.is_valid());
|
||
|
||
// Establishing a half-page mapping actually establishes a single page.
|
||
const size_t kPageSize = base::checked_cast<size_t>(getpagesize());
|
||
const size_t kHalfPageSize = kPageSize / 2;
|
||
ASSERT_TRUE(ScopedMmapResetMmap(&mapping, kHalfPageSize));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_NE(mapping.addr(), MAP_FAILED);
|
||
EXPECT_EQ(mapping.len(), kHalfPageSize);
|
||
|
||
TestCookie cookie;
|
||
cookie.SetUp(mapping.addr_as<uint64_t*>());
|
||
|
||
// Shrinking a one-page mapping to a half page is a no-op.
|
||
void* orig_addr = mapping.addr();
|
||
ASSERT_TRUE(mapping.ResetAddrLen(orig_addr, kHalfPageSize));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_EQ(mapping.addr(), orig_addr);
|
||
EXPECT_EQ(mapping.len(), kHalfPageSize);
|
||
|
||
EXPECT_EQ(cookie.Observed(), cookie.Expected());
|
||
|
||
// Same thing shrinking it to a single byte, or one byte less than a whole
|
||
// page.
|
||
ASSERT_TRUE(mapping.ResetAddrLen(orig_addr, 1));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_EQ(mapping.addr(), orig_addr);
|
||
EXPECT_EQ(mapping.len(), 1u);
|
||
|
||
EXPECT_EQ(cookie.Observed(), cookie.Expected());
|
||
|
||
ASSERT_TRUE(mapping.ResetAddrLen(orig_addr, kPageSize - 1));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_EQ(mapping.addr(), orig_addr);
|
||
EXPECT_EQ(mapping.len(), kPageSize - 1);
|
||
|
||
EXPECT_EQ(cookie.Observed(), cookie.Expected());
|
||
|
||
// Shrinking a two-page mapping to a half page frees the second page but
|
||
// leaves the first alone.
|
||
ASSERT_TRUE(ScopedMmapResetMmap(&mapping, 2 * kPageSize));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_NE(mapping.addr(), MAP_FAILED);
|
||
EXPECT_EQ(mapping.len(), 2 * kPageSize);
|
||
|
||
TestCookie two_cookies[2];
|
||
for (size_t index = 0; index < base::size(two_cookies); ++index) {
|
||
two_cookies[index].SetUp(reinterpret_cast<uint64_t*>(
|
||
mapping.addr_as<uintptr_t>() + index * kPageSize));
|
||
}
|
||
|
||
orig_addr = mapping.addr();
|
||
ASSERT_TRUE(mapping.ResetAddrLen(orig_addr, kHalfPageSize));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_EQ(mapping.addr(), orig_addr);
|
||
EXPECT_EQ(mapping.len(), kHalfPageSize);
|
||
|
||
EXPECT_EQ(two_cookies[0].Observed(), two_cookies[0].Expected());
|
||
EXPECT_DEATH_CRASH(two_cookies[1].Check(), "");
|
||
|
||
// Shrinking a two-page mapping to a page and a half is a no-op.
|
||
ASSERT_TRUE(ScopedMmapResetMmap(&mapping, 2 * kPageSize));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_NE(mapping.addr(), MAP_FAILED);
|
||
EXPECT_EQ(mapping.len(), 2 * kPageSize);
|
||
|
||
for (size_t index = 0; index < base::size(two_cookies); ++index) {
|
||
two_cookies[index].SetUp(reinterpret_cast<uint64_t*>(
|
||
mapping.addr_as<uintptr_t>() + index * kPageSize));
|
||
}
|
||
|
||
orig_addr = mapping.addr();
|
||
ASSERT_TRUE(mapping.ResetAddrLen(orig_addr, kPageSize + kHalfPageSize));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_EQ(mapping.addr(), orig_addr);
|
||
EXPECT_EQ(mapping.len(), kPageSize + kHalfPageSize);
|
||
|
||
EXPECT_EQ(two_cookies[0].Observed(), two_cookies[0].Expected());
|
||
EXPECT_EQ(two_cookies[1].Observed(), two_cookies[1].Expected());
|
||
}
|
||
|
||
TEST(ScopedMmapDeathTest, Mprotect) {
|
||
ScopedMmap mapping;
|
||
|
||
const size_t kPageSize = base::checked_cast<size_t>(getpagesize());
|
||
ASSERT_TRUE(ScopedMmapResetMmap(&mapping, kPageSize));
|
||
EXPECT_TRUE(mapping.is_valid());
|
||
EXPECT_NE(mapping.addr(), MAP_FAILED);
|
||
EXPECT_EQ(mapping.len(), kPageSize);
|
||
|
||
char* addr = mapping.addr_as<char*>();
|
||
*addr = 1;
|
||
|
||
ASSERT_TRUE(mapping.Mprotect(PROT_READ));
|
||
|
||
EXPECT_DEATH_CRASH(*addr = 0, "");
|
||
|
||
ASSERT_TRUE(mapping.Mprotect(PROT_READ | PROT_WRITE));
|
||
EXPECT_EQ(*addr, 1);
|
||
*addr = 2;
|
||
}
|
||
|
||
TEST(ScopedMmapTest, Release) {
|
||
ScopedMmap mapping;
|
||
|
||
const size_t kPageSize = base::checked_cast<size_t>(getpagesize());
|
||
ASSERT_TRUE(ScopedMmapResetMmap(&mapping, kPageSize));
|
||
ASSERT_TRUE(mapping.is_valid());
|
||
|
||
ScopedMmap mapping2;
|
||
ASSERT_TRUE(mapping2.ResetAddrLen(mapping.release(), kPageSize));
|
||
EXPECT_TRUE(mapping2.is_valid());
|
||
EXPECT_FALSE(mapping.is_valid());
|
||
}
|
||
|
||
} // namespace
|
||
} // namespace test
|
||
} // namespace crashpad
|