bin/zxdb/console/analyze_memory.cc - garnet - Git at Google

 // Copyright 2018 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "garnet/bin/zxdb/console/analyze_memory.h"

 #include <inttypes.h>

 #include <map>

 #include "garnet/bin/zxdb/client/frame.h"
 #include "garnet/bin/zxdb/client/memory_dump.h"
 #include "garnet/bin/zxdb/client/process.h"
 #include "garnet/bin/zxdb/client/register.h"
 #include "garnet/bin/zxdb/client/thread.h"
 #include "garnet/bin/zxdb/common/err.h"
 #include "garnet/bin/zxdb/console/format_register.h"
 #include "garnet/bin/zxdb/console/format_table.h"
 #include "garnet/bin/zxdb/console/output_buffer.h"
 #include "garnet/bin/zxdb/symbols/input_location.h"
 #include "garnet/bin/zxdb/symbols/process_symbols.h"
 #include "garnet/bin/zxdb/symbols/symbol_utils.h"
 #include "garnet/lib/debug_ipc/helper/message_loop.h"
 #include "garnet/lib/debug_ipc/records.h"
 #include "lib/fxl/logging.h"
 #include "lib/fxl/strings/string_printf.h"

 namespace zxdb {

 namespace {

 // Rounds the beginning and size to sizeof(uint64_t) which we assume all
 // pointers are on the debugged platform. This may need to be configurable in
 // the future.
 constexpr uint64_t kAlign = sizeof(uint64_t);

 // Aspace entries this size or larger will be ignored for annotation purposes.
 // These large regions generally represent the process's available address
 // space rather than actually used memory.
 constexpr uint64_t kMaxAspaceRegion = 128000000000;  // 128GB

 }  // namespace

 namespace internal {

 MemoryAnalysis::MemoryAnalysis(const AnalyzeMemoryOptions& opts, Callback cb)
     : callback_(std::move(cb)) {
   process_ = opts.process->GetWeakPtr();

   // This doesn't store the Thread because it may go out-of-scope during the
   // asynchronous requests. We'd need a weak pointer but its better avoided.
   begin_address_ = opts.begin_address / kAlign * kAlign;

   uint64_t end = opts.begin_address + opts.bytes_to_read;
   end += kAlign - 1;
   end = end / kAlign * kAlign;
   bytes_to_read_ = static_cast<uint32_t>(end - begin_address_);
 }

 void MemoryAnalysis::Schedule(const AnalyzeMemoryOptions& opts) {
   // Copies are passed to the callbacks to keep this object in scope until
   // all are complete.
   fxl::RefPtr<MemoryAnalysis> this_ref(this);

   if (opts.thread) {
     // Request registers. Only need the general registers.
     if (!have_registers_) {
       opts.thread->ReadRegisters(
           {debug_ipc::RegisterCategory::Type::kGeneral},
           [this_ref](const Err& err, const RegisterSet& registers) {
             this_ref->OnRegisters(err, registers);
           });
     }

     // Request stack dump.
     if (!have_frames_) {
       if (opts.thread->GetStack().has_all_frames()) {
         OnFrames(opts.thread->GetWeakPtr());
       } else {
         opts.thread->GetStack().SyncFrames([
           this_ref, weak_thread = opts.thread->GetWeakPtr()
         ](const Err&) {
           // Can ignore the error, the frames will be re-queried from the
           // thread and we'll check the weak pointer in case its destroyed.
           this_ref->OnFrames(weak_thread);
         });
       }
     }
   } else {
     // Mark these as complete so we can continue when everything else is done.
     have_registers_ = true;
     have_frames_ = true;
   }

   // Request memory dump.
   if (!have_memory_) {
     opts.process->ReadMemory(begin_address_, bytes_to_read_,
                              [this_ref](const Err& err, MemoryDump dump) {
                                this_ref->OnMemory(err, std::move(dump));
                              });
   }

   // Request address space dump.
   if (!have_aspace_) {
     opts.process->GetAspace(
         0, [this_ref](const Err& err,
                       std::vector<debug_ipc::AddressRegion> aspace) {
           this_ref->OnAspace(err, std::move(aspace));
         });
   }

   // Test code could have set everything, in which case trigger a run.
   if (HasEverything()) {
     debug_ipc::MessageLoop::Current()->PostTask(
         FROM_HERE, [this_ref]() { this_ref->DoAnalysis(); });
   }
 }

 void MemoryAnalysis::SetAspace(std::vector<debug_ipc::AddressRegion> aspace) {
   FXL_DCHECK(!have_aspace_);
   have_aspace_ = true;
   aspace_ = std::move(aspace);
 }

 void MemoryAnalysis::SetStack(const Stack& stack) {
   FXL_DCHECK(!have_frames_);
   have_frames_ = true;

   // This loop avoids adding frame 0's information because that should be
   // covered by the CPU registers.
   for (int i = 1; i < static_cast<int>(stack.size()); i++) {
     AddAnnotation(stack[i]->GetAddress(), fxl::StringPrintf("frame %d IP", i));
     // TODO(brettw) make this work when the BP is asynchronous.
     if (auto bp = stack[i]->GetBasePointer())
       AddAnnotation(*bp, fxl::StringPrintf("frame %d BP", i));
     AddAnnotation(stack[i]->GetStackPointer(),
                   fxl::StringPrintf("frame %d SP", i));
   }
 }

 void MemoryAnalysis::SetMemory(MemoryDump dump) {
   FXL_DCHECK(!have_memory_);
   have_memory_ = true;
   memory_ = std::move(dump);
 }

 void MemoryAnalysis::SetRegisters(const RegisterSet& registers) {
   FXL_DCHECK(!have_registers_);
   have_registers_ = true;
   for (const auto& kv : registers.category_map()) {
     // We look for the general section registers
     if (kv.first == debug_ipc::RegisterCategory::Type::kGeneral) {
       for (const auto& reg : kv.second)
         AddAnnotation(reg.GetValue(), RegisterIDToString(reg.id()));
     }
   }
 }

 void MemoryAnalysis::DoAnalysis() {
   std::vector<std::vector<OutputBuffer>> rows;
   rows.reserve(bytes_to_read_ / kAlign);
   for (uint64_t offset = 0; offset < bytes_to_read_; offset += kAlign) {
     rows.emplace_back();
     auto& row = rows.back();

     uint64_t address = begin_address_ + offset;

     // Address.
     row.emplace_back(Syntax::kComment,
                      fxl::StringPrintf("0x%" PRIx64, address));

     // Data
     uint64_t data_value = 0;
     bool has_data = GetData(address, &data_value);
     if (has_data) {
       row.emplace_back(fxl::StringPrintf("0x%016" PRIx64, data_value));
     } else {
       row.emplace_back("<invalid memory>");
     }

     std::string annotation = GetAnnotationsBetween(address, address + kAlign);
     std::string pointed_to;
     if (has_data)
       pointed_to = GetPointedToAnnotation(data_value);

     OutputBuffer comments;
     if (!annotation.empty()) {
       // Mark things pointing into the stack as special since they're important
       // and can get drowned out by the "pointed to" annotations.
       comments.Append(Syntax::kSpecial, std::move(annotation));
       if (!pointed_to.empty())
         comments.Append(". ");  // Separator between sections.
     }
     if (!pointed_to.empty())
       comments.Append(std::move(pointed_to));
     row.push_back(comments);
   }

   OutputBuffer out;
   FormatTable({ColSpec(Align::kRight, 0, "Address"),
                ColSpec(Align::kRight, 0, "Data"), ColSpec()},
               rows, &out);
   callback_(Err(), std::move(out), begin_address_ + bytes_to_read_);
 }

 void MemoryAnalysis::OnAspace(const Err& err,
                               std::vector<debug_ipc::AddressRegion> aspace) {
   if (aborted_)
     return;

   // This function can continue without address space annotations so ignore
   // errors.
   SetAspace(std::move(aspace));

   if (HasEverything())
     DoAnalysis();
 }

 void MemoryAnalysis::OnRegisters(const Err& err, const RegisterSet& registers) {
   if (aborted_)
     return;

   // This function can continue without registers (say, if the thread has been
   // resumed by the time the request got executed). So just ignore failures.
   SetRegisters(registers);

   if (HasEverything())
     DoAnalysis();
 }

 void MemoryAnalysis::OnMemory(const Err& err, MemoryDump dump) {
   if (aborted_)
     return;
   if (err.has_error()) {
     IssueError(err);
     return;
   }

   SetMemory(std::move(dump));

   if (HasEverything())
     DoAnalysis();
 }

 void MemoryAnalysis::OnFrames(fxl::WeakPtr<Thread> thread) {
   if (aborted_)
     return;

   // This function can continue even if the thread is gone, it just won't get
   // the frame annotations.
   if (thread)
     SetStack(thread->GetStack());
   else
     have_frames_ = true;  // Mark fetching is complete.

   if (HasEverything())
     DoAnalysis();
 }

 bool MemoryAnalysis::HasEverything() const {
   return have_registers_ && have_memory_ && have_frames_ && have_aspace_;
 }

 void MemoryAnalysis::IssueError(const Err& err) {
   aborted_ = true;
   callback_(err, OutputBuffer(), 0);

   // Reset so we notice if there's an accidental double-call.
   callback_ = Callback();
 }

 void MemoryAnalysis::AddAnnotation(uint64_t address, const std::string& str) {
   auto found = annotations_.find(address);
   if (found == annotations_.end()) {
     annotations_[address] = str;
   } else {
     found->second.append(", ");
     found->second.append(str);
   }
 }

 bool MemoryAnalysis::GetData(uint64_t address, uint64_t* out_value) const {
   // Need to handle invalid memory. The easiest thing is to read a byte at a
   // time. This doesn't handle invalid regions spanning a pointer; that
   // shouldn't happen because valid memory regions should always be aligned
   // more coarsly than the size of a pointer.
   uint64_t data = 0;
   for (uint64_t i = 0; i < kAlign; i++) {
     uint8_t byte;
     if (!memory_.GetByte(address + i, &byte))
       return false;
     data |= static_cast<uint64_t>(byte) << (i * 8);
   }

   *out_value = data;
   return true;
 }

 std::string MemoryAnalysis::GetAnnotationsBetween(uint64_t address_begin,
                                                   uint64_t address_end) const {
   auto lower = annotations_.lower_bound(address_begin);
   auto upper = annotations_.upper_bound(address_end - 1);
   if (lower == upper)
     return std::string();  // No annotations in this range.

   std::string result = ("◁ ");
   for (auto cur = lower; cur != upper; ++cur) {
     if (cur != lower) {
       // Not the first annotation, needs a separator.
       result += "; ";
     }
     if (cur->first != address_begin) {
       // Not at the address but inside of the range. Annotate that carefully.
       result += fxl::StringPrintf("@ 0x%" PRIx64 ": ", cur->first);
     }
     result += cur->second;
   }
   return result;
 }

 std::string MemoryAnalysis::GetPointedToAnnotation(uint64_t data) const {
   if (!process_)
     return std::string();
   auto locations =
       process_->GetSymbols()->ResolveInputLocation(InputLocation(data));
   FXL_DCHECK(locations.size() == 1);

   if (!locations[0].symbol()) {
     // Check if this points into any relevant aspace entries. Want the deepest
     // one smaller than the max size threshold.
     int max_depth = -1;
     size_t found_entry = aspace_.size();  // Indicates not found.
     for (size_t i = 0; i < aspace_.size(); i++) {
       const auto& region = aspace_[i];
       if (region.size < kMaxAspaceRegion && data >= region.base &&
           data < region.base + region.size &&
           max_depth < static_cast<int>(region.depth)) {
         max_depth = static_cast<int>(region.depth);
         found_entry = i;
       }
     }

     if (found_entry == aspace_.size())
       return std::string();  // Not found.
     return fxl::StringPrintf("▷ inside map \"%s\"",
                              aspace_[found_entry].name.c_str());
   }
   // TODO(brettw) this should indicate the byte offset from the beginning of
   // the function, or maybe the file/line number.
   return "▷ inside " + locations[0].symbol().Get()->GetFullName();
 }

 }  // namespace internal

 void AnalyzeMemory(const AnalyzeMemoryOptions& opts,
                    std::function<void(const Err& err, OutputBuffer analysis,
                                       uint64_t next_addr)>
                        cb) {
   auto analysis =
       fxl::MakeRefCounted<zxdb::internal::MemoryAnalysis>(opts, std::move(cb));
   analysis->Schedule(opts);
 }

 }  // namespace zxdb
	// Copyright 2018 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "garnet/bin/zxdb/console/analyze_memory.h"

	#include <inttypes.h>

	#include <map>

	#include "garnet/bin/zxdb/client/frame.h"
	#include "garnet/bin/zxdb/client/memory_dump.h"
	#include "garnet/bin/zxdb/client/process.h"
	#include "garnet/bin/zxdb/client/register.h"
	#include "garnet/bin/zxdb/client/thread.h"
	#include "garnet/bin/zxdb/common/err.h"
	#include "garnet/bin/zxdb/console/format_register.h"
	#include "garnet/bin/zxdb/console/format_table.h"
	#include "garnet/bin/zxdb/console/output_buffer.h"
	#include "garnet/bin/zxdb/symbols/input_location.h"
	#include "garnet/bin/zxdb/symbols/process_symbols.h"
	#include "garnet/bin/zxdb/symbols/symbol_utils.h"
	#include "garnet/lib/debug_ipc/helper/message_loop.h"
	#include "garnet/lib/debug_ipc/records.h"
	#include "lib/fxl/logging.h"
	#include "lib/fxl/strings/string_printf.h"

	namespace zxdb {

	namespace {

	// Rounds the beginning and size to sizeof(uint64_t) which we assume all
	// pointers are on the debugged platform. This may need to be configurable in
	// the future.
	constexpr uint64_t kAlign = sizeof(uint64_t);

	// Aspace entries this size or larger will be ignored for annotation purposes.
	// These large regions generally represent the process's available address
	// space rather than actually used memory.
	constexpr uint64_t kMaxAspaceRegion = 128000000000; // 128GB

	} // namespace

	namespace internal {

	MemoryAnalysis::MemoryAnalysis(const AnalyzeMemoryOptions& opts, Callback cb)
	: callback_(std::move(cb)) {
	process_ = opts.process->GetWeakPtr();

	// This doesn't store the Thread because it may go out-of-scope during the
	// asynchronous requests. We'd need a weak pointer but its better avoided.
	begin_address_ = opts.begin_address / kAlign * kAlign;

	uint64_t end = opts.begin_address + opts.bytes_to_read;
	end += kAlign - 1;
	end = end / kAlign * kAlign;
	bytes_to_read_ = static_cast<uint32_t>(end - begin_address_);
	}

	void MemoryAnalysis::Schedule(const AnalyzeMemoryOptions& opts) {
	// Copies are passed to the callbacks to keep this object in scope until
	// all are complete.
	fxl::RefPtr<MemoryAnalysis> this_ref(this);

	if (opts.thread) {
	// Request registers. Only need the general registers.
	if (!have_registers_) {
	opts.thread->ReadRegisters(
	{debug_ipc::RegisterCategory::Type::kGeneral},
	[this_ref](const Err& err, const RegisterSet& registers) {
	this_ref->OnRegisters(err, registers);
	});
	}

	// Request stack dump.
	if (!have_frames_) {
	if (opts.thread->GetStack().has_all_frames()) {
	OnFrames(opts.thread->GetWeakPtr());
	} else {
	opts.thread->GetStack().SyncFrames([
	this_ref, weak_thread = opts.thread->GetWeakPtr()
	](const Err&) {
	// Can ignore the error, the frames will be re-queried from the
	// thread and we'll check the weak pointer in case its destroyed.
	this_ref->OnFrames(weak_thread);
	});
	}
	}
	} else {
	// Mark these as complete so we can continue when everything else is done.
	have_registers_ = true;
	have_frames_ = true;
	}

	// Request memory dump.
	if (!have_memory_) {
	opts.process->ReadMemory(begin_address_, bytes_to_read_,
	[this_ref](const Err& err, MemoryDump dump) {
	this_ref->OnMemory(err, std::move(dump));
	});
	}

	// Request address space dump.
	if (!have_aspace_) {
	opts.process->GetAspace(
	0, [this_ref](const Err& err,
	std::vector<debug_ipc::AddressRegion> aspace) {
	this_ref->OnAspace(err, std::move(aspace));
	});
	}

	// Test code could have set everything, in which case trigger a run.
	if (HasEverything()) {
	debug_ipc::MessageLoop::Current()->PostTask(
	FROM_HERE, [this_ref]() { this_ref->DoAnalysis(); });
	}
	}

	void MemoryAnalysis::SetAspace(std::vector<debug_ipc::AddressRegion> aspace) {
	FXL_DCHECK(!have_aspace_);
	have_aspace_ = true;
	aspace_ = std::move(aspace);
	}

	void MemoryAnalysis::SetStack(const Stack& stack) {
	FXL_DCHECK(!have_frames_);
	have_frames_ = true;

	// This loop avoids adding frame 0's information because that should be
	// covered by the CPU registers.
	for (int i = 1; i < static_cast<int>(stack.size()); i++) {
	AddAnnotation(stack[i]->GetAddress(), fxl::StringPrintf("frame %d IP", i));
	// TODO(brettw) make this work when the BP is asynchronous.
	if (auto bp = stack[i]->GetBasePointer())
	AddAnnotation(*bp, fxl::StringPrintf("frame %d BP", i));
	AddAnnotation(stack[i]->GetStackPointer(),
	fxl::StringPrintf("frame %d SP", i));
	}
	}

	void MemoryAnalysis::SetMemory(MemoryDump dump) {
	FXL_DCHECK(!have_memory_);
	have_memory_ = true;
	memory_ = std::move(dump);
	}

	void MemoryAnalysis::SetRegisters(const RegisterSet& registers) {
	FXL_DCHECK(!have_registers_);
	have_registers_ = true;
	for (const auto& kv : registers.category_map()) {
	// We look for the general section registers
	if (kv.first == debug_ipc::RegisterCategory::Type::kGeneral) {
	for (const auto& reg : kv.second)
	AddAnnotation(reg.GetValue(), RegisterIDToString(reg.id()));
	}
	}
	}

	void MemoryAnalysis::DoAnalysis() {
	std::vector<std::vector<OutputBuffer>> rows;
	rows.reserve(bytes_to_read_ / kAlign);
	for (uint64_t offset = 0; offset < bytes_to_read_; offset += kAlign) {
	rows.emplace_back();
	auto& row = rows.back();

	uint64_t address = begin_address_ + offset;

	// Address.
	row.emplace_back(Syntax::kComment,
	fxl::StringPrintf("0x%" PRIx64, address));

	// Data
	uint64_t data_value = 0;
	bool has_data = GetData(address, &data_value);
	if (has_data) {
	row.emplace_back(fxl::StringPrintf("0x%016" PRIx64, data_value));
	} else {
	row.emplace_back("<invalid memory>");
	}

	std::string annotation = GetAnnotationsBetween(address, address + kAlign);
	std::string pointed_to;
	if (has_data)
	pointed_to = GetPointedToAnnotation(data_value);

	OutputBuffer comments;
	if (!annotation.empty()) {
	// Mark things pointing into the stack as special since they're important
	// and can get drowned out by the "pointed to" annotations.
	comments.Append(Syntax::kSpecial, std::move(annotation));
	if (!pointed_to.empty())
	comments.Append(". "); // Separator between sections.
	}
	if (!pointed_to.empty())
	comments.Append(std::move(pointed_to));
	row.push_back(comments);
	}

	OutputBuffer out;
	FormatTable({ColSpec(Align::kRight, 0, "Address"),
	ColSpec(Align::kRight, 0, "Data"), ColSpec()},
	rows, &out);
	callback_(Err(), std::move(out), begin_address_ + bytes_to_read_);
	}

	void MemoryAnalysis::OnAspace(const Err& err,
	std::vector<debug_ipc::AddressRegion> aspace) {
	if (aborted_)
	return;

	// This function can continue without address space annotations so ignore
	// errors.
	SetAspace(std::move(aspace));

	if (HasEverything())
	DoAnalysis();
	}

	void MemoryAnalysis::OnRegisters(const Err& err, const RegisterSet& registers) {
	if (aborted_)
	return;

	// This function can continue without registers (say, if the thread has been
	// resumed by the time the request got executed). So just ignore failures.
	SetRegisters(registers);

	if (HasEverything())
	DoAnalysis();
	}

	void MemoryAnalysis::OnMemory(const Err& err, MemoryDump dump) {
	if (aborted_)
	return;
	if (err.has_error()) {
	IssueError(err);
	return;
	}

	SetMemory(std::move(dump));

	if (HasEverything())
	DoAnalysis();
	}

	void MemoryAnalysis::OnFrames(fxl::WeakPtr<Thread> thread) {
	if (aborted_)
	return;

	// This function can continue even if the thread is gone, it just won't get
	// the frame annotations.
	if (thread)
	SetStack(thread->GetStack());
	else
	have_frames_ = true; // Mark fetching is complete.

	if (HasEverything())
	DoAnalysis();
	}

	bool MemoryAnalysis::HasEverything() const {
	return have_registers_ && have_memory_ && have_frames_ && have_aspace_;
	}

	void MemoryAnalysis::IssueError(const Err& err) {
	aborted_ = true;
	callback_(err, OutputBuffer(), 0);

	// Reset so we notice if there's an accidental double-call.
	callback_ = Callback();
	}

	void MemoryAnalysis::AddAnnotation(uint64_t address, const std::string& str) {
	auto found = annotations_.find(address);
	if (found == annotations_.end()) {
	annotations_[address] = str;
	} else {
	found->second.append(", ");
	found->second.append(str);
	}
	}

	bool MemoryAnalysis::GetData(uint64_t address, uint64_t* out_value) const {
	// Need to handle invalid memory. The easiest thing is to read a byte at a
	// time. This doesn't handle invalid regions spanning a pointer; that
	// shouldn't happen because valid memory regions should always be aligned
	// more coarsly than the size of a pointer.
	uint64_t data = 0;
	for (uint64_t i = 0; i < kAlign; i++) {
	uint8_t byte;
	if (!memory_.GetByte(address + i, &byte))
	return false;
	data \|= static_cast<uint64_t>(byte) << (i * 8);
	}

	*out_value = data;
	return true;
	}

	std::string MemoryAnalysis::GetAnnotationsBetween(uint64_t address_begin,
	uint64_t address_end) const {
	auto lower = annotations_.lower_bound(address_begin);
	auto upper = annotations_.upper_bound(address_end - 1);
	if (lower == upper)
	return std::string(); // No annotations in this range.

	std::string result = ("◁ ");
	for (auto cur = lower; cur != upper; ++cur) {
	if (cur != lower) {
	// Not the first annotation, needs a separator.
	result += "; ";
	}
	if (cur->first != address_begin) {
	// Not at the address but inside of the range. Annotate that carefully.
	result += fxl::StringPrintf("@ 0x%" PRIx64 ": ", cur->first);
	}
	result += cur->second;
	}
	return result;
	}

	std::string MemoryAnalysis::GetPointedToAnnotation(uint64_t data) const {
	if (!process_)
	return std::string();
	auto locations =
	process_->GetSymbols()->ResolveInputLocation(InputLocation(data));
	FXL_DCHECK(locations.size() == 1);

	if (!locations[0].symbol()) {
	// Check if this points into any relevant aspace entries. Want the deepest
	// one smaller than the max size threshold.
	int max_depth = -1;
	size_t found_entry = aspace_.size(); // Indicates not found.
	for (size_t i = 0; i < aspace_.size(); i++) {
	const auto& region = aspace_[i];
	if (region.size < kMaxAspaceRegion && data >= region.base &&
	data < region.base + region.size &&
	max_depth < static_cast<int>(region.depth)) {
	max_depth = static_cast<int>(region.depth);
	found_entry = i;
	}
	}

	if (found_entry == aspace_.size())
	return std::string(); // Not found.
	return fxl::StringPrintf("▷ inside map \"%s\"",
	aspace_[found_entry].name.c_str());
	}
	// TODO(brettw) this should indicate the byte offset from the beginning of
	// the function, or maybe the file/line number.
	return "▷ inside " + locations[0].symbol().Get()->GetFullName();
	}

	} // namespace internal

	void AnalyzeMemory(const AnalyzeMemoryOptions& opts,
	std::function<void(const Err& err, OutputBuffer analysis,
	uint64_t next_addr)>
	cb) {
	auto analysis =
	fxl::MakeRefCounted<zxdb::internal::MemoryAnalysis>(opts, std::move(cb));
	analysis->Schedule(opts);
	}

	} // namespace zxdb