1 //===-- sanitizer_common_test.cpp -----------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file is a part of ThreadSanitizer/AddressSanitizer runtime. 10 // 11 //===----------------------------------------------------------------------===// 12 #include <algorithm> 13 14 #include "sanitizer_common/sanitizer_allocator_internal.h" 15 #include "sanitizer_common/sanitizer_common.h" 16 #include "sanitizer_common/sanitizer_file.h" 17 #include "sanitizer_common/sanitizer_flags.h" 18 #include "sanitizer_common/sanitizer_libc.h" 19 #include "sanitizer_common/sanitizer_platform.h" 20 21 #include "sanitizer_pthread_wrappers.h" 22 23 #include "gtest/gtest.h" 24 25 namespace __sanitizer { 26 27 static bool IsSorted(const uptr *array, uptr n) { 28 for (uptr i = 1; i < n; i++) { 29 if (array[i] < array[i - 1]) return false; 30 } 31 return true; 32 } 33 34 TEST(SanitizerCommon, SortTest) { 35 uptr array[100]; 36 uptr n = 100; 37 // Already sorted. 38 for (uptr i = 0; i < n; i++) { 39 array[i] = i; 40 } 41 Sort(array, n); 42 EXPECT_TRUE(IsSorted(array, n)); 43 // Reverse order. 44 for (uptr i = 0; i < n; i++) { 45 array[i] = n - 1 - i; 46 } 47 Sort(array, n); 48 EXPECT_TRUE(IsSorted(array, n)); 49 // Mixed order. 50 for (uptr i = 0; i < n; i++) { 51 array[i] = (i % 2 == 0) ? i : n - 1 - i; 52 } 53 Sort(array, n); 54 EXPECT_TRUE(IsSorted(array, n)); 55 // All equal. 56 for (uptr i = 0; i < n; i++) { 57 array[i] = 42; 58 } 59 Sort(array, n); 60 EXPECT_TRUE(IsSorted(array, n)); 61 // All but one sorted. 62 for (uptr i = 0; i < n - 1; i++) { 63 array[i] = i; 64 } 65 array[n - 1] = 42; 66 Sort(array, n); 67 EXPECT_TRUE(IsSorted(array, n)); 68 // Minimal case - sort three elements. 69 array[0] = 1; 70 array[1] = 0; 71 Sort(array, 2); 72 EXPECT_TRUE(IsSorted(array, 2)); 73 } 74 75 TEST(SanitizerCommon, MmapAlignedOrDieOnFatalError) { 76 uptr PageSize = GetPageSizeCached(); 77 for (uptr size = 1; size <= 32; size *= 2) { 78 for (uptr alignment = 1; alignment <= 32; alignment *= 2) { 79 for (int iter = 0; iter < 100; iter++) { 80 uptr res = (uptr)MmapAlignedOrDieOnFatalError( 81 size * PageSize, alignment * PageSize, "MmapAlignedOrDieTest"); 82 EXPECT_EQ(0U, res % (alignment * PageSize)); 83 internal_memset((void*)res, 1, size * PageSize); 84 UnmapOrDie((void*)res, size * PageSize); 85 } 86 } 87 } 88 } 89 90 TEST(SanitizerCommon, Mprotect) { 91 uptr PageSize = GetPageSizeCached(); 92 u8 *mem = reinterpret_cast<u8 *>(MmapOrDie(PageSize, "MprotectTest")); 93 for (u8 *p = mem; p < mem + PageSize; ++p) ++(*p); 94 95 MprotectReadOnly(reinterpret_cast<uptr>(mem), PageSize); 96 for (u8 *p = mem; p < mem + PageSize; ++p) EXPECT_EQ(1u, *p); 97 EXPECT_DEATH(++mem[0], ""); 98 EXPECT_DEATH(++mem[PageSize / 2], ""); 99 EXPECT_DEATH(++mem[PageSize - 1], ""); 100 101 MprotectNoAccess(reinterpret_cast<uptr>(mem), PageSize); 102 volatile u8 t; 103 (void)t; 104 EXPECT_DEATH(t = mem[0], ""); 105 EXPECT_DEATH(t = mem[PageSize / 2], ""); 106 EXPECT_DEATH(t = mem[PageSize - 1], ""); 107 } 108 109 TEST(SanitizerCommon, InternalMmapVectorRoundUpCapacity) { 110 InternalMmapVector<uptr> v; 111 v.reserve(1); 112 CHECK_EQ(v.capacity(), GetPageSizeCached() / sizeof(uptr)); 113 } 114 115 TEST(SanitizerCommon, InternalMmapVectorReize) { 116 InternalMmapVector<uptr> v; 117 CHECK_EQ(0U, v.size()); 118 CHECK_GE(v.capacity(), v.size()); 119 120 v.reserve(1000); 121 CHECK_EQ(0U, v.size()); 122 CHECK_GE(v.capacity(), 1000U); 123 124 v.resize(10000); 125 CHECK_EQ(10000U, v.size()); 126 CHECK_GE(v.capacity(), v.size()); 127 uptr cap = v.capacity(); 128 129 v.resize(100); 130 CHECK_EQ(100U, v.size()); 131 CHECK_EQ(v.capacity(), cap); 132 133 v.reserve(10); 134 CHECK_EQ(100U, v.size()); 135 CHECK_EQ(v.capacity(), cap); 136 } 137 138 TEST(SanitizerCommon, InternalMmapVector) { 139 InternalMmapVector<uptr> vector; 140 for (uptr i = 0; i < 100; i++) { 141 EXPECT_EQ(i, vector.size()); 142 vector.push_back(i); 143 } 144 for (uptr i = 0; i < 100; i++) { 145 EXPECT_EQ(i, vector[i]); 146 } 147 for (int i = 99; i >= 0; i--) { 148 EXPECT_EQ((uptr)i, vector.back()); 149 vector.pop_back(); 150 EXPECT_EQ((uptr)i, vector.size()); 151 } 152 InternalMmapVector<uptr> empty_vector; 153 CHECK_EQ(empty_vector.capacity(), 0U); 154 CHECK_EQ(0U, empty_vector.size()); 155 } 156 157 TEST(SanitizerCommon, InternalMmapVectorEq) { 158 InternalMmapVector<uptr> vector1; 159 InternalMmapVector<uptr> vector2; 160 for (uptr i = 0; i < 100; i++) { 161 vector1.push_back(i); 162 vector2.push_back(i); 163 } 164 EXPECT_TRUE(vector1 == vector2); 165 EXPECT_FALSE(vector1 != vector2); 166 167 vector1.push_back(1); 168 EXPECT_FALSE(vector1 == vector2); 169 EXPECT_TRUE(vector1 != vector2); 170 171 vector2.push_back(1); 172 EXPECT_TRUE(vector1 == vector2); 173 EXPECT_FALSE(vector1 != vector2); 174 175 vector1[55] = 1; 176 EXPECT_FALSE(vector1 == vector2); 177 EXPECT_TRUE(vector1 != vector2); 178 } 179 180 TEST(SanitizerCommon, InternalMmapVectorSwap) { 181 InternalMmapVector<uptr> vector1; 182 InternalMmapVector<uptr> vector2; 183 InternalMmapVector<uptr> vector3; 184 InternalMmapVector<uptr> vector4; 185 for (uptr i = 0; i < 100; i++) { 186 vector1.push_back(i); 187 vector2.push_back(i); 188 vector3.push_back(-i); 189 vector4.push_back(-i); 190 } 191 EXPECT_NE(vector2, vector3); 192 EXPECT_NE(vector1, vector4); 193 vector1.swap(vector3); 194 EXPECT_EQ(vector2, vector3); 195 EXPECT_EQ(vector1, vector4); 196 } 197 198 void TestThreadInfo(bool main) { 199 uptr stk_addr = 0; 200 uptr stk_size = 0; 201 uptr tls_addr = 0; 202 uptr tls_size = 0; 203 GetThreadStackAndTls(main, &stk_addr, &stk_size, &tls_addr, &tls_size); 204 205 int stack_var; 206 EXPECT_NE(stk_addr, (uptr)0); 207 EXPECT_NE(stk_size, (uptr)0); 208 EXPECT_GT((uptr)&stack_var, stk_addr); 209 EXPECT_LT((uptr)&stack_var, stk_addr + stk_size); 210 211 #if SANITIZER_LINUX && defined(__x86_64__) 212 static __thread int thread_var; 213 EXPECT_NE(tls_addr, (uptr)0); 214 EXPECT_NE(tls_size, (uptr)0); 215 EXPECT_GT((uptr)&thread_var, tls_addr); 216 EXPECT_LT((uptr)&thread_var, tls_addr + tls_size); 217 218 // Ensure that tls and stack do not intersect. 219 uptr tls_end = tls_addr + tls_size; 220 EXPECT_TRUE(tls_addr < stk_addr || tls_addr >= stk_addr + stk_size); 221 EXPECT_TRUE(tls_end < stk_addr || tls_end >= stk_addr + stk_size); 222 EXPECT_TRUE((tls_addr < stk_addr) == (tls_end < stk_addr)); 223 #endif 224 } 225 226 static void *WorkerThread(void *arg) { 227 TestThreadInfo(false); 228 return 0; 229 } 230 231 TEST(SanitizerCommon, ThreadStackTlsMain) { 232 InitTlsSize(); 233 TestThreadInfo(true); 234 } 235 236 TEST(SanitizerCommon, ThreadStackTlsWorker) { 237 InitTlsSize(); 238 pthread_t t; 239 PTHREAD_CREATE(&t, 0, WorkerThread, 0); 240 PTHREAD_JOIN(t, 0); 241 } 242 243 bool UptrLess(uptr a, uptr b) { 244 return a < b; 245 } 246 247 TEST(SanitizerCommon, InternalLowerBound) { 248 std::vector<int> arr = {1, 3, 5, 7, 11}; 249 250 EXPECT_EQ(0u, InternalLowerBound(arr, 0)); 251 EXPECT_EQ(0u, InternalLowerBound(arr, 1)); 252 EXPECT_EQ(1u, InternalLowerBound(arr, 2)); 253 EXPECT_EQ(1u, InternalLowerBound(arr, 3)); 254 EXPECT_EQ(2u, InternalLowerBound(arr, 4)); 255 EXPECT_EQ(2u, InternalLowerBound(arr, 5)); 256 EXPECT_EQ(3u, InternalLowerBound(arr, 6)); 257 EXPECT_EQ(3u, InternalLowerBound(arr, 7)); 258 EXPECT_EQ(4u, InternalLowerBound(arr, 8)); 259 EXPECT_EQ(4u, InternalLowerBound(arr, 9)); 260 EXPECT_EQ(4u, InternalLowerBound(arr, 10)); 261 EXPECT_EQ(4u, InternalLowerBound(arr, 11)); 262 EXPECT_EQ(5u, InternalLowerBound(arr, 12)); 263 } 264 265 TEST(SanitizerCommon, InternalLowerBoundVsStdLowerBound) { 266 std::vector<int> data; 267 auto create_item = [] (size_t i, size_t j) { 268 auto v = i * 10000 + j; 269 return ((v << 6) + (v >> 6) + 0x9e3779b9) % 100; 270 }; 271 for (size_t i = 0; i < 1000; ++i) { 272 data.resize(i); 273 for (size_t j = 0; j < i; ++j) { 274 data[j] = create_item(i, j); 275 } 276 277 std::sort(data.begin(), data.end()); 278 279 for (size_t j = 0; j < i; ++j) { 280 int val = create_item(i, j); 281 for (auto to_find : {val - 1, val, val + 1}) { 282 uptr expected = 283 std::lower_bound(data.begin(), data.end(), to_find) - data.begin(); 284 EXPECT_EQ(expected, 285 InternalLowerBound(data, to_find, std::less<int>())); 286 } 287 } 288 } 289 } 290 291 class SortAndDedupTest : public ::testing::TestWithParam<std::vector<int>> {}; 292 293 TEST_P(SortAndDedupTest, SortAndDedup) { 294 std::vector<int> v_std = GetParam(); 295 std::sort(v_std.begin(), v_std.end()); 296 v_std.erase(std::unique(v_std.begin(), v_std.end()), v_std.end()); 297 298 std::vector<int> v = GetParam(); 299 SortAndDedup(v); 300 301 EXPECT_EQ(v_std, v); 302 } 303 304 const std::vector<int> kSortAndDedupTests[] = { 305 {}, 306 {1}, 307 {1, 1}, 308 {1, 1, 1}, 309 {1, 2, 3}, 310 {3, 2, 1}, 311 {1, 2, 2, 3}, 312 {3, 3, 2, 1, 2}, 313 {3, 3, 2, 1, 2}, 314 {1, 2, 1, 1, 2, 1, 1, 1, 2, 2}, 315 {1, 3, 3, 2, 3, 1, 3, 1, 4, 4, 2, 1, 4, 1, 1, 2, 2}, 316 }; 317 INSTANTIATE_TEST_SUITE_P(SortAndDedupTest, SortAndDedupTest, 318 ::testing::ValuesIn(kSortAndDedupTests)); 319 320 #if SANITIZER_LINUX && !SANITIZER_ANDROID 321 TEST(SanitizerCommon, FindPathToBinary) { 322 char *true_path = FindPathToBinary("true"); 323 EXPECT_NE((char*)0, internal_strstr(true_path, "/bin/true")); 324 InternalFree(true_path); 325 EXPECT_EQ(0, FindPathToBinary("unexisting_binary.ergjeorj")); 326 } 327 #elif SANITIZER_WINDOWS 328 TEST(SanitizerCommon, FindPathToBinary) { 329 // ntdll.dll should be on PATH in all supported test environments on all 330 // supported Windows versions. 331 char *ntdll_path = FindPathToBinary("ntdll.dll"); 332 EXPECT_NE((char*)0, internal_strstr(ntdll_path, "ntdll.dll")); 333 InternalFree(ntdll_path); 334 EXPECT_EQ(0, FindPathToBinary("unexisting_binary.ergjeorj")); 335 } 336 #endif 337 338 TEST(SanitizerCommon, StripPathPrefix) { 339 EXPECT_EQ(0, StripPathPrefix(0, "prefix")); 340 EXPECT_STREQ("foo", StripPathPrefix("foo", 0)); 341 EXPECT_STREQ("dir/file.cc", 342 StripPathPrefix("/usr/lib/dir/file.cc", "/usr/lib/")); 343 EXPECT_STREQ("/file.cc", StripPathPrefix("/usr/myroot/file.cc", "/myroot")); 344 EXPECT_STREQ("file.h", StripPathPrefix("/usr/lib/./file.h", "/usr/lib/")); 345 } 346 347 TEST(SanitizerCommon, RemoveANSIEscapeSequencesFromString) { 348 RemoveANSIEscapeSequencesFromString(nullptr); 349 const char *buffs[22] = { 350 "Default", "Default", 351 "\033[95mLight magenta", "Light magenta", 352 "\033[30mBlack\033[32mGreen\033[90mGray", "BlackGreenGray", 353 "\033[106mLight cyan \033[107mWhite ", "Light cyan White ", 354 "\033[31mHello\033[0m World", "Hello World", 355 "\033[38;5;82mHello \033[38;5;198mWorld", "Hello World", 356 "123[653456789012", "123[653456789012", 357 "Normal \033[5mBlink \033[25mNormal", "Normal Blink Normal", 358 "\033[106m\033[107m", "", 359 "", "", 360 " ", " ", 361 }; 362 363 for (size_t i = 0; i < ARRAY_SIZE(buffs); i+=2) { 364 char *buffer_copy = internal_strdup(buffs[i]); 365 RemoveANSIEscapeSequencesFromString(buffer_copy); 366 EXPECT_STREQ(buffer_copy, buffs[i+1]); 367 InternalFree(buffer_copy); 368 } 369 } 370 371 TEST(SanitizerCommon, InternalScopedString) { 372 InternalScopedString str; 373 EXPECT_EQ(0U, str.length()); 374 EXPECT_STREQ("", str.data()); 375 376 str.append("foo"); 377 EXPECT_EQ(3U, str.length()); 378 EXPECT_STREQ("foo", str.data()); 379 380 int x = 1234; 381 str.append("%d", x); 382 EXPECT_EQ(7U, str.length()); 383 EXPECT_STREQ("foo1234", str.data()); 384 385 str.append("%d", x); 386 EXPECT_EQ(11U, str.length()); 387 EXPECT_STREQ("foo12341234", str.data()); 388 389 str.clear(); 390 EXPECT_EQ(0U, str.length()); 391 EXPECT_STREQ("", str.data()); 392 } 393 394 TEST(SanitizerCommon, InternalScopedStringLarge) { 395 InternalScopedString str; 396 std::string expected; 397 for (int i = 0; i < 1000; ++i) { 398 std::string append(i, 'a' + i % 26); 399 expected += append; 400 str.append("%s", append.c_str()); 401 EXPECT_EQ(expected, str.data()); 402 } 403 } 404 405 TEST(SanitizerCommon, InternalScopedStringLargeFormat) { 406 InternalScopedString str; 407 std::string expected; 408 for (int i = 0; i < 1000; ++i) { 409 std::string append(i, 'a' + i % 26); 410 expected += append; 411 str.append("%s", append.c_str()); 412 EXPECT_EQ(expected, str.data()); 413 } 414 } 415 416 #if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_MAC || SANITIZER_IOS 417 TEST(SanitizerCommon, GetRandom) { 418 u8 buffer_1[32], buffer_2[32]; 419 for (bool blocking : { false, true }) { 420 EXPECT_FALSE(GetRandom(nullptr, 32, blocking)); 421 EXPECT_FALSE(GetRandom(buffer_1, 0, blocking)); 422 EXPECT_FALSE(GetRandom(buffer_1, 512, blocking)); 423 EXPECT_EQ(ARRAY_SIZE(buffer_1), ARRAY_SIZE(buffer_2)); 424 for (uptr size = 4; size <= ARRAY_SIZE(buffer_1); size += 4) { 425 for (uptr i = 0; i < 100; i++) { 426 EXPECT_TRUE(GetRandom(buffer_1, size, blocking)); 427 EXPECT_TRUE(GetRandom(buffer_2, size, blocking)); 428 EXPECT_NE(internal_memcmp(buffer_1, buffer_2, size), 0); 429 } 430 } 431 } 432 } 433 #endif 434 435 TEST(SanitizerCommon, ReservedAddressRangeInit) { 436 uptr init_size = 0xffff; 437 ReservedAddressRange address_range; 438 uptr res = address_range.Init(init_size); 439 CHECK_NE(res, (void*)-1); 440 UnmapOrDie((void*)res, init_size); 441 // Should be able to map into the same space now. 442 ReservedAddressRange address_range2; 443 uptr res2 = address_range2.Init(init_size, nullptr, res); 444 CHECK_EQ(res, res2); 445 446 // TODO(flowerhack): Once this is switched to the "real" implementation 447 // (rather than passing through to MmapNoAccess*), enforce and test "no 448 // double initializations allowed" 449 } 450 451 TEST(SanitizerCommon, ReservedAddressRangeMap) { 452 constexpr uptr init_size = 0xffff; 453 ReservedAddressRange address_range; 454 uptr res = address_range.Init(init_size); 455 CHECK_NE(res, (void*) -1); 456 457 // Valid mappings should succeed. 458 CHECK_EQ(res, address_range.Map(res, init_size)); 459 460 // Valid mappings should be readable. 461 unsigned char buffer[init_size]; 462 memcpy(buffer, reinterpret_cast<void *>(res), init_size); 463 464 // TODO(flowerhack): Once this is switched to the "real" implementation, make 465 // sure you can only mmap into offsets in the Init range. 466 } 467 468 TEST(SanitizerCommon, ReservedAddressRangeUnmap) { 469 uptr PageSize = GetPageSizeCached(); 470 uptr init_size = PageSize * 8; 471 ReservedAddressRange address_range; 472 uptr base_addr = address_range.Init(init_size); 473 CHECK_NE(base_addr, (void*)-1); 474 CHECK_EQ(base_addr, address_range.Map(base_addr, init_size)); 475 476 // Unmapping the entire range should succeed. 477 address_range.Unmap(base_addr, init_size); 478 479 // Map a new range. 480 base_addr = address_range.Init(init_size); 481 CHECK_EQ(base_addr, address_range.Map(base_addr, init_size)); 482 483 // Windows doesn't allow partial unmappings. 484 #if !SANITIZER_WINDOWS 485 486 // Unmapping at the beginning should succeed. 487 address_range.Unmap(base_addr, PageSize); 488 489 // Unmapping at the end should succeed. 490 uptr new_start = reinterpret_cast<uptr>(address_range.base()) + 491 address_range.size() - PageSize; 492 address_range.Unmap(new_start, PageSize); 493 494 #endif 495 496 // Unmapping in the middle of the ReservedAddressRange should fail. 497 EXPECT_DEATH(address_range.Unmap(base_addr + (PageSize * 2), PageSize), ".*"); 498 } 499 500 TEST(SanitizerCommon, ReadBinaryNameCached) { 501 char buf[256]; 502 EXPECT_NE((uptr)0, ReadBinaryNameCached(buf, sizeof(buf))); 503 } 504 505 } // namespace __sanitizer 506