blob: edcc179ed96d08aab55b02792c0f6299beacbdd7 [file] [log] [blame]
Christopher Ferris885f3b92013-05-21 17:48:01 -07001/*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <gtest/gtest.h>
18
Christopher Ferrise4cdbc42019-02-08 17:30:58 -080019#include <elf.h>
Christopher Ferrisa4037802014-06-09 19:14:11 -070020#include <limits.h>
Christopher Ferris1fc5ccf2019-02-15 18:06:15 -080021#include <pthread.h>
Christopher Ferrisa4037802014-06-09 19:14:11 -070022#include <stdint.h>
Christopher Ferris6c619a02019-03-01 17:59:51 -080023#include <stdio.h>
Christopher Ferris885f3b92013-05-21 17:48:01 -070024#include <stdlib.h>
Christopher Ferris1fc5ccf2019-02-15 18:06:15 -080025#include <string.h>
26#include <sys/types.h>
27#include <sys/wait.h>
Christopher Ferris885f3b92013-05-21 17:48:01 -070028#include <malloc.h>
Christopher Ferrisa4037802014-06-09 19:14:11 -070029#include <unistd.h>
Christopher Ferris885f3b92013-05-21 17:48:01 -070030
Christopher Ferris1fc5ccf2019-02-15 18:06:15 -080031#include <atomic>
Dan Albert4caa1f02014-08-20 09:16:57 -070032#include <tinyxml2.h>
33
Christopher Ferrise4cdbc42019-02-08 17:30:58 -080034#include <android-base/file.h>
35
Christopher Ferris63619642014-06-16 23:35:53 -070036#include "private/bionic_config.h"
Ryan Savitskiecc37e32018-12-14 15:57:21 +000037#include "private/bionic_malloc.h"
Evgenii Stepanovacd6f4f2018-11-06 16:48:27 -080038#include "utils.h"
Dan Alberte5fdaa42014-06-14 01:04:31 +000039
Elliott Hughesb1770852018-09-18 12:52:42 -070040#if defined(__BIONIC__)
41#define HAVE_REALLOCARRAY 1
42#else
43#define HAVE_REALLOCARRAY __GLIBC_PREREQ(2, 26)
44#endif
45
Christopher Ferris885f3b92013-05-21 17:48:01 -070046TEST(malloc, malloc_std) {
47 // Simple malloc test.
48 void *ptr = malloc(100);
Yi Kong32bc0fc2018-08-02 17:31:13 -070049 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -070050 ASSERT_LE(100U, malloc_usable_size(ptr));
Christopher Ferris885f3b92013-05-21 17:48:01 -070051 free(ptr);
52}
53
Christopher Ferrisa4037802014-06-09 19:14:11 -070054TEST(malloc, malloc_overflow) {
Evgenii Stepanovacd6f4f2018-11-06 16:48:27 -080055 SKIP_WITH_HWASAN;
Christopher Ferrisa4037802014-06-09 19:14:11 -070056 errno = 0;
Yi Kong32bc0fc2018-08-02 17:31:13 -070057 ASSERT_EQ(nullptr, malloc(SIZE_MAX));
Christopher Ferrisa4037802014-06-09 19:14:11 -070058 ASSERT_EQ(ENOMEM, errno);
59}
60
Christopher Ferris885f3b92013-05-21 17:48:01 -070061TEST(malloc, calloc_std) {
62 // Simple calloc test.
63 size_t alloc_len = 100;
64 char *ptr = (char *)calloc(1, alloc_len);
Yi Kong32bc0fc2018-08-02 17:31:13 -070065 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -070066 ASSERT_LE(alloc_len, malloc_usable_size(ptr));
67 for (size_t i = 0; i < alloc_len; i++) {
68 ASSERT_EQ(0, ptr[i]);
69 }
Christopher Ferris885f3b92013-05-21 17:48:01 -070070 free(ptr);
71}
72
Christopher Ferrisa4037802014-06-09 19:14:11 -070073TEST(malloc, calloc_illegal) {
Evgenii Stepanovacd6f4f2018-11-06 16:48:27 -080074 SKIP_WITH_HWASAN;
Christopher Ferrisa4037802014-06-09 19:14:11 -070075 errno = 0;
Yi Kong32bc0fc2018-08-02 17:31:13 -070076 ASSERT_EQ(nullptr, calloc(-1, 100));
Christopher Ferrisa4037802014-06-09 19:14:11 -070077 ASSERT_EQ(ENOMEM, errno);
78}
79
80TEST(malloc, calloc_overflow) {
Evgenii Stepanovacd6f4f2018-11-06 16:48:27 -080081 SKIP_WITH_HWASAN;
Christopher Ferrisa4037802014-06-09 19:14:11 -070082 errno = 0;
Yi Kong32bc0fc2018-08-02 17:31:13 -070083 ASSERT_EQ(nullptr, calloc(1, SIZE_MAX));
Christopher Ferrisa4037802014-06-09 19:14:11 -070084 ASSERT_EQ(ENOMEM, errno);
85 errno = 0;
Yi Kong32bc0fc2018-08-02 17:31:13 -070086 ASSERT_EQ(nullptr, calloc(SIZE_MAX, SIZE_MAX));
Christopher Ferrisa4037802014-06-09 19:14:11 -070087 ASSERT_EQ(ENOMEM, errno);
88 errno = 0;
Yi Kong32bc0fc2018-08-02 17:31:13 -070089 ASSERT_EQ(nullptr, calloc(2, SIZE_MAX));
Christopher Ferrisa4037802014-06-09 19:14:11 -070090 ASSERT_EQ(ENOMEM, errno);
91 errno = 0;
Yi Kong32bc0fc2018-08-02 17:31:13 -070092 ASSERT_EQ(nullptr, calloc(SIZE_MAX, 2));
Christopher Ferrisa4037802014-06-09 19:14:11 -070093 ASSERT_EQ(ENOMEM, errno);
94}
95
Christopher Ferris885f3b92013-05-21 17:48:01 -070096TEST(malloc, memalign_multiple) {
Elliott Hughesbcaa4542019-03-08 15:20:23 -080097 SKIP_WITH_HWASAN << "hwasan requires power of 2 alignment";
Christopher Ferris885f3b92013-05-21 17:48:01 -070098 // Memalign test where the alignment is any value.
99 for (size_t i = 0; i <= 12; i++) {
100 for (size_t alignment = 1 << i; alignment < (1U << (i+1)); alignment++) {
Christopher Ferrisa4037802014-06-09 19:14:11 -0700101 char *ptr = reinterpret_cast<char*>(memalign(alignment, 100));
Yi Kong32bc0fc2018-08-02 17:31:13 -0700102 ASSERT_TRUE(ptr != nullptr) << "Failed at alignment " << alignment;
Christopher Ferrisa4037802014-06-09 19:14:11 -0700103 ASSERT_LE(100U, malloc_usable_size(ptr)) << "Failed at alignment " << alignment;
104 ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(ptr) % ((1U << i)))
105 << "Failed at alignment " << alignment;
Christopher Ferris885f3b92013-05-21 17:48:01 -0700106 free(ptr);
107 }
108 }
109}
110
Christopher Ferrisa4037802014-06-09 19:14:11 -0700111TEST(malloc, memalign_overflow) {
Evgenii Stepanovacd6f4f2018-11-06 16:48:27 -0800112 SKIP_WITH_HWASAN;
Yi Kong32bc0fc2018-08-02 17:31:13 -0700113 ASSERT_EQ(nullptr, memalign(4096, SIZE_MAX));
Christopher Ferrisa4037802014-06-09 19:14:11 -0700114}
115
116TEST(malloc, memalign_non_power2) {
Evgenii Stepanovacd6f4f2018-11-06 16:48:27 -0800117 SKIP_WITH_HWASAN;
Christopher Ferrisa4037802014-06-09 19:14:11 -0700118 void* ptr;
119 for (size_t align = 0; align <= 256; align++) {
120 ptr = memalign(align, 1024);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700121 ASSERT_TRUE(ptr != nullptr) << "Failed at align " << align;
Christopher Ferrisa4037802014-06-09 19:14:11 -0700122 free(ptr);
123 }
124}
125
Christopher Ferris885f3b92013-05-21 17:48:01 -0700126TEST(malloc, memalign_realloc) {
127 // Memalign and then realloc the pointer a couple of times.
128 for (size_t alignment = 1; alignment <= 4096; alignment <<= 1) {
129 char *ptr = (char*)memalign(alignment, 100);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700130 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700131 ASSERT_LE(100U, malloc_usable_size(ptr));
132 ASSERT_EQ(0U, (intptr_t)ptr % alignment);
133 memset(ptr, 0x23, 100);
134
135 ptr = (char*)realloc(ptr, 200);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700136 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700137 ASSERT_LE(200U, malloc_usable_size(ptr));
Yi Kong32bc0fc2018-08-02 17:31:13 -0700138 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700139 for (size_t i = 0; i < 100; i++) {
140 ASSERT_EQ(0x23, ptr[i]);
141 }
142 memset(ptr, 0x45, 200);
143
144 ptr = (char*)realloc(ptr, 300);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700145 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700146 ASSERT_LE(300U, malloc_usable_size(ptr));
147 for (size_t i = 0; i < 200; i++) {
148 ASSERT_EQ(0x45, ptr[i]);
149 }
150 memset(ptr, 0x67, 300);
151
152 ptr = (char*)realloc(ptr, 250);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700153 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700154 ASSERT_LE(250U, malloc_usable_size(ptr));
155 for (size_t i = 0; i < 250; i++) {
156 ASSERT_EQ(0x67, ptr[i]);
157 }
Christopher Ferris885f3b92013-05-21 17:48:01 -0700158 free(ptr);
159 }
160}
161
162TEST(malloc, malloc_realloc_larger) {
163 // Realloc to a larger size, malloc is used for the original allocation.
164 char *ptr = (char *)malloc(100);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700165 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700166 ASSERT_LE(100U, malloc_usable_size(ptr));
167 memset(ptr, 67, 100);
168
169 ptr = (char *)realloc(ptr, 200);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700170 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700171 ASSERT_LE(200U, malloc_usable_size(ptr));
172 for (size_t i = 0; i < 100; i++) {
173 ASSERT_EQ(67, ptr[i]);
174 }
Christopher Ferris885f3b92013-05-21 17:48:01 -0700175 free(ptr);
176}
177
178TEST(malloc, malloc_realloc_smaller) {
179 // Realloc to a smaller size, malloc is used for the original allocation.
180 char *ptr = (char *)malloc(200);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700181 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700182 ASSERT_LE(200U, malloc_usable_size(ptr));
183 memset(ptr, 67, 200);
184
185 ptr = (char *)realloc(ptr, 100);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700186 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700187 ASSERT_LE(100U, malloc_usable_size(ptr));
188 for (size_t i = 0; i < 100; i++) {
189 ASSERT_EQ(67, ptr[i]);
190 }
Christopher Ferris885f3b92013-05-21 17:48:01 -0700191 free(ptr);
192}
193
194TEST(malloc, malloc_multiple_realloc) {
195 // Multiple reallocs, malloc is used for the original allocation.
196 char *ptr = (char *)malloc(200);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700197 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700198 ASSERT_LE(200U, malloc_usable_size(ptr));
199 memset(ptr, 0x23, 200);
200
201 ptr = (char *)realloc(ptr, 100);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700202 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700203 ASSERT_LE(100U, malloc_usable_size(ptr));
204 for (size_t i = 0; i < 100; i++) {
205 ASSERT_EQ(0x23, ptr[i]);
206 }
207
208 ptr = (char*)realloc(ptr, 50);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700209 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700210 ASSERT_LE(50U, malloc_usable_size(ptr));
211 for (size_t i = 0; i < 50; i++) {
212 ASSERT_EQ(0x23, ptr[i]);
213 }
214
215 ptr = (char*)realloc(ptr, 150);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700216 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700217 ASSERT_LE(150U, malloc_usable_size(ptr));
218 for (size_t i = 0; i < 50; i++) {
219 ASSERT_EQ(0x23, ptr[i]);
220 }
221 memset(ptr, 0x23, 150);
222
223 ptr = (char*)realloc(ptr, 425);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700224 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700225 ASSERT_LE(425U, malloc_usable_size(ptr));
226 for (size_t i = 0; i < 150; i++) {
227 ASSERT_EQ(0x23, ptr[i]);
228 }
Christopher Ferris885f3b92013-05-21 17:48:01 -0700229 free(ptr);
230}
Christopher Ferrisa4037802014-06-09 19:14:11 -0700231
Christopher Ferris885f3b92013-05-21 17:48:01 -0700232TEST(malloc, calloc_realloc_larger) {
233 // Realloc to a larger size, calloc is used for the original allocation.
234 char *ptr = (char *)calloc(1, 100);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700235 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700236 ASSERT_LE(100U, malloc_usable_size(ptr));
237
238 ptr = (char *)realloc(ptr, 200);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700239 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700240 ASSERT_LE(200U, malloc_usable_size(ptr));
241 for (size_t i = 0; i < 100; i++) {
242 ASSERT_EQ(0, ptr[i]);
243 }
Christopher Ferris885f3b92013-05-21 17:48:01 -0700244 free(ptr);
245}
246
247TEST(malloc, calloc_realloc_smaller) {
248 // Realloc to a smaller size, calloc is used for the original allocation.
249 char *ptr = (char *)calloc(1, 200);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700250 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700251 ASSERT_LE(200U, malloc_usable_size(ptr));
252
253 ptr = (char *)realloc(ptr, 100);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700254 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700255 ASSERT_LE(100U, malloc_usable_size(ptr));
256 for (size_t i = 0; i < 100; i++) {
257 ASSERT_EQ(0, ptr[i]);
258 }
Christopher Ferris885f3b92013-05-21 17:48:01 -0700259 free(ptr);
260}
261
262TEST(malloc, calloc_multiple_realloc) {
263 // Multiple reallocs, calloc is used for the original allocation.
264 char *ptr = (char *)calloc(1, 200);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700265 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700266 ASSERT_LE(200U, malloc_usable_size(ptr));
267
268 ptr = (char *)realloc(ptr, 100);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700269 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700270 ASSERT_LE(100U, malloc_usable_size(ptr));
271 for (size_t i = 0; i < 100; i++) {
272 ASSERT_EQ(0, ptr[i]);
273 }
274
275 ptr = (char*)realloc(ptr, 50);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700276 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700277 ASSERT_LE(50U, malloc_usable_size(ptr));
278 for (size_t i = 0; i < 50; i++) {
279 ASSERT_EQ(0, ptr[i]);
280 }
281
282 ptr = (char*)realloc(ptr, 150);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700283 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700284 ASSERT_LE(150U, malloc_usable_size(ptr));
285 for (size_t i = 0; i < 50; i++) {
286 ASSERT_EQ(0, ptr[i]);
287 }
288 memset(ptr, 0, 150);
289
290 ptr = (char*)realloc(ptr, 425);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700291 ASSERT_TRUE(ptr != nullptr);
Christopher Ferris885f3b92013-05-21 17:48:01 -0700292 ASSERT_LE(425U, malloc_usable_size(ptr));
293 for (size_t i = 0; i < 150; i++) {
294 ASSERT_EQ(0, ptr[i]);
295 }
Christopher Ferris885f3b92013-05-21 17:48:01 -0700296 free(ptr);
297}
Christopher Ferris72bbd422014-05-08 11:14:03 -0700298
Christopher Ferrisa4037802014-06-09 19:14:11 -0700299TEST(malloc, realloc_overflow) {
Evgenii Stepanovacd6f4f2018-11-06 16:48:27 -0800300 SKIP_WITH_HWASAN;
Christopher Ferrisa4037802014-06-09 19:14:11 -0700301 errno = 0;
Yi Kong32bc0fc2018-08-02 17:31:13 -0700302 ASSERT_EQ(nullptr, realloc(nullptr, SIZE_MAX));
Christopher Ferrisa4037802014-06-09 19:14:11 -0700303 ASSERT_EQ(ENOMEM, errno);
304 void* ptr = malloc(100);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700305 ASSERT_TRUE(ptr != nullptr);
Christopher Ferrisa4037802014-06-09 19:14:11 -0700306 errno = 0;
Yi Kong32bc0fc2018-08-02 17:31:13 -0700307 ASSERT_EQ(nullptr, realloc(ptr, SIZE_MAX));
Christopher Ferrisa4037802014-06-09 19:14:11 -0700308 ASSERT_EQ(ENOMEM, errno);
309 free(ptr);
Christopher Ferris72bbd422014-05-08 11:14:03 -0700310}
311
Dan Alberte5fdaa42014-06-14 01:04:31 +0000312#if defined(HAVE_DEPRECATED_MALLOC_FUNCS)
313extern "C" void* pvalloc(size_t);
314extern "C" void* valloc(size_t);
Christopher Ferris804cebe2019-06-20 08:50:23 -0700315#endif
Dan Alberte5fdaa42014-06-14 01:04:31 +0000316
Christopher Ferrisa4037802014-06-09 19:14:11 -0700317TEST(malloc, pvalloc_std) {
Christopher Ferris804cebe2019-06-20 08:50:23 -0700318#if defined(HAVE_DEPRECATED_MALLOC_FUNCS)
Christopher Ferrisa4037802014-06-09 19:14:11 -0700319 size_t pagesize = sysconf(_SC_PAGESIZE);
320 void* ptr = pvalloc(100);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700321 ASSERT_TRUE(ptr != nullptr);
Christopher Ferrisa4037802014-06-09 19:14:11 -0700322 ASSERT_TRUE((reinterpret_cast<uintptr_t>(ptr) & (pagesize-1)) == 0);
323 ASSERT_LE(pagesize, malloc_usable_size(ptr));
324 free(ptr);
Christopher Ferris804cebe2019-06-20 08:50:23 -0700325#else
326 GTEST_SKIP() << "pvalloc not supported.";
327#endif
Christopher Ferrisa4037802014-06-09 19:14:11 -0700328}
329
330TEST(malloc, pvalloc_overflow) {
Christopher Ferris804cebe2019-06-20 08:50:23 -0700331#if defined(HAVE_DEPRECATED_MALLOC_FUNCS)
Yi Kong32bc0fc2018-08-02 17:31:13 -0700332 ASSERT_EQ(nullptr, pvalloc(SIZE_MAX));
Christopher Ferris804cebe2019-06-20 08:50:23 -0700333#else
334 GTEST_SKIP() << "pvalloc not supported.";
335#endif
Christopher Ferrisa4037802014-06-09 19:14:11 -0700336}
337
338TEST(malloc, valloc_std) {
Christopher Ferris804cebe2019-06-20 08:50:23 -0700339#if defined(HAVE_DEPRECATED_MALLOC_FUNCS)
Christopher Ferrisa4037802014-06-09 19:14:11 -0700340 size_t pagesize = sysconf(_SC_PAGESIZE);
Christopher Ferrisd5ab0a52019-06-19 12:03:57 -0700341 void* ptr = valloc(100);
Yi Kong32bc0fc2018-08-02 17:31:13 -0700342 ASSERT_TRUE(ptr != nullptr);
Christopher Ferrisa4037802014-06-09 19:14:11 -0700343 ASSERT_TRUE((reinterpret_cast<uintptr_t>(ptr) & (pagesize-1)) == 0);
344 free(ptr);
Christopher Ferris804cebe2019-06-20 08:50:23 -0700345#else
346 GTEST_SKIP() << "valloc not supported.";
347#endif
Christopher Ferrisa4037802014-06-09 19:14:11 -0700348}
349
350TEST(malloc, valloc_overflow) {
Christopher Ferris804cebe2019-06-20 08:50:23 -0700351#if defined(HAVE_DEPRECATED_MALLOC_FUNCS)
Yi Kong32bc0fc2018-08-02 17:31:13 -0700352 ASSERT_EQ(nullptr, valloc(SIZE_MAX));
Christopher Ferris804cebe2019-06-20 08:50:23 -0700353#else
354 GTEST_SKIP() << "valloc not supported.";
Dan Alberte5fdaa42014-06-14 01:04:31 +0000355#endif
Christopher Ferris804cebe2019-06-20 08:50:23 -0700356}
Dan Albert4caa1f02014-08-20 09:16:57 -0700357
358TEST(malloc, malloc_info) {
359#ifdef __BIONIC__
Evgenii Stepanov8de6b462019-03-22 13:22:28 -0700360 SKIP_WITH_HWASAN; // hwasan does not implement malloc_info
Dan Albert4caa1f02014-08-20 09:16:57 -0700361 char* buf;
362 size_t bufsize;
363 FILE* memstream = open_memstream(&buf, &bufsize);
364 ASSERT_NE(nullptr, memstream);
365 ASSERT_EQ(0, malloc_info(0, memstream));
366 ASSERT_EQ(0, fclose(memstream));
367
368 tinyxml2::XMLDocument doc;
369 ASSERT_EQ(tinyxml2::XML_SUCCESS, doc.Parse(buf));
370
371 auto root = doc.FirstChildElement();
372 ASSERT_NE(nullptr, root);
373 ASSERT_STREQ("malloc", root->Name());
Christopher Ferris6c619a02019-03-01 17:59:51 -0800374 if (std::string(root->Attribute("version")) == "jemalloc-1") {
375 // Verify jemalloc version of this data.
376 ASSERT_STREQ("jemalloc-1", root->Attribute("version"));
Dan Albert4caa1f02014-08-20 09:16:57 -0700377
Christopher Ferris6c619a02019-03-01 17:59:51 -0800378 auto arena = root->FirstChildElement();
379 for (; arena != nullptr; arena = arena->NextSiblingElement()) {
380 int val;
Dan Albert4caa1f02014-08-20 09:16:57 -0700381
Christopher Ferris6c619a02019-03-01 17:59:51 -0800382 ASSERT_STREQ("heap", arena->Name());
383 ASSERT_EQ(tinyxml2::XML_SUCCESS, arena->QueryIntAttribute("nr", &val));
384 ASSERT_EQ(tinyxml2::XML_SUCCESS,
385 arena->FirstChildElement("allocated-large")->QueryIntText(&val));
386 ASSERT_EQ(tinyxml2::XML_SUCCESS,
387 arena->FirstChildElement("allocated-huge")->QueryIntText(&val));
388 ASSERT_EQ(tinyxml2::XML_SUCCESS,
389 arena->FirstChildElement("allocated-bins")->QueryIntText(&val));
390 ASSERT_EQ(tinyxml2::XML_SUCCESS,
391 arena->FirstChildElement("bins-total")->QueryIntText(&val));
Dan Albert4caa1f02014-08-20 09:16:57 -0700392
Christopher Ferris6c619a02019-03-01 17:59:51 -0800393 auto bin = arena->FirstChildElement("bin");
394 for (; bin != nullptr; bin = bin ->NextSiblingElement()) {
395 if (strcmp(bin->Name(), "bin") == 0) {
396 ASSERT_EQ(tinyxml2::XML_SUCCESS, bin->QueryIntAttribute("nr", &val));
397 ASSERT_EQ(tinyxml2::XML_SUCCESS,
398 bin->FirstChildElement("allocated")->QueryIntText(&val));
399 ASSERT_EQ(tinyxml2::XML_SUCCESS,
400 bin->FirstChildElement("nmalloc")->QueryIntText(&val));
401 ASSERT_EQ(tinyxml2::XML_SUCCESS,
402 bin->FirstChildElement("ndalloc")->QueryIntText(&val));
403 }
Dan Albert4caa1f02014-08-20 09:16:57 -0700404 }
405 }
Christopher Ferris6c619a02019-03-01 17:59:51 -0800406 } else {
407 // Only verify that this is debug-malloc-1, the malloc debug unit tests
408 // verify the output.
409 ASSERT_STREQ("debug-malloc-1", root->Attribute("version"));
Dan Albert4caa1f02014-08-20 09:16:57 -0700410 }
411#endif
412}
Christopher Ferrisad33ebe2015-12-16 12:07:25 -0800413
Christopher Ferrisdb9706a2019-05-02 18:33:11 -0700414TEST(malloc, malloc_info_matches_mallinfo) {
415#ifdef __BIONIC__
416 SKIP_WITH_HWASAN; // hwasan does not implement malloc_info
417
418 char* buf;
419 size_t bufsize;
420 FILE* memstream = open_memstream(&buf, &bufsize);
421 ASSERT_NE(nullptr, memstream);
422 size_t mallinfo_before_allocated_bytes = mallinfo().uordblks;
423 ASSERT_EQ(0, malloc_info(0, memstream));
424 size_t mallinfo_after_allocated_bytes = mallinfo().uordblks;
425 ASSERT_EQ(0, fclose(memstream));
426
427 tinyxml2::XMLDocument doc;
428 ASSERT_EQ(tinyxml2::XML_SUCCESS, doc.Parse(buf));
429
430 size_t total_allocated_bytes = 0;
431 auto root = doc.FirstChildElement();
432 ASSERT_NE(nullptr, root);
433 ASSERT_STREQ("malloc", root->Name());
434 if (std::string(root->Attribute("version")) == "jemalloc-1") {
435 // Verify jemalloc version of this data.
436 ASSERT_STREQ("jemalloc-1", root->Attribute("version"));
437
438 auto arena = root->FirstChildElement();
439 for (; arena != nullptr; arena = arena->NextSiblingElement()) {
440 int val;
441
442 ASSERT_STREQ("heap", arena->Name());
443 ASSERT_EQ(tinyxml2::XML_SUCCESS, arena->QueryIntAttribute("nr", &val));
444 ASSERT_EQ(tinyxml2::XML_SUCCESS,
445 arena->FirstChildElement("allocated-large")->QueryIntText(&val));
446 total_allocated_bytes += val;
447 ASSERT_EQ(tinyxml2::XML_SUCCESS,
448 arena->FirstChildElement("allocated-huge")->QueryIntText(&val));
449 total_allocated_bytes += val;
450 ASSERT_EQ(tinyxml2::XML_SUCCESS,
451 arena->FirstChildElement("allocated-bins")->QueryIntText(&val));
452 total_allocated_bytes += val;
453 ASSERT_EQ(tinyxml2::XML_SUCCESS,
454 arena->FirstChildElement("bins-total")->QueryIntText(&val));
455 }
456 // The total needs to be between the mallinfo call before and after
457 // since malloc_info allocates some memory.
458 EXPECT_LE(mallinfo_before_allocated_bytes, total_allocated_bytes);
459 EXPECT_GE(mallinfo_after_allocated_bytes, total_allocated_bytes);
460 } else {
461 // Only verify that this is debug-malloc-1, the malloc debug unit tests
462 // verify the output.
463 ASSERT_STREQ("debug-malloc-1", root->Attribute("version"));
464 }
465#endif
466}
467
Christopher Ferrisad33ebe2015-12-16 12:07:25 -0800468TEST(malloc, calloc_usable_size) {
469 for (size_t size = 1; size <= 2048; size++) {
470 void* pointer = malloc(size);
471 ASSERT_TRUE(pointer != nullptr);
472 memset(pointer, 0xeb, malloc_usable_size(pointer));
473 free(pointer);
474
475 // We should get a previous pointer that has been set to non-zero.
476 // If calloc does not zero out all of the data, this will fail.
477 uint8_t* zero_mem = reinterpret_cast<uint8_t*>(calloc(1, size));
478 ASSERT_TRUE(pointer != nullptr);
479 size_t usable_size = malloc_usable_size(zero_mem);
480 for (size_t i = 0; i < usable_size; i++) {
481 ASSERT_EQ(0, zero_mem[i]) << "Failed at allocation size " << size << " at byte " << i;
482 }
483 free(zero_mem);
484 }
485}
Elliott Hughes884f76e2016-02-10 20:43:22 -0800486
487TEST(malloc, malloc_0) {
488 void* p = malloc(0);
489 ASSERT_TRUE(p != nullptr);
490 free(p);
491}
492
493TEST(malloc, calloc_0_0) {
494 void* p = calloc(0, 0);
495 ASSERT_TRUE(p != nullptr);
496 free(p);
497}
498
499TEST(malloc, calloc_0_1) {
500 void* p = calloc(0, 1);
501 ASSERT_TRUE(p != nullptr);
502 free(p);
503}
504
505TEST(malloc, calloc_1_0) {
506 void* p = calloc(1, 0);
507 ASSERT_TRUE(p != nullptr);
508 free(p);
509}
510
511TEST(malloc, realloc_nullptr_0) {
512 // realloc(nullptr, size) is actually malloc(size).
513 void* p = realloc(nullptr, 0);
514 ASSERT_TRUE(p != nullptr);
515 free(p);
516}
517
518TEST(malloc, realloc_0) {
519 void* p = malloc(1024);
520 ASSERT_TRUE(p != nullptr);
521 // realloc(p, 0) is actually free(p).
522 void* p2 = realloc(p, 0);
523 ASSERT_TRUE(p2 == nullptr);
524}
Christopher Ferris72df6702016-02-11 15:51:31 -0800525
526constexpr size_t MAX_LOOPS = 200;
527
528// Make sure that memory returned by malloc is aligned to allow these data types.
529TEST(malloc, verify_alignment) {
530 uint32_t** values_32 = new uint32_t*[MAX_LOOPS];
531 uint64_t** values_64 = new uint64_t*[MAX_LOOPS];
532 long double** values_ldouble = new long double*[MAX_LOOPS];
533 // Use filler to attempt to force the allocator to get potentially bad alignments.
534 void** filler = new void*[MAX_LOOPS];
535
536 for (size_t i = 0; i < MAX_LOOPS; i++) {
537 // Check uint32_t pointers.
538 filler[i] = malloc(1);
539 ASSERT_TRUE(filler[i] != nullptr);
540
541 values_32[i] = reinterpret_cast<uint32_t*>(malloc(sizeof(uint32_t)));
542 ASSERT_TRUE(values_32[i] != nullptr);
543 *values_32[i] = i;
544 ASSERT_EQ(*values_32[i], i);
545 ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(values_32[i]) & (sizeof(uint32_t) - 1));
546
547 free(filler[i]);
548 }
549
550 for (size_t i = 0; i < MAX_LOOPS; i++) {
551 // Check uint64_t pointers.
552 filler[i] = malloc(1);
553 ASSERT_TRUE(filler[i] != nullptr);
554
555 values_64[i] = reinterpret_cast<uint64_t*>(malloc(sizeof(uint64_t)));
556 ASSERT_TRUE(values_64[i] != nullptr);
557 *values_64[i] = 0x1000 + i;
558 ASSERT_EQ(*values_64[i], 0x1000 + i);
559 ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(values_64[i]) & (sizeof(uint64_t) - 1));
560
561 free(filler[i]);
562 }
563
564 for (size_t i = 0; i < MAX_LOOPS; i++) {
565 // Check long double pointers.
566 filler[i] = malloc(1);
567 ASSERT_TRUE(filler[i] != nullptr);
568
569 values_ldouble[i] = reinterpret_cast<long double*>(malloc(sizeof(long double)));
570 ASSERT_TRUE(values_ldouble[i] != nullptr);
571 *values_ldouble[i] = 5.5 + i;
572 ASSERT_DOUBLE_EQ(*values_ldouble[i], 5.5 + i);
573 // 32 bit glibc has a long double size of 12 bytes, so hardcode the
574 // required alignment to 0x7.
575#if !defined(__BIONIC__) && !defined(__LP64__)
576 ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(values_ldouble[i]) & 0x7);
577#else
578 ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(values_ldouble[i]) & (sizeof(long double) - 1));
579#endif
580
581 free(filler[i]);
582 }
583
584 for (size_t i = 0; i < MAX_LOOPS; i++) {
585 free(values_32[i]);
586 free(values_64[i]);
587 free(values_ldouble[i]);
588 }
589
590 delete[] filler;
591 delete[] values_32;
592 delete[] values_64;
593 delete[] values_ldouble;
594}
Christopher Ferrisa1c0d2f2017-05-15 15:50:19 -0700595
596TEST(malloc, mallopt_smoke) {
597 errno = 0;
598 ASSERT_EQ(0, mallopt(-1000, 1));
599 // mallopt doesn't set errno.
600 ASSERT_EQ(0, errno);
601}
Elliott Hughesb1770852018-09-18 12:52:42 -0700602
Christopher Ferrisaf1b8dd2018-11-07 15:28:16 -0800603TEST(malloc, mallopt_decay) {
604#if defined(__BIONIC__)
Elliott Hughesbcaa4542019-03-08 15:20:23 -0800605 SKIP_WITH_HWASAN << "hwasan does not implement mallopt";
Christopher Ferrisaf1b8dd2018-11-07 15:28:16 -0800606 errno = 0;
607 ASSERT_EQ(1, mallopt(M_DECAY_TIME, 1));
608 ASSERT_EQ(1, mallopt(M_DECAY_TIME, 0));
609 ASSERT_EQ(1, mallopt(M_DECAY_TIME, 1));
610 ASSERT_EQ(1, mallopt(M_DECAY_TIME, 0));
611#else
Elliott Hughesbcaa4542019-03-08 15:20:23 -0800612 GTEST_SKIP() << "bionic-only test";
Christopher Ferrisaf1b8dd2018-11-07 15:28:16 -0800613#endif
614}
615
616TEST(malloc, mallopt_purge) {
617#if defined(__BIONIC__)
Elliott Hughesbcaa4542019-03-08 15:20:23 -0800618 SKIP_WITH_HWASAN << "hwasan does not implement mallopt";
Christopher Ferrisaf1b8dd2018-11-07 15:28:16 -0800619 errno = 0;
620 ASSERT_EQ(1, mallopt(M_PURGE, 0));
621#else
Elliott Hughesbcaa4542019-03-08 15:20:23 -0800622 GTEST_SKIP() << "bionic-only test";
Christopher Ferrisaf1b8dd2018-11-07 15:28:16 -0800623#endif
624}
625
Elliott Hughesb1770852018-09-18 12:52:42 -0700626TEST(malloc, reallocarray_overflow) {
627#if HAVE_REALLOCARRAY
628 // Values that cause overflow to a result small enough (8 on LP64) that malloc would "succeed".
629 size_t a = static_cast<size_t>(INTPTR_MIN + 4);
630 size_t b = 2;
631
632 errno = 0;
633 ASSERT_TRUE(reallocarray(nullptr, a, b) == nullptr);
634 ASSERT_EQ(ENOMEM, errno);
635
636 errno = 0;
637 ASSERT_TRUE(reallocarray(nullptr, b, a) == nullptr);
638 ASSERT_EQ(ENOMEM, errno);
639#else
Elliott Hughesbcaa4542019-03-08 15:20:23 -0800640 GTEST_SKIP() << "reallocarray not available";
Elliott Hughesb1770852018-09-18 12:52:42 -0700641#endif
642}
643
644TEST(malloc, reallocarray) {
645#if HAVE_REALLOCARRAY
646 void* p = reallocarray(nullptr, 2, 32);
647 ASSERT_TRUE(p != nullptr);
648 ASSERT_GE(malloc_usable_size(p), 64U);
649#else
Elliott Hughesbcaa4542019-03-08 15:20:23 -0800650 GTEST_SKIP() << "reallocarray not available";
Elliott Hughesb1770852018-09-18 12:52:42 -0700651#endif
652}
Christopher Ferris09a19aa2018-11-16 13:28:56 -0800653
654TEST(malloc, mallinfo) {
655#if defined(__BIONIC__)
Elliott Hughesbcaa4542019-03-08 15:20:23 -0800656 SKIP_WITH_HWASAN << "hwasan does not implement mallinfo";
Christopher Ferris09a19aa2018-11-16 13:28:56 -0800657 static size_t sizes[] = {
658 8, 32, 128, 4096, 32768, 131072, 1024000, 10240000, 20480000, 300000000
659 };
660
661 constexpr static size_t kMaxAllocs = 50;
662
663 for (size_t size : sizes) {
664 // If some of these allocations are stuck in a thread cache, then keep
665 // looping until we make an allocation that changes the total size of the
666 // memory allocated.
667 // jemalloc implementations counts the thread cache allocations against
668 // total memory allocated.
669 void* ptrs[kMaxAllocs] = {};
670 bool pass = false;
671 for (size_t i = 0; i < kMaxAllocs; i++) {
672 size_t allocated = mallinfo().uordblks;
673 ptrs[i] = malloc(size);
674 ASSERT_TRUE(ptrs[i] != nullptr);
675 size_t new_allocated = mallinfo().uordblks;
676 if (allocated != new_allocated) {
677 size_t usable_size = malloc_usable_size(ptrs[i]);
Christopher Ferris4e562282019-02-07 14:20:03 -0800678 // Only check if the total got bigger by at least allocation size.
679 // Sometimes the mallinfo numbers can go backwards due to compaction
680 // and/or freeing of cached data.
681 if (new_allocated >= allocated + usable_size) {
682 pass = true;
683 break;
684 }
Christopher Ferris09a19aa2018-11-16 13:28:56 -0800685 }
686 }
687 for (void* ptr : ptrs) {
688 free(ptr);
689 }
690 ASSERT_TRUE(pass)
691 << "For size " << size << " allocated bytes did not increase after "
692 << kMaxAllocs << " allocations.";
693 }
694#else
Elliott Hughesbcaa4542019-03-08 15:20:23 -0800695 GTEST_SKIP() << "glibc is broken";
Christopher Ferris09a19aa2018-11-16 13:28:56 -0800696#endif
697}
Ryan Savitskiecc37e32018-12-14 15:57:21 +0000698
699TEST(android_mallopt, error_on_unexpected_option) {
700#if defined(__BIONIC__)
701 const int unrecognized_option = -1;
702 errno = 0;
703 EXPECT_EQ(false, android_mallopt(unrecognized_option, nullptr, 0));
704 EXPECT_EQ(ENOTSUP, errno);
705#else
Elliott Hughesbcaa4542019-03-08 15:20:23 -0800706 GTEST_SKIP() << "bionic-only test";
Ryan Savitskiecc37e32018-12-14 15:57:21 +0000707#endif
708}
709
Christopher Ferrise4cdbc42019-02-08 17:30:58 -0800710bool IsDynamic() {
711#if defined(__LP64__)
712 Elf64_Ehdr ehdr;
713#else
714 Elf32_Ehdr ehdr;
715#endif
716 std::string path(android::base::GetExecutablePath());
717
718 int fd = open(path.c_str(), O_RDONLY | O_CLOEXEC);
719 if (fd == -1) {
720 // Assume dynamic on error.
721 return true;
722 }
723 bool read_completed = android::base::ReadFully(fd, &ehdr, sizeof(ehdr));
724 close(fd);
725 // Assume dynamic in error cases.
726 return !read_completed || ehdr.e_type == ET_DYN;
727}
728
Ryan Savitskiecc37e32018-12-14 15:57:21 +0000729TEST(android_mallopt, init_zygote_child_profiling) {
730#if defined(__BIONIC__)
731 // Successful call.
732 errno = 0;
Christopher Ferrise4cdbc42019-02-08 17:30:58 -0800733 if (IsDynamic()) {
734 EXPECT_EQ(true, android_mallopt(M_INIT_ZYGOTE_CHILD_PROFILING, nullptr, 0));
735 EXPECT_EQ(0, errno);
736 } else {
737 // Not supported in static executables.
738 EXPECT_EQ(false, android_mallopt(M_INIT_ZYGOTE_CHILD_PROFILING, nullptr, 0));
739 EXPECT_EQ(ENOTSUP, errno);
740 }
Ryan Savitskiecc37e32018-12-14 15:57:21 +0000741
742 // Unexpected arguments rejected.
743 errno = 0;
744 char unexpected = 0;
745 EXPECT_EQ(false, android_mallopt(M_INIT_ZYGOTE_CHILD_PROFILING, &unexpected, 1));
Christopher Ferrise4cdbc42019-02-08 17:30:58 -0800746 if (IsDynamic()) {
747 EXPECT_EQ(EINVAL, errno);
748 } else {
749 EXPECT_EQ(ENOTSUP, errno);
750 }
Ryan Savitskiecc37e32018-12-14 15:57:21 +0000751#else
Elliott Hughesbcaa4542019-03-08 15:20:23 -0800752 GTEST_SKIP() << "bionic-only test";
Ryan Savitskiecc37e32018-12-14 15:57:21 +0000753#endif
754}
Christopher Ferris1fc5ccf2019-02-15 18:06:15 -0800755
756#if defined(__BIONIC__)
757template <typename FuncType>
758void CheckAllocationFunction(FuncType func) {
759 // Assumes that no more than 108MB of memory is allocated before this.
760 size_t limit = 128 * 1024 * 1024;
761 ASSERT_TRUE(android_mallopt(M_SET_ALLOCATION_LIMIT_BYTES, &limit, sizeof(limit)));
762 if (!func(20 * 1024 * 1024))
763 exit(1);
764 if (func(128 * 1024 * 1024))
765 exit(1);
766 exit(0);
767}
768#endif
769
770TEST(android_mallopt, set_allocation_limit) {
771#if defined(__BIONIC__)
772 EXPECT_EXIT(CheckAllocationFunction([](size_t bytes) { return calloc(bytes, 1) != nullptr; }),
773 testing::ExitedWithCode(0), "");
774 EXPECT_EXIT(CheckAllocationFunction([](size_t bytes) { return calloc(1, bytes) != nullptr; }),
775 testing::ExitedWithCode(0), "");
776 EXPECT_EXIT(CheckAllocationFunction([](size_t bytes) { return malloc(bytes) != nullptr; }),
777 testing::ExitedWithCode(0), "");
778 EXPECT_EXIT(CheckAllocationFunction(
779 [](size_t bytes) { return memalign(sizeof(void*), bytes) != nullptr; }),
780 testing::ExitedWithCode(0), "");
781 EXPECT_EXIT(CheckAllocationFunction([](size_t bytes) {
782 void* ptr;
783 return posix_memalign(&ptr, sizeof(void *), bytes) == 0;
784 }),
785 testing::ExitedWithCode(0), "");
786 EXPECT_EXIT(CheckAllocationFunction(
787 [](size_t bytes) { return aligned_alloc(sizeof(void*), bytes) != nullptr; }),
788 testing::ExitedWithCode(0), "");
789 EXPECT_EXIT(CheckAllocationFunction([](size_t bytes) {
790 void* p = malloc(1024 * 1024);
791 return realloc(p, bytes) != nullptr;
792 }),
793 testing::ExitedWithCode(0), "");
794#if !defined(__LP64__)
795 EXPECT_EXIT(CheckAllocationFunction([](size_t bytes) { return pvalloc(bytes) != nullptr; }),
796 testing::ExitedWithCode(0), "");
797 EXPECT_EXIT(CheckAllocationFunction([](size_t bytes) { return valloc(bytes) != nullptr; }),
798 testing::ExitedWithCode(0), "");
799#endif
800#else
Elliott Hughes10907202019-03-27 08:51:02 -0700801 GTEST_SKIP() << "bionic extension";
Christopher Ferris1fc5ccf2019-02-15 18:06:15 -0800802#endif
803}
804
805TEST(android_mallopt, set_allocation_limit_multiple) {
806#if defined(__BIONIC__)
807 // Only the first set should work.
808 size_t limit = 256 * 1024 * 1024;
809 ASSERT_TRUE(android_mallopt(M_SET_ALLOCATION_LIMIT_BYTES, &limit, sizeof(limit)));
810 limit = 32 * 1024 * 1024;
811 ASSERT_FALSE(android_mallopt(M_SET_ALLOCATION_LIMIT_BYTES, &limit, sizeof(limit)));
812#else
Elliott Hughes10907202019-03-27 08:51:02 -0700813 GTEST_SKIP() << "bionic extension";
Christopher Ferris1fc5ccf2019-02-15 18:06:15 -0800814#endif
815}
816
817#if defined(__BIONIC__)
818static constexpr size_t kAllocationSize = 8 * 1024 * 1024;
819
820static size_t GetMaxAllocations() {
821 size_t max_pointers = 0;
822 void* ptrs[20];
823 for (size_t i = 0; i < sizeof(ptrs) / sizeof(void*); i++) {
824 ptrs[i] = malloc(kAllocationSize);
825 if (ptrs[i] == nullptr) {
826 max_pointers = i;
827 break;
828 }
829 }
830 for (size_t i = 0; i < max_pointers; i++) {
831 free(ptrs[i]);
832 }
833 return max_pointers;
834}
835
836static void VerifyMaxPointers(size_t max_pointers) {
837 // Now verify that we can allocate the same number as before.
838 void* ptrs[20];
839 for (size_t i = 0; i < max_pointers; i++) {
840 ptrs[i] = malloc(kAllocationSize);
841 ASSERT_TRUE(ptrs[i] != nullptr) << "Failed to allocate on iteration " << i;
842 }
843
844 // Make sure the next allocation still fails.
845 ASSERT_TRUE(malloc(kAllocationSize) == nullptr);
846 for (size_t i = 0; i < max_pointers; i++) {
847 free(ptrs[i]);
848 }
849}
850#endif
851
852TEST(android_mallopt, set_allocation_limit_realloc_increase) {
853#if defined(__BIONIC__)
854 size_t limit = 128 * 1024 * 1024;
855 ASSERT_TRUE(android_mallopt(M_SET_ALLOCATION_LIMIT_BYTES, &limit, sizeof(limit)));
856
857 size_t max_pointers = GetMaxAllocations();
858 ASSERT_TRUE(max_pointers != 0) << "Limit never reached.";
859
860 void* memory = malloc(10 * 1024 * 1024);
861 ASSERT_TRUE(memory != nullptr);
862
863 // Increase size.
864 memory = realloc(memory, 20 * 1024 * 1024);
865 ASSERT_TRUE(memory != nullptr);
866 memory = realloc(memory, 40 * 1024 * 1024);
867 ASSERT_TRUE(memory != nullptr);
868 memory = realloc(memory, 60 * 1024 * 1024);
869 ASSERT_TRUE(memory != nullptr);
870 memory = realloc(memory, 80 * 1024 * 1024);
871 ASSERT_TRUE(memory != nullptr);
872 // Now push past limit.
873 memory = realloc(memory, 130 * 1024 * 1024);
874 ASSERT_TRUE(memory == nullptr);
875
876 VerifyMaxPointers(max_pointers);
877#else
Elliott Hughes10907202019-03-27 08:51:02 -0700878 GTEST_SKIP() << "bionic extension";
Christopher Ferris1fc5ccf2019-02-15 18:06:15 -0800879#endif
880}
881
882TEST(android_mallopt, set_allocation_limit_realloc_decrease) {
883#if defined(__BIONIC__)
884 size_t limit = 100 * 1024 * 1024;
885 ASSERT_TRUE(android_mallopt(M_SET_ALLOCATION_LIMIT_BYTES, &limit, sizeof(limit)));
886
887 size_t max_pointers = GetMaxAllocations();
888 ASSERT_TRUE(max_pointers != 0) << "Limit never reached.";
889
890 void* memory = malloc(80 * 1024 * 1024);
891 ASSERT_TRUE(memory != nullptr);
892
893 // Decrease size.
894 memory = realloc(memory, 60 * 1024 * 1024);
895 ASSERT_TRUE(memory != nullptr);
896 memory = realloc(memory, 40 * 1024 * 1024);
897 ASSERT_TRUE(memory != nullptr);
898 memory = realloc(memory, 20 * 1024 * 1024);
899 ASSERT_TRUE(memory != nullptr);
900 memory = realloc(memory, 10 * 1024 * 1024);
901 ASSERT_TRUE(memory != nullptr);
902 free(memory);
903
904 VerifyMaxPointers(max_pointers);
905#else
Elliott Hughes10907202019-03-27 08:51:02 -0700906 GTEST_SKIP() << "bionic extension";
Christopher Ferris1fc5ccf2019-02-15 18:06:15 -0800907#endif
908}
909
910TEST(android_mallopt, set_allocation_limit_realloc_free) {
911#if defined(__BIONIC__)
912 size_t limit = 100 * 1024 * 1024;
913 ASSERT_TRUE(android_mallopt(M_SET_ALLOCATION_LIMIT_BYTES, &limit, sizeof(limit)));
914
915 size_t max_pointers = GetMaxAllocations();
916 ASSERT_TRUE(max_pointers != 0) << "Limit never reached.";
917
918 void* memory = malloc(60 * 1024 * 1024);
919 ASSERT_TRUE(memory != nullptr);
920
921 memory = realloc(memory, 0);
922 ASSERT_TRUE(memory == nullptr);
923
924 VerifyMaxPointers(max_pointers);
925#else
Elliott Hughes10907202019-03-27 08:51:02 -0700926 GTEST_SKIP() << "bionic extension";
Christopher Ferris1fc5ccf2019-02-15 18:06:15 -0800927#endif
928}
929
930#if defined(__BIONIC__)
931static void* SetAllocationLimit(void* data) {
932 std::atomic_bool* go = reinterpret_cast<std::atomic_bool*>(data);
933 while (!go->load()) {
934 }
935 size_t limit = 500 * 1024 * 1024;
936 if (android_mallopt(M_SET_ALLOCATION_LIMIT_BYTES, &limit, sizeof(limit))) {
937 return reinterpret_cast<void*>(-1);
938 }
939 return nullptr;
940}
941
942static void SetAllocationLimitMultipleThreads() {
943 std::atomic_bool go;
944 go = false;
945
946 static constexpr size_t kNumThreads = 4;
947 pthread_t threads[kNumThreads];
948 for (size_t i = 0; i < kNumThreads; i++) {
949 ASSERT_EQ(0, pthread_create(&threads[i], nullptr, SetAllocationLimit, &go));
950 }
951
952 // Let them go all at once.
953 go = true;
954 ASSERT_EQ(0, kill(getpid(), __SIGRTMIN + 4));
955
956 size_t num_successful = 0;
957 for (size_t i = 0; i < kNumThreads; i++) {
958 void* result;
959 ASSERT_EQ(0, pthread_join(threads[i], &result));
960 if (result != nullptr) {
961 num_successful++;
962 }
963 }
964 ASSERT_EQ(1U, num_successful);
965 exit(0);
966}
967#endif
968
969TEST(android_mallopt, set_allocation_limit_multiple_threads) {
970#if defined(__BIONIC__)
971 if (IsDynamic()) {
972 ASSERT_TRUE(android_mallopt(M_INIT_ZYGOTE_CHILD_PROFILING, nullptr, 0));
973 }
974
975 // Run this a number of times as a stress test.
976 for (size_t i = 0; i < 100; i++) {
977 // Not using ASSERT_EXIT because errors messages are not displayed.
978 pid_t pid;
979 if ((pid = fork()) == 0) {
980 ASSERT_NO_FATAL_FAILURE(SetAllocationLimitMultipleThreads());
981 }
982 ASSERT_NE(-1, pid);
983 int status;
984 ASSERT_EQ(pid, wait(&status));
985 ASSERT_EQ(0, WEXITSTATUS(status));
986 }
987#else
Elliott Hughes10907202019-03-27 08:51:02 -0700988 GTEST_SKIP() << "bionic extension";
Christopher Ferris1fc5ccf2019-02-15 18:06:15 -0800989#endif
990}