| /* | |
| * Copyright (C) 2018 The Android Open Source Project | |
| * | |
| * 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 <stdint.h> | |
| #include <stdlib.h> | |
| #include <time.h> | |
| #include <gtest/gtest.h> | |
| #if defined(__BIONIC__) | |
| #include <vector> | |
| #include <procinfo/process_map.h> | |
| #include "utils.h" | |
| extern "C" void malloc_disable(); | |
| extern "C" void malloc_enable(); | |
| extern "C" int malloc_iterate(uintptr_t base, size_t size, void (*callback)(uintptr_t base, | |
| size_t size, void* arg), void* arg); | |
| struct AllocDataType { | |
| void* ptr; | |
| size_t size; | |
| size_t size_reported; | |
| size_t count; | |
| }; | |
| struct TestDataType { | |
| size_t total_allocated_bytes; | |
| std::vector<AllocDataType> allocs; | |
| }; | |
| static void AllocPtr(TestDataType* test_data, size_t size) { | |
| test_data->allocs.resize(test_data->allocs.size() + 1); | |
| AllocDataType* alloc = &test_data->allocs.back(); | |
| void* ptr = malloc(size); | |
| ASSERT_TRUE(ptr != nullptr); | |
| alloc->ptr = ptr; | |
| alloc->size = malloc_usable_size(ptr); | |
| alloc->size_reported = 0; | |
| alloc->count = 0; | |
| } | |
| static void FreePtrs(TestDataType* test_data) { | |
| for (size_t i = 0; i < test_data->allocs.size(); i++) { | |
| free(test_data->allocs[i].ptr); | |
| } | |
| } | |
| static void SavePointers(uintptr_t base, size_t size, void* data) { | |
| TestDataType* test_data = reinterpret_cast<TestDataType*>(data); | |
| test_data->total_allocated_bytes += size; | |
| uintptr_t end; | |
| if (__builtin_add_overflow(base, size, &end)) { | |
| // Skip this entry. | |
| return; | |
| } | |
| for (size_t i = 0; i < test_data->allocs.size(); i++) { | |
| uintptr_t ptr = reinterpret_cast<uintptr_t>(test_data->allocs[i].ptr); | |
| if (ptr >= base && ptr < end) { | |
| test_data->allocs[i].count++; | |
| uintptr_t max_size = end - ptr; | |
| if (max_size > test_data->allocs[i].size) { | |
| test_data->allocs[i].size_reported = test_data->allocs[i].size; | |
| } else { | |
| test_data->allocs[i].size_reported = max_size; | |
| } | |
| } | |
| } | |
| } | |
| static void VerifyPtrs(TestDataType* test_data) { | |
| test_data->total_allocated_bytes = 0; | |
| // Find all of the maps that are [anon:libc_malloc]. | |
| ASSERT_TRUE(android::procinfo::ReadMapFile( | |
| "/proc/self/maps", | |
| [&](uint64_t start, uint64_t end, uint16_t, uint64_t, ino_t, const char* name) { | |
| if (std::string(name) == "[anon:libc_malloc]") { | |
| malloc_disable(); | |
| malloc_iterate(start, end - start, SavePointers, test_data); | |
| malloc_enable(); | |
| } | |
| })); | |
| for (size_t i = 0; i < test_data->allocs.size(); i++) { | |
| EXPECT_EQ(1UL, test_data->allocs[i].count) << "Failed on size " << test_data->allocs[i].size; | |
| if (test_data->allocs[i].count == 1) { | |
| EXPECT_EQ(test_data->allocs[i].size, test_data->allocs[i].size_reported); | |
| } | |
| } | |
| } | |
| static void AllocateSizes(TestDataType* test_data, const std::vector<size_t>& sizes) { | |
| static constexpr size_t kInitialAllocations = 40; | |
| static constexpr size_t kNumAllocs = 50; | |
| for (size_t size : sizes) { | |
| // Verify that if the tcache is enabled, that tcache pointers | |
| // are found by allocating and freeing 20 pointers (should be larger | |
| // than the total number of cache entries). | |
| for (size_t i = 0; i < kInitialAllocations; i++) { | |
| void* ptr = malloc(size); | |
| ASSERT_TRUE(ptr != nullptr); | |
| memset(ptr, 0, size); | |
| free(ptr); | |
| } | |
| for (size_t i = 0; i < kNumAllocs; i++) { | |
| AllocPtr(test_data, size); | |
| } | |
| } | |
| } | |
| #endif | |
| // Verify that small allocs can be found properly. | |
| TEST(malloc_iterate, small_allocs) { | |
| #if defined(__BIONIC__) | |
| SKIP_WITH_HWASAN; | |
| TestDataType test_data; | |
| // Try to cycle through all of the different small bins. | |
| // This is specific to the implementation of jemalloc and should be | |
| // adjusted if a different native memory allocator is used. | |
| std::vector<size_t> sizes{8, 16, 32, 48, 64, 80, 96, 112, 128, 160, | |
| 192, 224, 256, 320, 384, 448, 512, 640, 768, 896, | |
| 1024, 1280, 1536, 1792, 2048, 2560, 3072, 3584, 4096, 5120, | |
| 6144, 7168, 8192, 10240, 12288, 14336, 16384, 32768, 65536}; | |
| AllocateSizes(&test_data, sizes); | |
| SCOPED_TRACE(""); | |
| VerifyPtrs(&test_data); | |
| FreePtrs(&test_data); | |
| #else | |
| GTEST_SKIP() << "bionic-only test"; | |
| #endif | |
| } | |
| // Verify that large allocs can be found properly. | |
| TEST(malloc_iterate, large_allocs) { | |
| #if defined(__BIONIC__) | |
| SKIP_WITH_HWASAN; | |
| TestDataType test_data; | |
| // Try some larger sizes. | |
| std::vector<size_t> sizes{131072, 262144, 524288, 1048576, 2097152}; | |
| AllocateSizes(&test_data, sizes); | |
| SCOPED_TRACE(""); | |
| VerifyPtrs(&test_data); | |
| FreePtrs(&test_data); | |
| #else | |
| GTEST_SKIP() << "bionic-only test"; | |
| #endif | |
| } | |
| // Verify that there are no crashes attempting to get pointers from | |
| // non-allocated pointers. | |
| TEST(malloc_iterate, invalid_pointers) { | |
| #if defined(__BIONIC__) | |
| SKIP_WITH_HWASAN; | |
| TestDataType test_data = {}; | |
| // Find all of the maps that are not [anon:libc_malloc]. | |
| ASSERT_TRUE(android::procinfo::ReadMapFile( | |
| "/proc/self/maps", | |
| [&](uint64_t start, uint64_t end, uint16_t, uint64_t, ino_t, const char* name) { | |
| if (std::string(name) != "[anon:libc_malloc]") { | |
| malloc_disable(); | |
| malloc_iterate(start, end - start, SavePointers, &test_data); | |
| malloc_enable(); | |
| } | |
| })); | |
| ASSERT_EQ(0UL, test_data.total_allocated_bytes); | |
| #else | |
| GTEST_SKIP() << "bionic-only test"; | |
| #endif | |
| } | |
| TEST(malloc_iterate, malloc_disable_prevents_allocs) { | |
| #if defined(__BIONIC__) | |
| SKIP_WITH_HWASAN; | |
| pid_t pid; | |
| if ((pid = fork()) == 0) { | |
| malloc_disable(); | |
| void* ptr = malloc(1024); | |
| if (ptr == nullptr) { | |
| exit(1); | |
| } | |
| memset(ptr, 0, 1024); | |
| exit(0); | |
| } | |
| ASSERT_NE(-1, pid); | |
| // Expect that the malloc will hang forever, and that if the process | |
| // does not return for two seconds, it is hung. | |
| sleep(2); | |
| pid_t wait_pid = TEMP_FAILURE_RETRY(waitpid(pid, nullptr, WNOHANG)); | |
| if (wait_pid <= 0) { | |
| kill(pid, SIGKILL); | |
| } | |
| ASSERT_NE(-1, wait_pid) << "Unknown failure in waitpid."; | |
| ASSERT_EQ(0, wait_pid) << "malloc_disable did not prevent allocation calls."; | |
| #else | |
| GTEST_SKIP() << "bionic-only test"; | |
| #endif | |
| } |