| // Copyright 2021 The ChromiumOS Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "update_engine/common/cros_healthd.h" |
| |
| #include <memory> |
| #include <string> |
| #include <unordered_map> |
| #include <unordered_set> |
| #include <utility> |
| #include <vector> |
| |
| #include <base/check.h> |
| #include <base/files/scoped_file.h> |
| #include <base/logging.h> |
| #include <base/task/single_thread_task_runner.h> |
| #include <base/time/time.h> |
| #include <chromeos/mojo/service_constants.h> |
| #include <mojo/public/cpp/bindings/callback_helpers.h> |
| #include <mojo/public/cpp/platform/platform_channel.h> |
| #include <mojo/public/cpp/system/invitation.h> |
| #include <mojo_service_manager/lib/connect.h> |
| |
| namespace chromeos_update_engine { |
| |
| namespace { |
| |
| using ::ash::cros_healthd::mojom::ProbeCategoryEnum; |
| |
| // The timeout for connecting to the cros_healthd. This should not happen in the |
| // normal case. |
| constexpr base::TimeDelta kCrosHealthdConnectingTimeout = base::Minutes(3); |
| |
| #define SET_MOJO_VALUE(x) \ |
| { TelemetryCategoryEnum::x, ProbeCategoryEnum::x } |
| static const std::unordered_map<TelemetryCategoryEnum, ProbeCategoryEnum> |
| kTelemetryMojoMapping{ |
| SET_MOJO_VALUE(kBattery), |
| SET_MOJO_VALUE(kNonRemovableBlockDevices), |
| SET_MOJO_VALUE(kCpu), |
| SET_MOJO_VALUE(kTimezone), |
| SET_MOJO_VALUE(kMemory), |
| SET_MOJO_VALUE(kBacklight), |
| SET_MOJO_VALUE(kFan), |
| SET_MOJO_VALUE(kStatefulPartition), |
| SET_MOJO_VALUE(kBluetooth), |
| SET_MOJO_VALUE(kSystem), |
| SET_MOJO_VALUE(kNetwork), |
| SET_MOJO_VALUE(kAudio), |
| SET_MOJO_VALUE(kBootPerformance), |
| SET_MOJO_VALUE(kBus), |
| }; |
| |
| void PrintError(const ash::cros_healthd::mojom::ProbeErrorPtr& error, |
| std::string info) { |
| LOG(ERROR) << "Failed to get " << info << "," << " error_type=" << error->type |
| << " error_msg=" << error->msg; |
| } |
| |
| } // namespace |
| |
| std::unique_ptr<CrosHealthdInterface> CreateCrosHealthd() { |
| auto cros_healthd = std::make_unique<CrosHealthd>(); |
| // Call mojo bootstrap, instead of in constructor as testing/mocks don't |
| // require the `BootstrapMojo()` call. |
| cros_healthd->BootstrapMojo(); |
| return cros_healthd; |
| } |
| |
| void CrosHealthd::BootstrapMojo() { |
| // TODO(b/264832802): Move these initialization to a new interface. |
| // These operations (`mojo::core::Init()` and connecting to mojo service |
| // manager) could be done in each process only once. If we want to add other |
| // mojo services, we must reuse these mojo initiailizations. |
| mojo::core::Init(); |
| ipc_support_ = std::make_unique<mojo::core::ScopedIPCSupport>( |
| base::SingleThreadTaskRunner:: |
| GetCurrentDefault() /* io_thread_task_runner */, |
| mojo::core::ScopedIPCSupport::ShutdownPolicy:: |
| CLEAN /* blocking shutdown */); |
| auto pending_remote = |
| chromeos::mojo_service_manager::ConnectToMojoServiceManager(); |
| if (!pending_remote) { |
| LOG(ERROR) << "Failed to connect to mojo service manager."; |
| return; |
| } |
| service_manager_.Bind(std::move(pending_remote)); |
| service_manager_.set_disconnect_with_reason_handler( |
| base::BindOnce([](uint32_t error, const std::string& message) { |
| LOG(ERROR) << "Disconnected from mojo service manager. Error: " << error |
| << ", message: " << message; |
| })); |
| |
| service_manager_->Request( |
| chromeos::mojo_services::kCrosHealthdProbe, kCrosHealthdConnectingTimeout, |
| cros_healthd_probe_service_.BindNewPipeAndPassReceiver().PassPipe()); |
| cros_healthd_probe_service_.set_disconnect_with_reason_handler( |
| base::BindOnce([](uint32_t error, const std::string& message) { |
| LOG(ERROR) << "Disconnected from cros_healthd probe service. Error: " |
| << error << ", message: " << message; |
| })); |
| } |
| |
| TelemetryInfo* const CrosHealthd::GetTelemetryInfo() { |
| return telemetry_info_.get(); |
| } |
| |
| void CrosHealthd::ProbeTelemetryInfo( |
| const std::unordered_set<TelemetryCategoryEnum>& categories, |
| base::OnceClosure once_callback) { |
| if (!cros_healthd_probe_service_.is_bound()) { |
| LOG(WARNING) << "Skip probing because connection of cros_healthd is not " |
| "initialized."; |
| std::move(once_callback).Run(); |
| return; |
| } |
| std::vector<ProbeCategoryEnum> categories_mojo; |
| for (const auto& category : categories) { |
| auto it = kTelemetryMojoMapping.find(category); |
| if (it != kTelemetryMojoMapping.end()) |
| categories_mojo.push_back(it->second); |
| } |
| auto callback = |
| base::BindOnce(&CrosHealthd::OnProbeTelemetryInfo, |
| weak_ptr_factory_.GetWeakPtr(), std::move(once_callback)); |
| cros_healthd_probe_service_->ProbeTelemetryInfo( |
| categories_mojo, mojo::WrapCallbackWithDefaultInvokeIfNotRun( |
| std::move(callback), nullptr)); |
| } |
| |
| void CrosHealthd::OnProbeTelemetryInfo( |
| base::OnceClosure once_callback, |
| ash::cros_healthd::mojom::TelemetryInfoPtr result) { |
| if (!result) { |
| LOG(WARNING) << "Failed to parse telemetry information."; |
| std::move(once_callback).Run(); |
| return; |
| } |
| LOG(INFO) << "Probed telemetry info from cros_healthd."; |
| telemetry_info_ = std::make_unique<TelemetryInfo>(); |
| if (!ParseSystemResult(&result, telemetry_info_.get())) |
| LOG(WARNING) << "Failed to parse system information."; |
| if (!ParseMemoryResult(&result, telemetry_info_.get())) |
| LOG(WARNING) << "Failed to parse memory information."; |
| if (!ParseNonRemovableBlockDeviceResult(&result, telemetry_info_.get())) |
| LOG(WARNING) << "Failed to parse non-removable block device information."; |
| if (!ParseCpuResult(&result, telemetry_info_.get())) |
| LOG(WARNING) << "Failed to parse physical CPU information."; |
| if (!ParseBusResult(&result, telemetry_info_.get())) |
| LOG(WARNING) << "Failed to parse bus information."; |
| std::move(once_callback).Run(); |
| } |
| |
| bool CrosHealthd::ParseSystemResult( |
| ash::cros_healthd::mojom::TelemetryInfoPtr* result, |
| TelemetryInfo* telemetry_info) { |
| const auto& system_result = (*result)->system_result; |
| if (system_result) { |
| if (system_result->is_error()) { |
| PrintError(system_result->get_error(), "system information"); |
| return false; |
| } |
| const auto& system_info = system_result->get_system_info(); |
| |
| const auto& dmi_info = system_info->dmi_info; |
| if (dmi_info) { |
| if (dmi_info->sys_vendor.has_value()) |
| telemetry_info->system_info.dmi_info.sys_vendor = |
| dmi_info->sys_vendor.value(); |
| if (dmi_info->product_name.has_value()) |
| telemetry_info->system_info.dmi_info.product_name = |
| dmi_info->product_name.value(); |
| if (dmi_info->product_version.has_value()) |
| telemetry_info->system_info.dmi_info.product_version = |
| dmi_info->product_version.value(); |
| if (dmi_info->bios_version.has_value()) |
| telemetry_info->system_info.dmi_info.bios_version = |
| dmi_info->bios_version.value(); |
| } |
| |
| const auto& os_info = system_info->os_info; |
| if (os_info) { |
| telemetry_info->system_info.os_info.boot_mode = |
| static_cast<TelemetryInfo::SystemInfo::OsInfo::BootMode>( |
| os_info->boot_mode); |
| } |
| } |
| return true; |
| } |
| |
| bool CrosHealthd::ParseMemoryResult( |
| ash::cros_healthd::mojom::TelemetryInfoPtr* result, |
| TelemetryInfo* telemetry_info) { |
| const auto& memory_result = (*result)->memory_result; |
| if (memory_result) { |
| if (memory_result->is_error()) { |
| PrintError(memory_result->get_error(), "memory information"); |
| return false; |
| } |
| const auto& memory_info = memory_result->get_memory_info(); |
| if (memory_info) { |
| telemetry_info->memory_info.total_memory_kib = |
| memory_info->total_memory_kib; |
| } |
| } |
| return true; |
| } |
| |
| bool CrosHealthd::ParseNonRemovableBlockDeviceResult( |
| ash::cros_healthd::mojom::TelemetryInfoPtr* result, |
| TelemetryInfo* telemetry_info) { |
| const auto& non_removable_block_device_result = |
| (*result)->block_device_result; |
| if (non_removable_block_device_result) { |
| if (non_removable_block_device_result->is_error()) { |
| PrintError(non_removable_block_device_result->get_error(), |
| "non-removable block device information"); |
| return false; |
| } |
| const auto& non_removable_block_device_infos = |
| non_removable_block_device_result->get_block_device_info(); |
| for (const auto& non_removable_block_device_info : |
| non_removable_block_device_infos) { |
| telemetry_info->block_device_info.push_back({ |
| .size = non_removable_block_device_info->size, |
| }); |
| } |
| } |
| return true; |
| } |
| |
| bool CrosHealthd::ParseCpuResult( |
| ash::cros_healthd::mojom::TelemetryInfoPtr* result, |
| TelemetryInfo* telemetry_info) { |
| const auto& cpu_result = (*result)->cpu_result; |
| if (cpu_result) { |
| if (cpu_result->is_error()) { |
| PrintError(cpu_result->get_error(), "CPU information"); |
| return false; |
| } |
| const auto& cpu_info = cpu_result->get_cpu_info(); |
| for (const auto& physical_cpu : cpu_info->physical_cpus) { |
| if (physical_cpu->model_name.has_value()) { |
| telemetry_info->cpu_info.physical_cpus.push_back({ |
| .model_name = physical_cpu->model_name.value(), |
| }); |
| } |
| } |
| } |
| return true; |
| } |
| |
| bool CrosHealthd::ParseBusResult( |
| ash::cros_healthd::mojom::TelemetryInfoPtr* result, |
| TelemetryInfo* telemetry_info) { |
| const auto& bus_result = (*result)->bus_result; |
| if (bus_result) { |
| if (bus_result->is_error()) { |
| PrintError(bus_result->get_error(), "bus information"); |
| return false; |
| } |
| const auto& bus_devices = bus_result->get_bus_devices(); |
| for (const auto& bus_device : bus_devices) { |
| if (!bus_device->bus_info) |
| continue; |
| switch (bus_device->bus_info->which()) { |
| case ash::cros_healthd::mojom::BusInfo::Tag::kPciBusInfo: { |
| const auto& pci_bus_info = bus_device->bus_info->get_pci_bus_info(); |
| telemetry_info->bus_devices.push_back({ |
| .device_class = |
| static_cast<TelemetryInfo::BusDevice::BusDeviceClass>( |
| bus_device->device_class), |
| .bus_type_info = |
| TelemetryInfo::BusDevice::PciBusInfo{ |
| .vendor_id = pci_bus_info->vendor_id, |
| .device_id = pci_bus_info->device_id, |
| .driver = pci_bus_info->driver.has_value() |
| ? pci_bus_info->driver.value() |
| : "", |
| }, |
| }); |
| break; |
| } |
| case ash::cros_healthd::mojom::BusInfo::Tag::kUsbBusInfo: { |
| const auto& usb_bus_info = bus_device->bus_info->get_usb_bus_info(); |
| telemetry_info->bus_devices.push_back({ |
| .device_class = |
| static_cast<TelemetryInfo::BusDevice::BusDeviceClass>( |
| bus_device->device_class), |
| .bus_type_info = |
| TelemetryInfo::BusDevice::UsbBusInfo{ |
| .vendor_id = usb_bus_info->vendor_id, |
| .product_id = usb_bus_info->product_id, |
| }, |
| }); |
| break; |
| } |
| case ash::cros_healthd::mojom::BusInfo::Tag::kThunderboltBusInfo: { |
| break; |
| } |
| case ash::cros_healthd::mojom::BusInfo::Tag::kUnmappedField: { |
| LOG(ERROR) << "Get unmapped Mojo fields by retrieving bus info from " |
| "cros_healthd"; |
| break; |
| } |
| } |
| } |
| } |
| return true; |
| } |
| |
| } // namespace chromeos_update_engine |
