1eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// Use of this source code is governed by a BSD-style license that can be 3eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// found in the LICENSE file. 4eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 5eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#define _CRT_SECURE_NO_WARNINGS 6eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 7eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#include "base/process/memory.h" 8eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 9eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#include <limits> 10eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 11eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#include "base/compiler_specific.h" 12eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#include "base/debug/alias.h" 13f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles)#include "base/strings/stringprintf.h" 14eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#include "testing/gtest/include/gtest/gtest.h" 15eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 16eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#if defined(OS_WIN) 17eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#include <windows.h> 18eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#endif 19eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#if defined(OS_POSIX) 20eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#include <errno.h> 21eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#endif 22eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#if defined(OS_MACOSX) 23eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#include <malloc/malloc.h> 245f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles)#include "base/mac/mac_util.h" 25eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#include "base/process/memory_unittest_mac.h" 26eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#endif 27eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#if defined(OS_LINUX) 28eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#include <malloc.h> 29eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#endif 30eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 31eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#if defined(OS_WIN) 32eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// HeapQueryInformation function pointer. 33eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdochtypedef BOOL (WINAPI* HeapQueryFn) \ 34eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch (HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T, PSIZE_T); 35eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 36eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdochconst int kConstantInModule = 42; 37eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 38eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST(ProcessMemoryTest, GetModuleFromAddress) { 39eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // Since the unit tests are their own EXE, this should be 40eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // equivalent to the EXE's HINSTANCE. 41eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // 42eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // kConstantInModule is a constant in this file and 43eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // therefore within the unit test EXE. 44eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch EXPECT_EQ(::GetModuleHandle(NULL), 45eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch base::GetModuleFromAddress( 46eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch const_cast<int*>(&kConstantInModule))); 47eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 48eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // Any address within the kernel32 module should return 49eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // kernel32's HMODULE. Our only assumption here is that 50eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // kernel32 is larger than 4 bytes. 51eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch HMODULE kernel32 = ::GetModuleHandle(L"kernel32.dll"); 52eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch HMODULE kernel32_from_address = 53eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch base::GetModuleFromAddress(reinterpret_cast<DWORD*>(kernel32) + 1); 54eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch EXPECT_EQ(kernel32, kernel32_from_address); 55eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 56eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 57eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST(ProcessMemoryTest, EnableLFH) { 58eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_TRUE(base::EnableLowFragmentationHeap()); 59eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch if (IsDebuggerPresent()) { 60eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // Under these conditions, LFH can't be enabled. There's no point to test 61eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // anything. 62eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch const char* no_debug_env = getenv("_NO_DEBUG_HEAP"); 63eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch if (!no_debug_env || strcmp(no_debug_env, "1")) 64eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch return; 65eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch } 66eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch HMODULE kernel32 = GetModuleHandle(L"kernel32.dll"); 67eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_TRUE(kernel32 != NULL); 68eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch HeapQueryFn heap_query = reinterpret_cast<HeapQueryFn>(GetProcAddress( 69eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch kernel32, 70eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch "HeapQueryInformation")); 71eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 72eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // On Windows 2000, the function is not exported. This is not a reason to 73eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // fail but we won't be able to retrieves information about the heap, so we 74eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // should stop here. 75eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch if (heap_query == NULL) 76eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch return; 77eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 78eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch HANDLE heaps[1024] = { 0 }; 79eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch unsigned number_heaps = GetProcessHeaps(1024, heaps); 80eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch EXPECT_GT(number_heaps, 0u); 81eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch for (unsigned i = 0; i < number_heaps; ++i) { 82eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ULONG flag = 0; 83eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SIZE_T length; 84eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_NE(0, heap_query(heaps[i], 85eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch HeapCompatibilityInformation, 86eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch &flag, 87eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch sizeof(flag), 88eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch &length)); 89eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // If flag is 0, the heap is a standard heap that does not support 90eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // look-asides. If flag is 1, the heap supports look-asides. If flag is 2, 91eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // the heap is a low-fragmentation heap (LFH). Note that look-asides are not 92eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // supported on the LFH. 93eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 94eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // We don't have any documented way of querying the HEAP_NO_SERIALIZE flag. 95eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch EXPECT_LE(flag, 2u); 96eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch EXPECT_NE(flag, 1u); 97eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch } 98eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 99eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#endif // defined(OS_WIN) 100eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 101eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#if defined(OS_MACOSX) 102eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 103eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// For the following Mac tests: 104eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// Note that base::EnableTerminationOnHeapCorruption() is called as part of 105eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// test suite setup and does not need to be done again, else mach_override 106eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// will fail. 107eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 108eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#if !defined(ADDRESS_SANITIZER) 109eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// The following code tests the system implementation of malloc() thus no need 110eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// to test it under AddressSanitizer. 111eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST(ProcessMemoryTest, MacMallocFailureDoesNotTerminate) { 1125f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles)#if ARCH_CPU_32_BITS 1135f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) // The Mavericks malloc library changed in a way which breaks the tricks used 1145f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) // to implement EnableTerminationOnOutOfMemory() with UncheckedMalloc() under 1155f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) // 32-bit. Under 64-bit the oom_killer code handles this. 1165f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) if (base::mac::IsOSMavericksOrLater()) 1175f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) return; 1185f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles)#endif 1195f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) 120eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // Test that ENOMEM doesn't crash via CrMallocErrorBreak two ways: the exit 121eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // code and lack of the error string. The number of bytes is one less than 122eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // MALLOC_ABSOLUTE_MAX_SIZE, more than which the system early-returns NULL and 123eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // does not call through malloc_error_break(). See the comment at 124eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // EnableTerminationOnOutOfMemory() for more information. 125eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch void* buf = NULL; 126eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_EXIT( 127eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch { 128eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch base::EnableTerminationOnOutOfMemory(); 129eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 130eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch buf = malloc(std::numeric_limits<size_t>::max() - (2 * PAGE_SIZE) - 1); 131eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch }, 132eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch testing::KilledBySignal(SIGTRAP), 1335d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) "\\*\\*\\* error: can't allocate region.*\\n?.*"); 134eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 135eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch base::debug::Alias(buf); 136eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 137eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#endif // !defined(ADDRESS_SANITIZER) 138eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 139eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST(ProcessMemoryTest, MacTerminateOnHeapCorruption) { 140eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // Assert that freeing an unallocated pointer will crash the process. 141ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch char buf[9]; 142eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch asm("" : "=r" (buf)); // Prevent clang from being too smart. 143eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#if ARCH_CPU_64_BITS 144eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // On 64 bit Macs, the malloc system automatically abort()s on heap corruption 145eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // but does not output anything. 146eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_DEATH(free(buf), ""); 147eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#elif defined(ADDRESS_SANITIZER) 148eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // AddressSanitizer replaces malloc() and prints a different error message on 149eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // heap corruption. 150eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_DEATH(free(buf), "attempting free on address which " 151eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch "was not malloc\\(\\)-ed"); 152eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#else 1535d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) ASSERT_DEATH(free(buf), "being freed.*\\n?\\.*" 1545d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) "\\*\\*\\* set a breakpoint in malloc_error_break to debug.*\\n?.*" 155eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch "Terminating process due to a potential for future heap corruption"); 156eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#endif // ARCH_CPU_64_BITS || defined(ADDRESS_SANITIZER) 157eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 158eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 159eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#endif // defined(OS_MACOSX) 160eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 161eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// Android doesn't implement set_new_handler, so we can't use the 162eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// OutOfMemoryTest cases. 163eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// OpenBSD does not support these tests either. 164eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// TODO(vandebo) make this work on Windows too. 165eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#if !defined(OS_ANDROID) && !defined(OS_OPENBSD) && \ 166effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch !defined(OS_WIN) 167eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 168eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#if defined(USE_TCMALLOC) 169eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdochextern "C" { 170eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdochint tc_set_new_mode(int mode); 171eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 172eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#endif // defined(USE_TCMALLOC) 173eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 174effb81e5f8246d0db0270817048dc992db66e9fbBen Murdochclass OutOfMemoryTest : public testing::Test { 175eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch public: 176effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch OutOfMemoryTest() 177effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch : value_(NULL), 178effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch // Make test size as large as possible minus a few pages so 179effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch // that alignment or other rounding doesn't make it wrap. 180effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch test_size_(std::numeric_limits<std::size_t>::max() - 12 * 1024), 181effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch signed_test_size_(std::numeric_limits<ssize_t>::max()) { 182eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch } 183eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 184eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#if defined(USE_TCMALLOC) 185eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch virtual void SetUp() OVERRIDE { 186eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch tc_set_new_mode(1); 187eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch } 188eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 189eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch virtual void TearDown() OVERRIDE { 190eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch tc_set_new_mode(0); 191eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch } 192eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#endif // defined(USE_TCMALLOC) 193eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 194effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch protected: 195effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch void* value_; 196effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch size_t test_size_; 197effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch ssize_t signed_test_size_; 198effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch}; 199effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch 200effb81e5f8246d0db0270817048dc992db66e9fbBen Murdochclass OutOfMemoryDeathTest : public OutOfMemoryTest { 201effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch public: 202eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch void SetUpInDeathAssert() { 203eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // Must call EnableTerminationOnOutOfMemory() because that is called from 204eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // chrome's main function and therefore hasn't been called yet. 205eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // Since this call may result in another thread being created and death 206eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // tests shouldn't be started in a multithread environment, this call 207eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // should be done inside of the ASSERT_DEATH. 208eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch base::EnableTerminationOnOutOfMemory(); 209eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch } 210eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch}; 211eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 212eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST_F(OutOfMemoryDeathTest, New) { 213eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_DEATH({ 214eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SetUpInDeathAssert(); 215eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch value_ = operator new(test_size_); 216eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch }, ""); 217eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 218eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 219eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST_F(OutOfMemoryDeathTest, NewArray) { 220eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_DEATH({ 221eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SetUpInDeathAssert(); 222eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch value_ = new char[test_size_]; 223eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch }, ""); 224eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 225eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 226eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST_F(OutOfMemoryDeathTest, Malloc) { 227eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_DEATH({ 228eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SetUpInDeathAssert(); 229eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch value_ = malloc(test_size_); 230eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch }, ""); 231eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 232eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 233eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST_F(OutOfMemoryDeathTest, Realloc) { 234eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_DEATH({ 235eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SetUpInDeathAssert(); 236eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch value_ = realloc(NULL, test_size_); 237eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch }, ""); 238eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 239eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 240eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST_F(OutOfMemoryDeathTest, Calloc) { 241eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_DEATH({ 242eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SetUpInDeathAssert(); 243eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch value_ = calloc(1024, test_size_ / 1024L); 244eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch }, ""); 245eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 246eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 247eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST_F(OutOfMemoryDeathTest, Valloc) { 248eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_DEATH({ 249eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SetUpInDeathAssert(); 250eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch value_ = valloc(test_size_); 251eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch }, ""); 252eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 253eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 254eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#if defined(OS_LINUX) 255a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) 256a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles)#if PVALLOC_AVAILABLE == 1 257eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST_F(OutOfMemoryDeathTest, Pvalloc) { 258eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_DEATH({ 259eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SetUpInDeathAssert(); 260eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch value_ = pvalloc(test_size_); 261eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch }, ""); 262eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 263a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles)#endif // PVALLOC_AVAILABLE == 1 264eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 265eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST_F(OutOfMemoryDeathTest, Memalign) { 266eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_DEATH({ 267eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SetUpInDeathAssert(); 268eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch value_ = memalign(4, test_size_); 269eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch }, ""); 270eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 271eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 272eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST_F(OutOfMemoryDeathTest, ViaSharedLibraries) { 273f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // This tests that the run-time symbol resolution is overriding malloc for 274f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // shared libraries (including libc itself) as well as for our code. 275f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) std::string format = base::StringPrintf("%%%zud", test_size_); 276f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) char *value = NULL; 277eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_DEATH({ 278eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SetUpInDeathAssert(); 279f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) EXPECT_EQ(-1, asprintf(&value, format.c_str(), 0)); 280eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch }, ""); 281eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 282eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#endif // OS_LINUX 283eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 284eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// Android doesn't implement posix_memalign(). 285eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#if defined(OS_POSIX) && !defined(OS_ANDROID) 286eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST_F(OutOfMemoryDeathTest, Posix_memalign) { 287eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // Grab the return value of posix_memalign to silence a compiler warning 288eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // about unused return values. We don't actually care about the return 289eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // value, since we're asserting death. 290eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_DEATH({ 291eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SetUpInDeathAssert(); 292eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch EXPECT_EQ(ENOMEM, posix_memalign(&value_, 8, test_size_)); 293eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch }, ""); 294eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 295eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#endif // defined(OS_POSIX) && !defined(OS_ANDROID) 296eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 297eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#if defined(OS_MACOSX) 298eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 299eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// Purgeable zone tests 300eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 301eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST_F(OutOfMemoryDeathTest, MallocPurgeable) { 302eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch malloc_zone_t* zone = malloc_default_purgeable_zone(); 303eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_DEATH({ 304eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SetUpInDeathAssert(); 305eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch value_ = malloc_zone_malloc(zone, test_size_); 306eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch }, ""); 307eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 308eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 309eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST_F(OutOfMemoryDeathTest, ReallocPurgeable) { 310eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch malloc_zone_t* zone = malloc_default_purgeable_zone(); 311eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_DEATH({ 312eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SetUpInDeathAssert(); 313eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch value_ = malloc_zone_realloc(zone, NULL, test_size_); 314eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch }, ""); 315eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 316eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 317eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST_F(OutOfMemoryDeathTest, CallocPurgeable) { 318eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch malloc_zone_t* zone = malloc_default_purgeable_zone(); 319eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_DEATH({ 320eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SetUpInDeathAssert(); 321eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch value_ = malloc_zone_calloc(zone, 1024, test_size_ / 1024L); 322eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch }, ""); 323eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 324eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 325eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST_F(OutOfMemoryDeathTest, VallocPurgeable) { 326eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch malloc_zone_t* zone = malloc_default_purgeable_zone(); 327eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_DEATH({ 328eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SetUpInDeathAssert(); 329eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch value_ = malloc_zone_valloc(zone, test_size_); 330eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch }, ""); 331eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 332eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 333eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST_F(OutOfMemoryDeathTest, PosixMemalignPurgeable) { 334eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch malloc_zone_t* zone = malloc_default_purgeable_zone(); 335eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_DEATH({ 336eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SetUpInDeathAssert(); 337eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch value_ = malloc_zone_memalign(zone, 8, test_size_); 338eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch }, ""); 339eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 340eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 341eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// Since these allocation functions take a signed size, it's possible that 342eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// calling them just once won't be enough to exhaust memory. In the 32-bit 343eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// environment, it's likely that these allocation attempts will fail because 344eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// not enough contiguous address space is available. In the 64-bit environment, 345eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// it's likely that they'll fail because they would require a preposterous 346eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// amount of (virtual) memory. 347eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 348eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST_F(OutOfMemoryDeathTest, CFAllocatorSystemDefault) { 349eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_DEATH({ 350eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SetUpInDeathAssert(); 351eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch while ((value_ = 352eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch base::AllocateViaCFAllocatorSystemDefault(signed_test_size_))) {} 353eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch }, ""); 354eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 355eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 356eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST_F(OutOfMemoryDeathTest, CFAllocatorMalloc) { 357eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_DEATH({ 358eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SetUpInDeathAssert(); 359eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch while ((value_ = 360eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch base::AllocateViaCFAllocatorMalloc(signed_test_size_))) {} 361eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch }, ""); 362eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 363eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 364eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST_F(OutOfMemoryDeathTest, CFAllocatorMallocZone) { 365eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_DEATH({ 366eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SetUpInDeathAssert(); 367eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch while ((value_ = 368eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch base::AllocateViaCFAllocatorMallocZone(signed_test_size_))) {} 369eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch }, ""); 370eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 371eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 372eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#if !defined(ARCH_CPU_64_BITS) 373eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 374eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// See process_util_unittest_mac.mm for an explanation of why this test isn't 375eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// run in the 64-bit environment. 376eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 377eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochTEST_F(OutOfMemoryDeathTest, PsychoticallyBigObjCObject) { 378eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch ASSERT_DEATH({ 379eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SetUpInDeathAssert(); 380eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch while ((value_ = base::AllocatePsychoticallyBigObjCObject())) {} 381eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch }, ""); 382eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch} 383eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 384eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#endif // !ARCH_CPU_64_BITS 385eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#endif // OS_MACOSX 386eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 387effb81e5f8246d0db0270817048dc992db66e9fbBen Murdochclass OutOfMemoryHandledTest : public OutOfMemoryTest { 388effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch public: 389effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch static const size_t kSafeMallocSize = 512; 390effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch static const size_t kSafeCallocSize = 128; 391effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch static const size_t kSafeCallocItems = 4; 392effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch 393effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch virtual void SetUp() { 394effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch OutOfMemoryTest::SetUp(); 395effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch 396effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch // We enable termination on OOM - just as Chrome does at early 397effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch // initialization - and test that UncheckedMalloc and UncheckedCalloc 398effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch // properly by-pass this in order to allow the caller to handle OOM. 399effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch base::EnableTerminationOnOutOfMemory(); 400effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch } 401effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch}; 402effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch 403effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch// TODO(b.kelemen): make UncheckedMalloc and UncheckedCalloc work 404effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch// on Windows as well. 405effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch// UncheckedMalloc() and UncheckedCalloc() work as regular malloc()/calloc() 406effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch// under sanitizer tools. 407effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch#if !defined(MEMORY_TOOL_REPLACES_ALLOCATOR) 408effb81e5f8246d0db0270817048dc992db66e9fbBen MurdochTEST_F(OutOfMemoryHandledTest, UncheckedMalloc) { 4095f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles)#if defined(OS_MACOSX) && ARCH_CPU_32_BITS 4105f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) // The Mavericks malloc library changed in a way which breaks the tricks used 4115f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) // to implement EnableTerminationOnOutOfMemory() with UncheckedMalloc() under 4125f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) // 32-bit. The 64-bit malloc library works as desired without tricks. 4135f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) if (base::mac::IsOSMavericksOrLater()) 4145f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) return; 4155f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles)#endif 416effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch EXPECT_TRUE(base::UncheckedMalloc(kSafeMallocSize, &value_)); 417effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch EXPECT_TRUE(value_ != NULL); 418effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch free(value_); 419effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch 420effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch EXPECT_FALSE(base::UncheckedMalloc(test_size_, &value_)); 421effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch EXPECT_TRUE(value_ == NULL); 422effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch} 423effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch 424effb81e5f8246d0db0270817048dc992db66e9fbBen MurdochTEST_F(OutOfMemoryHandledTest, UncheckedCalloc) { 4255f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles)#if defined(OS_MACOSX) && ARCH_CPU_32_BITS 4265f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) // The Mavericks malloc library changed in a way which breaks the tricks used 4275f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) // to implement EnableTerminationOnOutOfMemory() with UncheckedCalloc() under 4285f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) // 32-bit. The 64-bit malloc library works as desired without tricks. 4295f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) if (base::mac::IsOSMavericksOrLater()) 4305f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) return; 4315f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles)#endif 432effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch EXPECT_TRUE(base::UncheckedCalloc(1, kSafeMallocSize, &value_)); 433effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch EXPECT_TRUE(value_ != NULL); 434effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch const char* bytes = static_cast<const char*>(value_); 435effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch for (size_t i = 0; i < kSafeMallocSize; ++i) 436effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch EXPECT_EQ(0, bytes[i]); 437effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch free(value_); 438effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch 439effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch EXPECT_TRUE( 440effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch base::UncheckedCalloc(kSafeCallocItems, kSafeCallocSize, &value_)); 441effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch EXPECT_TRUE(value_ != NULL); 442effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch bytes = static_cast<const char*>(value_); 443effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch for (size_t i = 0; i < (kSafeCallocItems * kSafeCallocSize); ++i) 444effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch EXPECT_EQ(0, bytes[i]); 445effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch free(value_); 446effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch 447effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch EXPECT_FALSE(base::UncheckedCalloc(1, test_size_, &value_)); 448effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch EXPECT_TRUE(value_ == NULL); 449effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch} 450effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch#endif // !defined(MEMORY_TOOL_REPLACES_ALLOCATOR) 451effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch#endif // !defined(OS_ANDROID) && !defined(OS_OPENBSD) && !defined(OS_WIN) 452