| // 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/memory_monitor/monitor.h" |
| |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <fuchsia/sysinfo/c/fidl.h> |
| #include <lib/async/cpp/task.h> |
| #include <lib/async/cpp/time.h> |
| #include <lib/async/default.h> |
| #include <lib/fdio/directory.h> |
| #include <lib/fdio/fd.h> |
| #include <lib/fdio/fdio.h> |
| #include <string.h> |
| #include <trace/event.h> |
| #include <zircon/status.h> |
| |
| #include <iostream> |
| |
| #include "src/lib/fxl/command_line.h" |
| #include "src/lib/fxl/logging.h" |
| #include "src/lib/fxl/strings/string_number_conversions.h" |
| |
| namespace memory { |
| |
| namespace { |
| |
| constexpr char kKstatsPathComponent[] = "kstats"; |
| |
| zx_status_t get_root_resource(zx_handle_t* root_resource) { |
| const char* sysinfo = "/dev/misc/sysinfo"; |
| int fd = open(sysinfo, O_RDWR); |
| if (fd < 0) { |
| FXL_LOG(ERROR) << "Cannot open sysinfo: " << strerror(errno); |
| return ZX_ERR_NOT_FOUND; |
| } |
| |
| zx::channel channel; |
| zx_status_t status = |
| fdio_get_service_handle(fd, channel.reset_and_get_address()); |
| if (status != ZX_OK) { |
| FXL_LOG(ERROR) << "Cannot obtain sysinfo channel: " |
| << zx_status_get_string(status); |
| return status; |
| } |
| |
| zx_status_t fidl_status = fuchsia_sysinfo_DeviceGetRootResource( |
| channel.get(), &status, root_resource); |
| if (fidl_status != ZX_OK) { |
| FXL_LOG(ERROR) << "Cannot obtain root resource: " |
| << zx_status_get_string(fidl_status); |
| return fidl_status; |
| } else if (status != ZX_OK) { |
| FXL_LOG(ERROR) << "Cannot obtain root resource: " |
| << zx_status_get_string(status); |
| return status; |
| } |
| return ZX_OK; |
| } |
| |
| } // namespace |
| |
| const char Monitor::kTraceName[] = "memory_monitor"; |
| |
| Monitor::Monitor(std::unique_ptr<sys::ComponentContext> context, |
| const fxl::CommandLine& command_line, |
| async_dispatcher_t* dispatcher) |
| : prealloc_size_(0), |
| logging_(command_line.HasOption("log")), |
| tracing_(false), |
| delay_(zx::sec(1)), |
| dispatcher_(dispatcher), |
| component_context_(std::move(context)), |
| root_object_(component::ObjectDir::Make("root")) { |
| component_context_->outgoing()->AddPublicService(bindings_.GetHandler(this)); |
| root_object_.set_children_callback( |
| {kKstatsPathComponent}, |
| [this](component::Object::ObjectVector* out_children) { |
| Inspect(out_children); |
| }); |
| component_context_->outgoing()->GetOrCreateDirectory("objects")->AddEntry( |
| fuchsia::inspect::Inspect::Name_, |
| std::make_unique<vfs::Service>( |
| inspect_bindings_.GetHandler(root_object_.object().get()))); |
| |
| auto status = get_root_resource(&root_); |
| if (status != ZX_OK) { |
| FXL_LOG(ERROR) << "Error getting root_resource: " << status; |
| exit(-1); |
| } |
| if (command_line.HasOption("help")) { |
| PrintHelp(); |
| exit(EXIT_SUCCESS); |
| } |
| std::string delay_as_string; |
| if (command_line.GetOptionValue("delay", &delay_as_string)) { |
| unsigned delay_as_int; |
| if (!fxl::StringToNumberWithError<unsigned>(delay_as_string, |
| &delay_as_int)) { |
| FXL_LOG(ERROR) << "Invalid value for delay: " << delay_as_string; |
| exit(-1); |
| } |
| printf("setting delay to %d\n", delay_as_int); |
| delay_ = zx::msec(delay_as_int); |
| } |
| std::string prealloc_as_string; |
| if (command_line.GetOptionValue("prealloc", &prealloc_as_string)) { |
| FXL_LOG(INFO) << "prealloc_string: " << prealloc_as_string; |
| if (!fxl::StringToNumberWithError<uint64_t>(prealloc_as_string, |
| &prealloc_size_)) { |
| FXL_LOG(ERROR) << "Invalid value for prealloc: " << prealloc_as_string; |
| exit(-1); |
| } |
| prealloc_size_ *= (1024 * 1024); |
| auto status = zx::vmo::create(prealloc_size_, 0, &prealloc_vmo_); |
| if (status != ZX_OK) { |
| FXL_LOG(ERROR) << "zx::vmo::create() returns " |
| << zx_status_get_string(status); |
| exit(-1); |
| } |
| prealloc_vmo_.get_size(&prealloc_size_); |
| uintptr_t prealloc_addr = 0; |
| status = zx::vmar::root_self()->map(0, prealloc_vmo_, 0, prealloc_size_, |
| ZX_VM_PERM_READ, &prealloc_addr); |
| if (status != ZX_OK) { |
| FXL_LOG(ERROR) << "zx::vmar::map() returns " |
| << zx_status_get_string(status); |
| exit(-1); |
| } |
| |
| status = |
| prealloc_vmo_.op_range(ZX_VMO_OP_COMMIT, 0, prealloc_size_, NULL, 0); |
| if (status != ZX_OK) { |
| FXL_LOG(ERROR) << "zx::vmo::op_range() returns " |
| << zx_status_get_string(status); |
| exit(-1); |
| } |
| } |
| |
| trace_observer_.Start(dispatcher_, [this] { UpdateState(); }); |
| if (logging_) { |
| zx_info_kmem_stats_t stats; |
| zx_status_t err = zx_object_get_info(root_, ZX_INFO_KMEM_STATS, &stats, |
| sizeof(stats), NULL, NULL); |
| if (err != ZX_OK) { |
| FXL_LOG(ERROR) << "ZX_INFO_KMEM_STATS returns " |
| << zx_status_get_string(err); |
| exit(-1); |
| } |
| FXL_LOG(INFO) << "Total: " << stats.total_bytes |
| << " Wired: " << stats.wired_bytes |
| << " Total Heap: " << stats.total_heap_bytes; |
| } |
| SampleAndPost(); |
| } |
| |
| Monitor::~Monitor() { |
| // TODO(CF-257). |
| root_object_.set_children_callback({kKstatsPathComponent}, nullptr); |
| } |
| |
| void Monitor::Watch(fidl::InterfaceHandle<fuchsia::memory::Watcher> watcher) { |
| fuchsia::memory::WatcherPtr watcher_proxy = watcher.Bind(); |
| fuchsia::memory::Watcher* proxy_raw_ptr = watcher_proxy.get(); |
| watcher_proxy.set_error_handler([this, proxy_raw_ptr](zx_status_t status) { |
| ReleaseWatcher(proxy_raw_ptr); |
| }); |
| watchers_.push_back(std::move(watcher_proxy)); |
| SampleAndPost(); |
| } |
| |
| void Monitor::ReleaseWatcher(fuchsia::memory::Watcher* watcher) { |
| auto predicate = [watcher](const auto& target) { |
| return target.get() == watcher; |
| }; |
| watchers_.erase( |
| std::remove_if(watchers_.begin(), watchers_.end(), predicate)); |
| } |
| |
| void Monitor::NotifyWatchers(zx_info_kmem_stats_t kmem_stats) { |
| fuchsia::memory::Stats stats{ |
| .total_bytes = kmem_stats.total_bytes, |
| .free_bytes = kmem_stats.free_bytes, |
| .wired_bytes = kmem_stats.wired_bytes, |
| .total_heap_bytes = kmem_stats.total_heap_bytes, |
| .free_heap_bytes = kmem_stats.free_heap_bytes, |
| .vmo_bytes = kmem_stats.vmo_bytes, |
| .mmu_overhead_bytes = kmem_stats.mmu_overhead_bytes, |
| .ipc_bytes = kmem_stats.ipc_bytes, |
| .other_bytes = kmem_stats.other_bytes, |
| }; |
| |
| for (auto& watcher : watchers_) { |
| watcher->OnChange(stats); |
| } |
| } |
| |
| void Monitor::PrintHelp() { |
| std::cout << "memory_monitor [options]" << std::endl; |
| std::cout << "Options:" << std::endl; |
| std::cout << " --log" << std::endl; |
| std::cout << " --prealloc=kbytes" << std::endl; |
| std::cout << " --delay=msecs" << std::endl; |
| } |
| |
| void Monitor::Inspect(component::Object::ObjectVector* out_children) { |
| auto kstats = component::ObjectDir::Make(kKstatsPathComponent); |
| zx_info_kmem_stats_t stats; |
| zx_status_t err = zx_object_get_info(root_, ZX_INFO_KMEM_STATS, &stats, |
| sizeof(stats), NULL, NULL); |
| if (err != ZX_OK) { |
| FXL_LOG(ERROR) << "ZX_INFO_KMEM_STATS returns " |
| << zx_status_get_string(err); |
| return; |
| } |
| kstats.set_metric("total_bytes", component::UIntMetric(stats.total_bytes)); |
| kstats.set_metric("free_bytes", component::UIntMetric(stats.free_bytes)); |
| kstats.set_metric("wired_bytes", component::UIntMetric(stats.wired_bytes)); |
| kstats.set_metric("total_heap_bytes", |
| component::UIntMetric(stats.total_heap_bytes)); |
| kstats.set_metric("vmo_bytes", component::UIntMetric(stats.vmo_bytes)); |
| kstats.set_metric("mmu_overhead_bytes", |
| component::UIntMetric(stats.mmu_overhead_bytes)); |
| kstats.set_metric("ipc_bytes", component::UIntMetric(stats.ipc_bytes)); |
| kstats.set_metric("other_bytes", component::UIntMetric(stats.other_bytes)); |
| out_children->push_back(kstats.object()); |
| } |
| |
| void Monitor::SampleAndPost() { |
| if (logging_ || tracing_ || watchers_.size() > 0) { |
| zx_info_kmem_stats_t stats; |
| zx_status_t err = zx_object_get_info(root_, ZX_INFO_KMEM_STATS, &stats, |
| sizeof(stats), NULL, NULL); |
| if (err != ZX_OK) { |
| FXL_LOG(ERROR) << "ZX_INFO_KMEM_STATS returns " |
| << zx_status_get_string(err); |
| return; |
| } |
| if (logging_) { |
| FXL_LOG(INFO) << "Free: " << stats.free_bytes |
| << " Free Heap: " << stats.free_heap_bytes |
| << " VMO: " << stats.vmo_bytes |
| << " MMU: " << stats.mmu_overhead_bytes |
| << " IPC: " << stats.ipc_bytes; |
| } |
| if (tracing_) { |
| TRACE_COUNTER(kTraceName, "allocated", 0, "vmo", stats.vmo_bytes, |
| "mmu_overhead", stats.mmu_overhead_bytes, "ipc", |
| stats.ipc_bytes); |
| TRACE_COUNTER(kTraceName, "free", 0, "free", stats.free_bytes, |
| "free_heap", stats.free_heap_bytes); |
| } |
| NotifyWatchers(stats); |
| async::PostDelayedTask( |
| dispatcher_, [this] { SampleAndPost(); }, delay_); |
| } |
| } |
| |
| void Monitor::UpdateState() { |
| if (trace_state() == TRACE_STARTED) { |
| if (trace_is_category_enabled(kTraceName)) { |
| FXL_LOG(INFO) << "Tracing started"; |
| if (!tracing_) { |
| zx_info_kmem_stats_t stats; |
| zx_status_t err = zx_object_get_info(root_, ZX_INFO_KMEM_STATS, &stats, |
| sizeof(stats), NULL, NULL); |
| if (err != ZX_OK) { |
| FXL_LOG(ERROR) << "ZX_INFO_KMEM_STATS returns " |
| << zx_status_get_string(err); |
| return; |
| } |
| TRACE_COUNTER(kTraceName, "fixed", 0, "total", stats.total_bytes, |
| "wired", stats.wired_bytes, "total_heap", |
| stats.total_heap_bytes); |
| tracing_ = true; |
| if (!logging_) { |
| SampleAndPost(); |
| } |
| } |
| } |
| } else { |
| if (tracing_) { |
| FXL_LOG(INFO) << "Tracing stopped"; |
| tracing_ = false; |
| } |
| } |
| } |
| |
| } // namespace memory |
