| |
| #pragma once |
| |
| #include "app.hpp" |
| #include "async_resp.hpp" |
| #include "dbus_utility.hpp" |
| #include "error_messages.hpp" |
| #include "http_request.hpp" |
| #include "managed_store.hpp" |
| #include "openbmc_dbus_rest.hpp" |
| #include "privileges.hpp" |
| #include "query.hpp" |
| #include "registries/privilege_registry.hpp" |
| #include "routing.hpp" |
| |
| #include <boost/algorithm/string/predicate.hpp> |
| #include <nlohmann/json.hpp> |
| #include <sdbusplus/asio/property.hpp> |
| |
| #include <string> |
| #include <string_view> |
| #include <unordered_set> |
| |
| #ifdef UNIT_TEST_BUILD |
| #include "test/g3/mock_managed_store.hpp" // NOLINT |
| #endif |
| |
| namespace redfish |
| { |
| |
| using SensorVariantType = dbus::utility::DbusVariantType; |
| |
| const std::unordered_set<std::string> daemonDoublePropertiesSet{ |
| "KernelTimeSeconds", "UserTimeSeconds", "UptimeSeconds"}; |
| |
| const std::unordered_set<std::string> daemonU32TPropertiesSet{ |
| "ResidentSetSizeBytes", "NFileDescriptors", "RestartCount"}; |
| |
| constexpr std::array bootupTimeProperties = { |
| "FirmwareTimestampMonotonic", "LoaderTimestampMonotonic", |
| "KernelTimestampMonotonic", "InitRDTimestampMonotonic", |
| "UserspaceTimestampMonotonic", "FinishTimestampMonotonic"}; |
| |
| constexpr std::array bootupTimeMetricName = { |
| "FirmwareTimeSeconds", "LoaderTimeSeconds", "KernelTimeSeconds", |
| "InitrdTimeSeconds", "UserSpaceTimeSeconds"}; |
| |
| const std::string healthMon = "xyz.openbmc_project.HealthMon"; |
| |
| inline std::optional<std::pair<std::string, std::string>> |
| checkAndGetSoleGetSubTreeResponse( |
| const dbus::utility::MapperGetSubTreeResponse& subtree) |
| { |
| if (subtree.empty()) |
| { |
| BMCWEB_LOG_DEBUG << "Can't find bmc D-Bus object!"; |
| return std::nullopt; |
| } |
| |
| // TODO: Consider Multi-BMC cases |
| // Assume only 1 bmc D-Bus object |
| // Throw an error if there is more than 1 |
| if (subtree.size() > 1) |
| { |
| BMCWEB_LOG_DEBUG << "Found more than 1 bmc D-Bus object!"; |
| return std::nullopt; |
| } |
| |
| if (subtree[0].first.empty() || subtree[0].second.size() != 1) |
| { |
| BMCWEB_LOG_DEBUG << "Error getting bmc D-Bus object!"; |
| return std::nullopt; |
| } |
| |
| return std::make_pair(subtree[0].first, subtree[0].second[0].first); |
| } |
| |
| // Returns the sole non-Object Mapper service |
| inline std::optional<std::string> checkAndGetSoleNonMapperGetObjectResponse( |
| const dbus::utility::MapperGetObject& objects) |
| { |
| if (objects.empty()) |
| { |
| return std::nullopt; |
| } |
| |
| for (const std::pair<std::string, std::vector<std::string>>& |
| serviceAndIfaces : objects) |
| { |
| if (serviceAndIfaces.first != "xyz.openbmc_project.ObjectMapper") |
| { |
| return serviceAndIfaces.first; |
| } |
| } |
| return std::nullopt; |
| } |
| |
| inline void populateProcessorStatistics( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| { |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| const std::array<std::pair<std::string, std::string>, 2> |
| processorStatisticMapping{ |
| {{"/xyz/openbmc_project/metric/bmc/cpu/kernel", "KernelPercent"}, |
| {"/xyz/openbmc_project/metric/bmc/cpu/user", "UserPercent"}}}; |
| |
| for (const auto& mapping : processorStatisticMapping) |
| { |
| dbus_utils::getProperty<double>( |
| healthMon, mapping.first, "xyz.openbmc_project.Metric.Value", |
| "Value", context, |
| [asyncResp, property(mapping.second)]( |
| const boost::system::error_code ec2, double value) { |
| if (ec2) |
| { |
| BMCWEB_LOG_ERROR << "DBus response error on getProperty " |
| << ec2; |
| return; |
| } |
| asyncResp->res.jsonValue["ProcessorStatistics"][property] = value; |
| }); |
| } |
| } |
| |
| inline void populateMemoryStatistics( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| { |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| dbus_utils::getProperty<double>( |
| healthMon, "/xyz/openbmc_project/metric/bmc/memory/available", |
| "xyz.openbmc_project.Metric.Value", "Value", context, |
| [asyncResp](const boost::system::error_code ec2, double value) { |
| if (ec2) |
| { |
| BMCWEB_LOG_ERROR << "DBus response error on getProperty " << ec2; |
| return; |
| } |
| asyncResp->res.jsonValue["MemoryStatistics"]["AvailableBytes"] = |
| static_cast<int64_t>(value); |
| }); |
| } |
| |
| inline void |
| populateRWFSStatistics(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| { |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| dbus_utils::getProperty<double>( |
| healthMon, "/xyz/openbmc_project/metric/bmc/storage/rw", |
| "xyz.openbmc_project.Metric.Value", "Value", context, |
| [asyncResp](const boost::system::error_code ec, double value) { |
| if (ec) |
| { |
| BMCWEB_LOG_ERROR << "DBus response error on getProperty " << ec; |
| return; |
| } |
| asyncResp->res.jsonValue["Oem"]["Google"]["RWStorageSpaceUsageBytes"] = |
| static_cast<int64_t>(value); |
| }); |
| } |
| |
| inline void |
| populateTMPFSStatistics(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| { |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| dbus_utils::getProperty<double>( |
| healthMon, "/xyz/openbmc_project/metric/bmc/storage/tmp", |
| "xyz.openbmc_project.Metric.Value", "Value", context, |
| [asyncResp](const boost::system::error_code ec, double value) { |
| if (ec) |
| { |
| BMCWEB_LOG_ERROR << "DBus response error on getProperty " << ec; |
| return; |
| } |
| asyncResp->res.jsonValue["Oem"]["Google"]["TMPStorageSpaceUsageBytes"] = |
| static_cast<int64_t>(value); |
| }); |
| } |
| |
| /** |
| * @brief Find the endpoints for an Association definition. |
| * |
| * @param[i,o] asyncResp - Async response object |
| * |
| * @return void |
| */ |
| inline void |
| findBmcInventory(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| { |
| populateProcessorStatistics(asyncResp); |
| populateMemoryStatistics(asyncResp); |
| populateRWFSStatistics(asyncResp); |
| populateTMPFSStatistics(asyncResp); |
| } |
| |
| inline void getBootInfo(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| { |
| const std::array<std::string, 2> bootInfoProperties = { |
| {"BootCount", "CrashCount"}}; |
| |
| for (const std::string& propertyName : bootInfoProperties) |
| { |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| dbus_utils::getProperty<uint32_t>( |
| "xyz.openbmc_project.Metric", "/xyz/openbmc_project/metric/bmc0", |
| "xyz.openbmc_project.Metric.BMC", propertyName, context, |
| [asyncResp, propertyName](const boost::system::error_code ec, |
| uint32_t property) { |
| if (ec) |
| { |
| BMCWEB_LOG_ERROR << "DBus error getting boot count"; |
| return; |
| } |
| |
| asyncResp->res.jsonValue["BootInfo"][propertyName] = property; |
| }); |
| } |
| } |
| |
| inline void calculateBootTimeResp( |
| const std::shared_ptr<bmcweb::AsyncResp>& aResp, |
| const std::vector<std::pair<std::string, dbus::utility::DbusVariantType>>& |
| properties) |
| { |
| static_assert(bootupTimeProperties.size() == |
| bootupTimeMetricName.size() + 1); |
| const uint32_t kernelIdx = |
| std::find(bootupTimeProperties.begin(), bootupTimeProperties.end(), |
| "KernelTimestampMonotonic") - |
| bootupTimeProperties.begin(); |
| uint64_t lastTime = 0; |
| uint32_t metricIdx = 0; |
| |
| for (const auto& s : bootupTimeMetricName) |
| { |
| aResp->res.jsonValue["BootTimeStatistics"][s] = 0.0; |
| } |
| // each metric should be calculated as next monotime - curr monotime |
| // some timestamps maybe 0 if the hardware doesn't support it. In this |
| // case we simply set that metrics to 0, and accumulate the diff until |
| // an available time is seen |
| // e.g. kernelmono initrdmono usermono finishmono is 0, 4, 0, 10 |
| // The metric values kerneltime initrdtime usertime should be 4, 0, 6 |
| try |
| { |
| for (uint32_t i = 0; i < bootupTimeProperties.size(); ++i) |
| { |
| const uint64_t* currTime = nullptr; |
| const bool success = sdbusplus::unpackPropertiesNoThrow( |
| dbus_utils::UnpackErrorPrinter(), properties, |
| static_cast<std::string>(bootupTimeProperties[i]), currTime); |
| if (!success || currTime == nullptr) |
| { |
| messages::internalError(aResp->res); |
| return; |
| } |
| |
| if (i == 0) |
| { |
| lastTime = *currTime; |
| continue; |
| } |
| uint64_t timeDiff = 0; |
| // KernelTime is 0 and timestamps before kernelTime are negative, |
| // timestamps after kernel are positive. |
| if (*currTime == 0 && i != kernelIdx) |
| { |
| continue; |
| } |
| |
| if (i <= kernelIdx) |
| { |
| if (lastTime != 0) |
| { |
| timeDiff = lastTime - *currTime; |
| } |
| } |
| else |
| { |
| timeDiff = *currTime - lastTime; |
| } |
| |
| lastTime = *currTime; |
| |
| aResp->res.jsonValue["BootTimeStatistics"] |
| [bootupTimeMetricName[metricIdx]] = |
| static_cast<double>(timeDiff) / 1000000.0; |
| metricIdx = i; |
| } |
| } |
| catch (...) |
| { |
| messages::internalError(aResp->res); |
| } |
| } |
| |
| inline void getBootTimeInfo(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| { |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| managedStore::GetManagedObjectStore()->getAllProperties( |
| "org.freedesktop.systemd1", "/org/freedesktop/systemd1", |
| "org.freedesktop.systemd1.Manager", context, |
| [asyncResp](const boost::system::error_code ec2, |
| const dbus::utility::DBusPropertiesMap& properties) { |
| if (ec2) |
| { |
| BMCWEB_LOG_ERROR << "DBUS error getting boot time"; |
| return; |
| } |
| calculateBootTimeResp(asyncResp, properties); |
| }); |
| } |
| |
| inline void |
| populateDaemonEntry(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& objectPath, |
| const std::string& filterServiceName) |
| { |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| managedStore::GetManagedObjectStore()->getAllProperties( |
| "xyz.openbmc_project.Metric", objectPath, |
| "xyz.openbmc_project.Metric.Daemon", context, |
| [asyncResp, filterServiceName](const boost::system::error_code ec, |
| const dbus::utility::DBusPropertiesMap& propertyMap) { |
| if (ec) |
| { |
| BMCWEB_LOG_ERROR << "DBus error getting daemon property"; |
| return; |
| } |
| |
| nlohmann::json daemon; |
| |
| for (const auto& propertyPair : propertyMap) |
| { |
| |
| if (propertyPair.first == "CommandLine") |
| { |
| std::string commandLine = |
| std::get<std::string>(propertyPair.second); |
| if (!filterServiceName.empty() && |
| commandLine.find(filterServiceName) == std::string::npos) |
| { |
| BMCWEB_LOG_DEBUG << "Filter param exsits,skipping service:" |
| << commandLine << ". Fitler service name is " |
| << filterServiceName; |
| return; |
| } |
| daemon[propertyPair.first] = commandLine; |
| continue; |
| } |
| |
| if (daemonDoublePropertiesSet.contains(propertyPair.first)) |
| { |
| daemon[propertyPair.first] = |
| std::get<double>(propertyPair.second); |
| continue; |
| } |
| |
| if (daemonU32TPropertiesSet.contains(propertyPair.first)) |
| { |
| daemon[propertyPair.first] = |
| std::get<uint32_t>(propertyPair.second); |
| continue; |
| } |
| } |
| |
| asyncResp->res.jsonValue["TopProcesses"].emplace_back(daemon); |
| }); |
| } |
| |
| inline void getDaemonInfo(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const query_param::Query& delegatedQuery) |
| { |
| asyncResp->res.jsonValue["TopProcesses"] = nlohmann::json::array(); |
| |
| std::string filterServiceName; |
| if (!delegatedQuery.filter.empty()) |
| { |
| std::vector<std::string> filterParams; |
| bmcweb::split(filterParams, delegatedQuery.filter, ' '); |
| |
| if (filterParams.size() != 3 || |
| filterParams[0] != "TopProcesses.CommandLine" || |
| filterParams[1] != "eq") |
| { |
| redfish::messages::queryParameterValueFormatError( |
| asyncResp->res, "$filter", delegatedQuery.filter); |
| asyncResp->res.result(boost::beast::http::status::not_implemented); |
| return; |
| } |
| filterServiceName = filterParams[2]; |
| } |
| |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| dbus_utils::getProperty<std::vector<std::string>>( |
| "xyz.openbmc_project.ObjectMapper", |
| "/xyz/openbmc_project/metric/bmc0/daemon", |
| "xyz.openbmc_project.Association", "endpoints", context, |
| [asyncResp, filterServiceName](const boost::system::error_code ec, |
| const std::vector<std::string>& endpoints) { |
| if (ec) |
| { |
| BMCWEB_LOG_ERROR |
| << "DBus error getting daemon association endpoints"; |
| return; |
| } |
| |
| for (const auto& endpoint : endpoints) |
| { |
| populateDaemonEntry(asyncResp, endpoint, filterServiceName); |
| } |
| }); |
| } |
| |
| inline void getLatencyInfo(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| { |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| dbus_utils::getProperty<double>( |
| "xyz.openbmc_project.Metric", "/xyz/openbmc_project/metric/bmc0", |
| "xyz.openbmc_project.Metric.BMC", "Latency", context, |
| [asyncResp](const boost::system::error_code ec, const double property) { |
| if (ec) |
| { |
| BMCWEB_LOG_ERROR |
| << "DBus error getting daemon association endpoints"; |
| return; |
| } |
| |
| asyncResp->res.jsonValue["Oem"]["Google"]["Latency"] = property; |
| }); |
| } |
| |
| inline void |
| afterGetManagerStartTime(const std::shared_ptr<bmcweb::AsyncResp>& aResp, |
| const boost::system::error_code& ec, |
| uint64_t bmcwebResetTime) |
| { |
| if (ec) |
| { |
| // Not all servers will be running in systemd, so ignore the error. |
| return; |
| } |
| using std::chrono::steady_clock; |
| |
| std::chrono::duration<steady_clock::rep, std::micro> usReset{ |
| bmcwebResetTime}; |
| steady_clock::time_point resetTime{usReset}; |
| |
| steady_clock::time_point now = steady_clock::now(); |
| |
| steady_clock::duration runTime = now - resetTime; |
| |
| if (runTime < steady_clock::duration::zero()) |
| { |
| BMCWEB_LOG_CRITICAL << "Uptime was negative????"; |
| messages::internalError(aResp->res); |
| return; |
| } |
| |
| // Floor to the closest millisecond |
| using Milli = std::chrono::duration<steady_clock::rep, std::milli>; |
| Milli milli = std::chrono::floor<Milli>(runTime); |
| |
| using SecondsFloat = std::chrono::duration<double>; |
| SecondsFloat sec = std::chrono::duration_cast<SecondsFloat>(milli); |
| |
| aResp->res.jsonValue["ServiceRootUptimeSeconds"] = sec.count(); |
| } |
| |
| inline void |
| managerGetServiceRootUptime(const std::shared_ptr<bmcweb::AsyncResp>& aResp) |
| { |
| managedStore::ManagedObjectStoreContext context(aResp); |
| dbus_utils::getProperty<uint64_t>( |
| "org.freedesktop.systemd1", |
| "/org/freedesktop/systemd1/unit/bmcweb_2eservice", |
| "org.freedesktop.systemd1.Unit", "ActiveEnterTimestampMonotonic", |
| context, std::bind_front(afterGetManagerStartTime, aResp)); |
| } |
| /** |
| * handleManagerDiagnosticData supports ManagerDiagnosticData. |
| * It retrieves BMC health information from various DBus resources and returns |
| * the information through the response. |
| */ |
| inline void handleManagerDiagnosticDataGet( |
| crow::App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| { |
| query_param::QueryCapabilities capabilities = { |
| .canDelegateFilter = true, |
| }; |
| query_param::Query delegatedQuery; |
| if (!redfish::setUpRedfishRouteWithDelegation(app, req, asyncResp, |
| delegatedQuery, capabilities)) |
| { |
| return; |
| } |
| asyncResp->res.jsonValue["@odata.type"] = |
| "#ManagerDiagnosticData.v1_2_0.ManagerDiagnosticData"; |
| asyncResp->res.jsonValue["@odata.id"] = |
| "/redfish/v1/Managers/bmc/ManagerDiagnosticData"; |
| asyncResp->res.jsonValue["Id"] = "ManagerDiagnosticData"; |
| asyncResp->res.jsonValue["Name"] = "Manager Diagnostic Data"; |
| |
| #ifdef BMCWEB_ENABLE_STATEFUL_BMCWEB |
| asyncResp->res.jsonValue["Oem"]["Google"]["GoogleManagedObjectStoreMetrics"] |
| ["@odata.id"] = |
| "/redfish/v1/Managers/bmc/ManagerDiagnosticData/Oem/Google/GoogleManagedObjectStoreMetrics"; |
| #endif |
| |
| managerGetServiceRootUptime(asyncResp); |
| |
| // Start the first step of the 4-step process to populate |
| // the BMC diagnostic data |
| findBmcInventory(asyncResp); |
| getBootInfo(asyncResp); |
| getBootTimeInfo(asyncResp); |
| getDaemonInfo(asyncResp, delegatedQuery); |
| getLatencyInfo(asyncResp); |
| } |
| |
| inline void requestRoutesManagerDiagnosticData(App& app) |
| { |
| BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/ManagerDiagnosticData") |
| .privileges(redfish::privileges::getManagerDiagnosticData) |
| .methods(boost::beast::http::verb::get)( |
| std::bind_front(handleManagerDiagnosticDataGet, std::ref(app))); |
| } |
| |
| } // namespace redfish |
