From 3bae40b27932b8940f408649d93b6236416507ae Mon Sep 17 00:00:00 2001 From: Christopher Ferris Date: Fri, 16 Aug 2019 10:49:34 -0700 Subject: [PATCH] Add ReadMapFileAsyncSafe function. This is a function designed so that it doesn't do any allocations. It's purpose is for testing allocation related code where doing an allocation can disturb the test. Added unit tests for the new code that disable memory allocations before running. Also, made the tests run in isolation mode since I added a bunch of tests and this will keep the total runtime about the same as before. Bug: 137795072 Test: All unit tests pass. Change-Id: I7645f1e9f88cdfbc57c8eebce80199b9cfae64c1 --- libprocinfo/Android.bp | 2 + libprocinfo/include/procinfo/process_map.h | 4 + libprocinfo/process_map.cpp | 97 +++++++++ libprocinfo/process_map_test.cpp | 217 +++++++++++++++++++++ 4 files changed, 320 insertions(+) create mode 100644 libprocinfo/process_map.cpp diff --git a/libprocinfo/Android.bp b/libprocinfo/Android.bp index 15f03d080..0c9a2b8a8 100644 --- a/libprocinfo/Android.bp +++ b/libprocinfo/Android.bp @@ -34,6 +34,7 @@ cc_library { host_supported: true, srcs: [ "process.cpp", + "process_map.cpp", ], local_include_dirs: ["include"], @@ -58,6 +59,7 @@ cc_test { name: "libprocinfo_test", defaults: ["libprocinfo_defaults"], host_supported: true, + isolated: true, srcs: [ "process_test.cpp", "process_map_test.cpp", diff --git a/libprocinfo/include/procinfo/process_map.h b/libprocinfo/include/procinfo/process_map.h index b6ec3cbce..569a02221 100644 --- a/libprocinfo/include/procinfo/process_map.h +++ b/libprocinfo/include/procinfo/process_map.h @@ -176,5 +176,9 @@ inline bool ReadProcessMaps(pid_t pid, std::vector* maps) { const char* name) { maps->emplace_back(start, end, flags, pgoff, inode, name); }); } +bool ReadMapFileAsyncSafe(const char* map_file, void* buffer, size_t buffer_size, + const std::function& callback); + } /* namespace procinfo */ } /* namespace android */ diff --git a/libprocinfo/process_map.cpp b/libprocinfo/process_map.cpp new file mode 100644 index 000000000..5e240b99f --- /dev/null +++ b/libprocinfo/process_map.cpp @@ -0,0 +1,97 @@ +/* + * Copyright (C) 2019 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include +#include +#include + +#include + +namespace android { +namespace procinfo { + +bool ReadMapFileAsyncSafe(const char* map_file, void* buffer, size_t buffer_size, + const std::function& callback) { + if (buffer == nullptr || buffer_size == 0) { + return false; + } + + int fd = open(map_file, O_RDONLY | O_CLOEXEC); + if (fd == -1) { + return false; + } + + char* char_buffer = reinterpret_cast(buffer); + size_t start = 0; + size_t read_bytes = 0; + char* line = nullptr; + bool read_complete = false; + while (true) { + ssize_t bytes = + TEMP_FAILURE_RETRY(read(fd, char_buffer + read_bytes, buffer_size - read_bytes - 1)); + if (bytes <= 0) { + if (read_bytes == 0) { + close(fd); + return bytes == 0; + } + // Treat the last piece of data as the last line. + char_buffer[start + read_bytes] = '\n'; + bytes = 1; + read_complete = true; + } + read_bytes += bytes; + + while (read_bytes > 0) { + char* newline = reinterpret_cast(memchr(&char_buffer[start], '\n', read_bytes)); + if (newline == nullptr) { + break; + } + *newline = '\0'; + line = &char_buffer[start]; + start = newline - char_buffer + 1; + read_bytes -= newline - line + 1; + + // Ignore the return code, errors are okay. + ReadMapFileContent(line, callback); + } + + if (read_complete) { + close(fd); + return true; + } + + if (start == 0 && read_bytes == buffer_size - 1) { + // The buffer provided is too small to contain this line, give up + // and indicate failure. + close(fd); + return false; + } + + // Copy any leftover data to the front of the buffer. + if (start > 0) { + if (read_bytes > 0) { + memmove(char_buffer, &char_buffer[start], read_bytes); + } + start = 0; + } + } +} + +} /* namespace procinfo */ +} /* namespace android */ diff --git a/libprocinfo/process_map_test.cpp b/libprocinfo/process_map_test.cpp index 562d864fe..b1bdc08a5 100644 --- a/libprocinfo/process_map_test.cpp +++ b/libprocinfo/process_map_test.cpp @@ -16,9 +16,14 @@ #include +#include +#include + #include +#include #include +#include #include @@ -63,3 +68,215 @@ TEST(process_map, ReadProcessMaps) { ASSERT_TRUE(android::procinfo::ReadProcessMaps(getpid(), &maps)); ASSERT_GT(maps.size(), 0u); } + +extern "C" void malloc_disable(); +extern "C" void malloc_enable(); + +struct TestMapInfo { + TestMapInfo() = default; + TestMapInfo(uint64_t start, uint64_t end, uint16_t flags, uint64_t pgoff, ino_t inode, + const char* new_name) + : start(start), end(end), flags(flags), pgoff(pgoff), inode(inode) { + strcpy(name, new_name); + } + uint64_t start = 0; + uint64_t end = 0; + uint16_t flags = 0; + uint64_t pgoff = 0; + ino_t inode = 0; + char name[100] = {}; +}; + +void VerifyReadMapFileAsyncSafe(const char* maps_data, + const std::vector& expected_info) { + TemporaryFile tf; + ASSERT_TRUE(android::base::WriteStringToFd(maps_data, tf.fd)); + + std::vector saved_info(expected_info.size()); + size_t num_maps = 0; + + auto callback = [&](uint64_t start, uint64_t end, uint16_t flags, uint64_t pgoff, ino_t inode, + const char* name) { + if (num_maps != saved_info.size()) { + TestMapInfo& saved = saved_info[num_maps]; + saved.start = start; + saved.end = end; + saved.flags = flags; + saved.pgoff = pgoff; + saved.inode = inode; + strcpy(saved.name, name); + } + num_maps++; + }; + + std::vector buffer(64 * 1024); + +#if defined(__BIONIC__) + // Any allocations will block after this call. + malloc_disable(); +#endif + + bool parsed = + android::procinfo::ReadMapFileAsyncSafe(tf.path, buffer.data(), buffer.size(), callback); + +#if defined(__BIONIC__) + malloc_enable(); +#endif + + ASSERT_TRUE(parsed) << "Parsing of data failed:\n" << maps_data; + ASSERT_EQ(expected_info.size(), num_maps); + for (size_t i = 0; i < expected_info.size(); i++) { + const TestMapInfo& expected = expected_info[i]; + const TestMapInfo& saved = saved_info[i]; + EXPECT_EQ(expected.start, saved.start); + EXPECT_EQ(expected.end, saved.end); + EXPECT_EQ(expected.flags, saved.flags); + EXPECT_EQ(expected.pgoff, saved.pgoff); + EXPECT_EQ(expected.inode, saved.inode); + EXPECT_STREQ(expected.name, saved.name); + } +} + +TEST(process_map, ReadMapFileAsyncSafe_invalid) { + std::vector expected_info; + + VerifyReadMapFileAsyncSafe("12c00000-2ac00000", expected_info); +} + +TEST(process_map, ReadMapFileAsyncSafe_single) { + std::vector expected_info; + expected_info.emplace_back(0x12c00000, 0x2ac00000, PROT_READ | PROT_WRITE, 0x100, 10267643, + "/lib/fake.so"); + + VerifyReadMapFileAsyncSafe("12c00000-2ac00000 rw-p 00000100 00:05 10267643 /lib/fake.so", + expected_info); +} + +TEST(process_map, ReadMapFileAsyncSafe_single_with_newline) { + std::vector expected_info; + expected_info.emplace_back(0x12c00000, 0x2ac00000, PROT_READ | PROT_WRITE, 0x100, 10267643, + "/lib/fake.so"); + + VerifyReadMapFileAsyncSafe("12c00000-2ac00000 rw-p 00000100 00:05 10267643 /lib/fake.so\n", + expected_info); +} + +TEST(process_map, ReadMapFileAsyncSafe_single_no_library) { + std::vector expected_info; + expected_info.emplace_back(0xa0000, 0xc0000, PROT_READ | PROT_WRITE | PROT_EXEC, 0xb00, 101, ""); + + VerifyReadMapFileAsyncSafe("a0000-c0000 rwxp 00000b00 00:05 101", expected_info); +} + +TEST(process_map, ReadMapFileAsyncSafe_multiple) { + std::vector expected_info; + expected_info.emplace_back(0xa0000, 0xc0000, PROT_READ | PROT_WRITE | PROT_EXEC, 1, 100, ""); + expected_info.emplace_back(0xd0000, 0xe0000, PROT_READ, 2, 101, "/lib/libsomething1.so"); + expected_info.emplace_back(0xf0000, 0x100000, PROT_WRITE, 3, 102, "/lib/libsomething2.so"); + expected_info.emplace_back(0x110000, 0x120000, PROT_EXEC, 4, 103, "[anon:something or another]"); + + std::string map_data = + "0a0000-0c0000 rwxp 00000001 00:05 100\n" + "0d0000-0e0000 r--p 00000002 00:05 101 /lib/libsomething1.so\n" + "0f0000-100000 -w-p 00000003 00:05 102 /lib/libsomething2.so\n" + "110000-120000 --xp 00000004 00:05 103 [anon:something or another]\n"; + + VerifyReadMapFileAsyncSafe(map_data.c_str(), expected_info); +} + +TEST(process_map, ReadMapFileAsyncSafe_multiple_reads) { + std::vector expected_info; + std::string map_data; + uint64_t start = 0xa0000; + for (size_t i = 0; i < 10000; i++) { + map_data += android::base::StringPrintf("%" PRIx64 "-%" PRIx64 " r--p %zx 01:20 %zu fake.so\n", + start, start + 0x1000, i, 1000 + i); + expected_info.emplace_back(start, start + 0x1000, PROT_READ, i, 1000 + i, "fake.so"); + } + + VerifyReadMapFileAsyncSafe(map_data.c_str(), expected_info); +} + +TEST(process_map, ReadMapFileAsyncSafe_buffer_nullptr) { + size_t num_calls = 0; + auto callback = [&](uint64_t, uint64_t, uint16_t, uint64_t, ino_t, const char*) { num_calls++; }; + +#if defined(__BIONIC__) + // Any allocations will block after this call. + malloc_disable(); +#endif + + bool parsed = android::procinfo::ReadMapFileAsyncSafe("/proc/self/maps", nullptr, 10, callback); + +#if defined(__BIONIC__) + malloc_enable(); +#endif + + ASSERT_FALSE(parsed); + EXPECT_EQ(0UL, num_calls); +} + +TEST(process_map, ReadMapFileAsyncSafe_buffer_size_zero) { + size_t num_calls = 0; + auto callback = [&](uint64_t, uint64_t, uint16_t, uint64_t, ino_t, const char*) { num_calls++; }; + +#if defined(__BIONIC__) + // Any allocations will block after this call. + malloc_disable(); +#endif + + char buffer[10]; + bool parsed = android::procinfo::ReadMapFileAsyncSafe("/proc/self/maps", buffer, 0, callback); + +#if defined(__BIONIC__) + malloc_enable(); +#endif + + ASSERT_FALSE(parsed); + EXPECT_EQ(0UL, num_calls); +} + +TEST(process_map, ReadMapFileAsyncSafe_buffer_too_small_no_calls) { + size_t num_calls = 0; + auto callback = [&](uint64_t, uint64_t, uint16_t, uint64_t, ino_t, const char*) { num_calls++; }; + +#if defined(__BIONIC__) + // Any allocations will block after this call. + malloc_disable(); +#endif + + char buffer[10]; + bool parsed = + android::procinfo::ReadMapFileAsyncSafe("/proc/self/maps", buffer, sizeof(buffer), callback); + +#if defined(__BIONIC__) + malloc_enable(); +#endif + + ASSERT_FALSE(parsed); + EXPECT_EQ(0UL, num_calls); +} + +TEST(process_map, ReadMapFileAsyncSafe_buffer_too_small_could_parse) { + TemporaryFile tf; + ASSERT_TRUE(android::base::WriteStringToFd( + "0a0000-0c0000 rwxp 00000001 00:05 100 /fake/lib.so\n", tf.fd)); + + size_t num_calls = 0; + auto callback = [&](uint64_t, uint64_t, uint16_t, uint64_t, ino_t, const char*) { num_calls++; }; + +#if defined(__BIONIC__) + // Any allocations will block after this call. + malloc_disable(); +#endif + + char buffer[39]; + bool parsed = android::procinfo::ReadMapFileAsyncSafe(tf.path, buffer, sizeof(buffer), callback); + +#if defined(__BIONIC__) + malloc_enable(); +#endif + + ASSERT_FALSE(parsed); + EXPECT_EQ(0UL, num_calls); +}