blob: 321e7fef08780aae9303784431bf8c2d21cb64c2 [file] [log] [blame]
/*
* Copyright (C) 2018 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 "src/profiling/memory/unwinding.h"
#include <cxxabi.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unwindstack/RegsGetLocal.h>
#include "perfetto/ext/base/scoped_file.h"
#include "src/profiling/common/unwind_support.h"
#include "src/profiling/memory/client.h"
#include "src/profiling/memory/wire_protocol.h"
#include "test/gtest_and_gmock.h"
namespace perfetto {
namespace profiling {
namespace {
TEST(UnwindingTest, StackOverlayMemoryOverlay) {
base::ScopedFile proc_mem(base::OpenFile("/proc/self/mem", O_RDONLY));
ASSERT_TRUE(proc_mem);
uint8_t fake_stack[1] = {120};
std::shared_ptr<FDMemory> mem(
std::make_shared<FDMemory>(std::move(proc_mem)));
StackOverlayMemory memory(mem, 0u, fake_stack, 1);
uint8_t buf[1] = {};
ASSERT_EQ(memory.Read(0u, buf, 1), 1u);
ASSERT_EQ(buf[0], 120);
}
TEST(UnwindingTest, StackOverlayMemoryNonOverlay) {
uint8_t value = 52;
base::ScopedFile proc_mem(base::OpenFile("/proc/self/mem", O_RDONLY));
ASSERT_TRUE(proc_mem);
uint8_t fake_stack[1] = {120};
std::shared_ptr<FDMemory> mem(
std::make_shared<FDMemory>(std::move(proc_mem)));
StackOverlayMemory memory(mem, 0u, fake_stack, 1);
uint8_t buf[1] = {1};
ASSERT_EQ(memory.Read(reinterpret_cast<uint64_t>(&value), buf, 1), 1u);
ASSERT_EQ(buf[0], value);
}
TEST(UnwindingTest, FDMapsParse) {
base::ScopedFile proc_maps(base::OpenFile("/proc/self/maps", O_RDONLY));
ASSERT_TRUE(proc_maps);
FDMaps maps(std::move(proc_maps));
ASSERT_TRUE(maps.Parse());
unwindstack::MapInfo* map_info =
maps.Find(reinterpret_cast<uint64_t>(&proc_maps));
ASSERT_NE(map_info, nullptr);
ASSERT_EQ(map_info->name, "[stack]");
}
void __attribute__((noinline)) AssertFunctionOffset() {
constexpr auto kMaxFunctionSize = 1000u;
// Need to zero-initialize to make MSAN happy. MSAN does not see the writes
// from AsmGetRegs (as it is in assembly) and complains otherwise.
char reg_data[kMaxRegisterDataSize] = {};
unwindstack::AsmGetRegs(reg_data);
auto regs = CreateRegsFromRawData(unwindstack::Regs::CurrentArch(), reg_data);
ASSERT_GT(regs->pc(), reinterpret_cast<uint64_t>(&AssertFunctionOffset));
ASSERT_LT(regs->pc() - reinterpret_cast<uint64_t>(&AssertFunctionOffset),
kMaxFunctionSize);
}
TEST(UnwindingTest, TestFunctionOffset) {
AssertFunctionOffset();
}
// This is needed because ASAN thinks copying the whole stack is a buffer
// underrun.
void __attribute__((noinline))
UnsafeMemcpy(void* dst, const void* src, size_t n)
__attribute__((no_sanitize("address", "hwaddress", "memory"))) {
const uint8_t* from = reinterpret_cast<const uint8_t*>(src);
uint8_t* to = reinterpret_cast<uint8_t*>(dst);
for (size_t i = 0; i < n; ++i)
to[i] = from[i];
}
struct RecordMemory {
std::unique_ptr<uint8_t[]> payload;
std::unique_ptr<AllocMetadata> metadata;
};
RecordMemory __attribute__((noinline)) GetRecord(WireMessage* msg) {
std::unique_ptr<AllocMetadata> metadata(new AllocMetadata);
*metadata = {};
const char* stackbase = GetThreadStackBase();
const char* stacktop = reinterpret_cast<char*>(__builtin_frame_address(0));
// Need to zero-initialize to make MSAN happy. MSAN does not see the writes
// from AsmGetRegs (as it is in assembly) and complains otherwise.
memset(metadata->register_data, 0, sizeof(metadata->register_data));
unwindstack::AsmGetRegs(metadata->register_data);
if (stackbase < stacktop) {
PERFETTO_FATAL("Stacktop >= stackbase.");
return {nullptr, nullptr};
}
size_t stack_size = static_cast<size_t>(stackbase - stacktop);
metadata->alloc_size = 10;
metadata->alloc_address = 0x10;
metadata->stack_pointer = reinterpret_cast<uint64_t>(stacktop);
metadata->arch = unwindstack::Regs::CurrentArch();
metadata->sequence_number = 1;
std::unique_ptr<uint8_t[]> payload(new uint8_t[stack_size]);
UnsafeMemcpy(&payload[0], stacktop, stack_size);
*msg = {};
msg->alloc_header = metadata.get();
msg->payload = reinterpret_cast<char*>(payload.get());
msg->payload_size = static_cast<size_t>(stack_size);
return {std::move(payload), std::move(metadata)};
}
TEST(UnwindingTest, DoUnwind) {
base::ScopedFile proc_maps(base::OpenFile("/proc/self/maps", O_RDONLY));
base::ScopedFile proc_mem(base::OpenFile("/proc/self/mem", O_RDONLY));
GlobalCallstackTrie callsites;
UnwindingMetadata metadata(std::move(proc_maps), std::move(proc_mem));
WireMessage msg;
auto record = GetRecord(&msg);
AllocRecord out;
ASSERT_TRUE(DoUnwind(&msg, &metadata, &out));
ASSERT_GT(out.frames.size(), 0u);
int st;
std::unique_ptr<char, base::FreeDeleter> demangled(abi::__cxa_demangle(
out.frames[0].frame.function_name.c_str(), nullptr, nullptr, &st));
ASSERT_EQ(st, 0) << "mangled: " << demangled.get()
<< ", frames: " << out.frames.size();
ASSERT_STREQ(demangled.get(),
"perfetto::profiling::(anonymous "
"namespace)::GetRecord(perfetto::profiling::WireMessage*)");
}
TEST(UnwindingTest, DoUnwindReparse) {
base::ScopedFile proc_maps(base::OpenFile("/proc/self/maps", O_RDONLY));
base::ScopedFile proc_mem(base::OpenFile("/proc/self/mem", O_RDONLY));
GlobalCallstackTrie callsites;
UnwindingMetadata metadata(std::move(proc_maps), std::move(proc_mem));
// Force reparse in DoUnwind.
metadata.fd_maps.Reset();
WireMessage msg;
auto record = GetRecord(&msg);
AllocRecord out;
ASSERT_TRUE(DoUnwind(&msg, &metadata, &out));
ASSERT_GT(out.frames.size(), 0u);
int st;
std::unique_ptr<char, base::FreeDeleter> demangled(abi::__cxa_demangle(
out.frames[0].frame.function_name.c_str(), nullptr, nullptr, &st));
ASSERT_EQ(st, 0) << "mangled: " << demangled.get()
<< ", frames: " << out.frames.size();
ASSERT_STREQ(demangled.get(),
"perfetto::profiling::(anonymous "
"namespace)::GetRecord(perfetto::profiling::WireMessage*)");
}
} // namespace
} // namespace profiling
} // namespace perfetto