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); +}