| // 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 "system_objects_directory.h" |
| |
| #include <fs/pseudo-file.h> |
| #include <src/lib/fxl/strings/string_printf.h> |
| #include <algorithm> |
| #include "debug_info_retriever.h" |
| |
| using fxl::StringPrintf; |
| |
| namespace { |
| |
| const char* obj_type_get_name(zx_obj_type_t type) { |
| switch (type) { |
| case ZX_OBJ_TYPE_NONE: |
| return "none"; |
| case ZX_OBJ_TYPE_PROCESS: |
| return "process"; |
| case ZX_OBJ_TYPE_THREAD: |
| return "thread"; |
| case ZX_OBJ_TYPE_VMO: |
| return "vmo"; |
| case ZX_OBJ_TYPE_CHANNEL: |
| return "channel"; |
| case ZX_OBJ_TYPE_EVENT: |
| return "event"; |
| case ZX_OBJ_TYPE_PORT: |
| return "port"; |
| case ZX_OBJ_TYPE_INTERRUPT: |
| return "interrupt"; |
| case ZX_OBJ_TYPE_PCI_DEVICE: |
| return "pci_device"; |
| case ZX_OBJ_TYPE_LOG: |
| return "log"; |
| case ZX_OBJ_TYPE_SOCKET: |
| return "socket"; |
| case ZX_OBJ_TYPE_RESOURCE: |
| return "resource"; |
| case ZX_OBJ_TYPE_EVENTPAIR: |
| return "eventpair"; |
| case ZX_OBJ_TYPE_JOB: |
| return "job"; |
| case ZX_OBJ_TYPE_VMAR: |
| return "vmar"; |
| case ZX_OBJ_TYPE_FIFO: |
| return "fifo"; |
| case ZX_OBJ_TYPE_GUEST: |
| return "guest"; |
| case ZX_OBJ_TYPE_VCPU: |
| return "vcpu"; |
| case ZX_OBJ_TYPE_TIMER: |
| return "timer"; |
| case ZX_OBJ_TYPE_IOMMU: |
| return "iommu"; |
| case ZX_OBJ_TYPE_BTI: |
| return "bti"; |
| case ZX_OBJ_TYPE_PROFILE: |
| return "profile"; |
| default: |
| return "unknown"; |
| } |
| } |
| |
| } // namespace |
| |
| namespace component { |
| |
| SystemObjectsDirectory::SystemObjectsDirectory(zx::process process) |
| : ExposedObject("system_objects"), |
| process_(std::move(process)), |
| threads_(std::make_unique<ThreadsDirectory>(&process_)), |
| memory_(std::make_unique<MemoryDirectory>(&process_)) { |
| add_child(threads_.get()); |
| add_child(memory_.get()); |
| object_dir().set_children_callback( |
| [this](component::Object::ObjectVector* out_children) { |
| zx_info_process_handle_stats_t process_handle_stats; |
| if (GetProcessHandleStats(&process_handle_stats) != ZX_OK) |
| return; |
| auto handle_count_dir = component::ObjectDir::Make("handle_count"); |
| |
| for (zx_obj_type_t obj_type = ZX_OBJ_TYPE_NONE; |
| obj_type < ZX_OBJ_TYPE_UPPER_BOUND; ++obj_type) { |
| handle_count_dir.set_metric( |
| obj_type_get_name(obj_type), |
| component::UIntMetric( |
| process_handle_stats.handle_count[obj_type])); |
| } |
| out_children->push_back(handle_count_dir.object()); |
| }); |
| } |
| |
| zx_status_t SystemObjectsDirectory::GetProcessHandleStats( |
| zx_info_process_handle_stats_t* process_handle_stats) { |
| zx_status_t status = |
| process_.get_info(ZX_INFO_PROCESS_HANDLE_STATS, process_handle_stats, |
| sizeof(zx_info_process_handle_stats), nullptr, nullptr); |
| if (status != ZX_OK) { |
| FXL_LOG(ERROR) << "zx_object_get_info failed, status: " << status; |
| return status; |
| } |
| |
| return ZX_OK; |
| } |
| |
| SystemObjectsDirectory::ThreadsDirectory::ThreadsDirectory( |
| const zx::process* process) |
| : ExposedObject("threads"), process_(process) { |
| auto all_dir = component::ObjectDir::Make("all_thread_stacks"); |
| all_dir.set_prop("stacks", [this]() -> std::string { |
| return StringPrintf("\n%s", DebugInfoRetriever::GetInfo(process_).data()); |
| }); |
| |
| object_dir().set_child(all_dir.object()); |
| object_dir().set_children_callback( |
| [this](component::Object::ObjectVector* out_children) { |
| fbl::Vector<ThreadInfo> threads; |
| threads.reserve(kMaxThreads); |
| GetThreads(&threads); |
| |
| for (const auto& thread : threads) { |
| auto koid_string = StringPrintf("%lu", thread.koid); |
| auto thread_obj = component::ObjectDir::Make(koid_string); |
| thread_obj.set_prop("koid", koid_string); |
| thread_obj.set_prop("name", thread.name.data()); |
| zx_handle_t handle = thread.thread.get(); |
| zx_info_thread_stats_t thread_stats; |
| thread_obj.set_metric( |
| "total_runtime", |
| UIntMetric(GetThreadStats(handle, &thread_stats) == ZX_OK |
| ? thread_stats.total_runtime |
| : 0u)); |
| out_children->push_back(thread_obj.object()); |
| |
| auto koid = thread.koid; |
| auto stack_obj = component::ObjectDir::Make("stack"); |
| stack_obj.set_prop("dump", [this, koid]() -> std::string { |
| zx_koid_t koids[] = {koid}; |
| return StringPrintf( |
| "\n%s", DebugInfoRetriever::GetInfo(process_, koids, 1).data()); |
| }); |
| thread_obj.set_child(stack_obj.object()); |
| } |
| }); |
| } |
| |
| void SystemObjectsDirectory::ThreadsDirectory::GetThreads( |
| fbl::Vector<ThreadInfo>* out) { |
| zx_koid_t thread_ids[kMaxThreads]; |
| size_t num_ids; |
| if (process_->get_info(ZX_INFO_PROCESS_THREADS, thread_ids, |
| sizeof(zx_koid_t) * kMaxThreads, &num_ids, |
| nullptr) != ZX_OK) { |
| return; |
| } |
| |
| for (size_t i = 0; i < num_ids; i++) { |
| zx::thread t; |
| char name[ZX_MAX_NAME_LEN]; |
| if (process_->get_child(thread_ids[i], ZX_RIGHT_SAME_RIGHTS, &t) != ZX_OK) { |
| return; |
| } |
| if (t.get_property(ZX_PROP_NAME, &name, ZX_MAX_NAME_LEN) != ZX_OK) { |
| return; |
| } |
| t.get_property(ZX_PROP_NAME, &name, ZX_MAX_NAME_LEN); |
| out->push_back({thread_ids[i], name, std::move(t)}); |
| } |
| } |
| |
| zx_status_t SystemObjectsDirectory::ThreadsDirectory::GetThreadStats( |
| zx_handle_t thread, zx_info_thread_stats_t* thread_stats) { |
| zx_status_t status = |
| zx_object_get_info(thread, ZX_INFO_THREAD_STATS, thread_stats, |
| sizeof(zx_info_thread_stats_t), nullptr, nullptr); |
| if (status != ZX_OK) { |
| FXL_LOG(ERROR) << "zx_object_get_info failed, status: " << status |
| << " thread: " << thread; |
| return status; |
| } |
| |
| return ZX_OK; |
| } |
| |
| SystemObjectsDirectory::MemoryDirectory::MemoryDirectory( |
| const zx::process* process) |
| : ExposedObject("memory"), process_(process) { |
| object_dir().set_metric( |
| "mapped_bytes", component::CallbackMetric([this](component::Metric* out) { |
| zx_info_task_stats_t task_stats; |
| if (GetTaskStats(&task_stats) != ZX_OK) |
| return; |
| out->SetUInt(task_stats.mem_mapped_bytes); |
| })); |
| |
| object_dir().set_metric( |
| "private_bytes", |
| component::CallbackMetric([this](component::Metric* out) { |
| zx_info_task_stats_t task_stats; |
| if (GetTaskStats(&task_stats) != ZX_OK) |
| return; |
| out->SetUInt(task_stats.mem_private_bytes); |
| })); |
| |
| object_dir().set_metric( |
| "shared_bytes", component::CallbackMetric([this](component::Metric* out) { |
| zx_info_task_stats_t task_stats; |
| if (GetTaskStats(&task_stats) != ZX_OK) |
| return; |
| out->SetUInt(task_stats.mem_shared_bytes); |
| })); |
| |
| object_dir().set_metric( |
| "scaled_shared_bytes", |
| component::CallbackMetric([this](component::Metric* out) { |
| zx_info_task_stats_t task_stats; |
| if (GetTaskStats(&task_stats) != ZX_OK) |
| return; |
| out->SetUInt(task_stats.mem_scaled_shared_bytes); |
| })); |
| } |
| |
| zx_status_t SystemObjectsDirectory::MemoryDirectory::GetTaskStats( |
| zx_info_task_stats_t* task_stats) { |
| zx_status_t status = |
| process_->get_info(ZX_INFO_TASK_STATS, task_stats, |
| sizeof(zx_info_task_stats_t), nullptr, nullptr); |
| if (status != ZX_OK) { |
| FXL_LOG(ERROR) << "zx_object_get_info failed, status: " << status; |
| return status; |
| } |
| |
| return ZX_OK; |
| } |
| |
| } // namespace component |
