tequilaOS/platform_system_core
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Add ReadMapFileAsyncSafe function.

Browse source 
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
This commit is contained in:
Christopher Ferris 2019-08-16 10:49:34 -07:00
parent 88eedafbe1
commit 3bae40b279
4 changed files with 320 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
libprocinfo/Android.bp
View file

@ -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",

4
libprocinfo/include/procinfo/process_map.h
View file

@ -176,5 +176,9 @@ inline bool ReadProcessMaps(pid_t pid, std::vector<MapInfo>* 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<void(uint64_t, uint64_t, uint16_t, uint64_t, ino_t,
const char*)>& callback);
} /* namespace procinfo */
} /* namespace android */

97
libprocinfo/process_map.cpp Normal file
View file

@ -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 <procinfo/process_map.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <procinfo/process.h>
namespace android {
namespace procinfo {
bool ReadMapFileAsyncSafe(const char* map_file, void* buffer, size_t buffer_size,
const std::function<void(uint64_t, uint64_t, uint16_t, uint64_t, ino_t,
const char*)>& 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<char*>(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<char*>(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 */

217
libprocinfo/process_map_test.cpp
View file

@ -16,9 +16,14 @@
#include <procinfo/process_map.h>
#include <inttypes.h>
#include <sys/mman.h>
#include <string>
#include <vector>
#include <android-base/file.h>
#include <android-base/stringprintf.h>
#include <gtest/gtest.h>
@ -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<TestMapInfo>& expected_info) {
TemporaryFile tf;
ASSERT_TRUE(android::base::WriteStringToFd(maps_data, tf.fd));
std::vector<TestMapInfo> 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<char> 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<TestMapInfo> expected_info;
VerifyReadMapFileAsyncSafe("12c00000-2ac00000", expected_info);
}
TEST(process_map, ReadMapFileAsyncSafe_single) {
std::vector<TestMapInfo> 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<TestMapInfo> 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<TestMapInfo> 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<TestMapInfo> 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<TestMapInfo> 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);
}