psutil: Add PSU update validation logic
This commit adds the PSUUpdateValidator class implementation which
validates whether it is safe to proceed with a PSU firmware update
based on current system state. It verifies the following:
- All present PSUs match the model of the target PSU
- Count the number of present PSUs in the system
- Ensure that the number of PSUs currently present, none faulty and
all of the same model, is sufficient to meet the PSU requirement
specified in the system configuration
This validator fetches PSU inventory paths, properties such as
'SupportedModel' and 'RedundantCount', and checks the PSU presence and
not faulty via D-Bus.
The method `validToUpdate()` encapsulates the overall logic, returning
true if all criteria for a safe update are met.
This class is designed to be integrated before triggering PSU updates
to ensure system safety.
Tested:
- Ran psutils with --validate on powered-on system, verified update
blocked
- Ran psutils with simulated PSUs of mismatched models, verified
update blocked
- Ran with matching models and sufficient present PSUs, verified
update succeeded
Change-Id: I367ef6d1b2cd66e8209f6b67a325de2b1a6da12a
Signed-off-by: Faisal Awada <faisal@us.ibm.com>
diff --git a/tools/power-utils/main.cpp b/tools/power-utils/main.cpp
index 5adbb1b..ca8a6fe 100644
--- a/tools/power-utils/main.cpp
+++ b/tools/power-utils/main.cpp
@@ -16,6 +16,7 @@
#include "model.hpp"
#include "updater.hpp"
#include "utility.hpp"
+#include "validator.hpp"
#include "version.hpp"
#include <CLI/CLI.hpp>
@@ -31,6 +32,7 @@
{
std::string psuPathVersion, psuPathModel;
std::vector<std::string> versions;
+ bool validateUpdate = false;
bool rawOutput = false;
std::vector<std::string> updateArguments;
@@ -42,11 +44,17 @@
"Get PSU model from inventory path");
action->add_option("-c,--compare", versions,
"Compare and get the latest version");
- action
- ->add_option("-u,--update", updateArguments,
- "Update PSU firmware, expecting two arguments: "
- "<PSU inventory path> <image-dir>")
- ->expected(2);
+ auto updateOpt =
+ action
+ ->add_option("-u,--update", updateArguments,
+ "Update PSU firmware, expecting two arguments: "
+ "<PSU inventory path> <image-dir>")
+ ->expected(2)
+ ->type_name("PSU_PATH IMAGE_DIR");
+ app.add_flag(
+ "--validate", validateUpdate,
+ "Validate number of present PSU vs number of required PSUs and all PSUs have same model before updating firmware")
+ ->needs(updateOpt);
action->require_option(1); // Only one option is supported
app.add_flag("--raw", rawOutput, "Output raw text without linefeed");
CLI11_PARSE(app, argc, argv);
@@ -69,7 +77,18 @@
if (!updateArguments.empty())
{
assert(updateArguments.size() == 2);
- if (updater::update(bus, updateArguments[0], updateArguments[1]))
+ bool updateStatus = false;
+ if (validateUpdate)
+ {
+ updateStatus = updater::validateAndUpdate(bus, updateArguments[0],
+ updateArguments[1]);
+ }
+ else
+ {
+ updateStatus =
+ updater::update(bus, updateArguments[0], updateArguments[1]);
+ }
+ if (updateStatus)
{
ret = "Update successful";
lg2::info("Successful update to PSU: {PSU}", "PSU",
diff --git a/tools/power-utils/meson.build b/tools/power-utils/meson.build
index 790e1d2..f7c491e 100644
--- a/tools/power-utils/meson.build
+++ b/tools/power-utils/meson.build
@@ -5,6 +5,7 @@
'aei_updater.cpp',
'utils.cpp',
'model.cpp',
+ 'validator.cpp',
'main.cpp',
dependencies: [
cli11_dep,
diff --git a/tools/power-utils/test/meson.build b/tools/power-utils/test/meson.build
index 3ac7b5c..ae29078 100644
--- a/tools/power-utils/test/meson.build
+++ b/tools/power-utils/test/meson.build
@@ -7,6 +7,8 @@
'test_version.cpp',
'../updater.cpp',
'../aei_updater.cpp',
+ '../validator.cpp',
+ '../model.cpp',
'../utils.cpp',
'../version.cpp',
dependencies: [gtest, gmock, nlohmann_json_dep, phosphor_logging],
diff --git a/tools/power-utils/updater.cpp b/tools/power-utils/updater.cpp
index 16e225f..07e74e9 100644
--- a/tools/power-utils/updater.cpp
+++ b/tools/power-utils/updater.cpp
@@ -21,6 +21,7 @@
#include "types.hpp"
#include "utility.hpp"
#include "utils.hpp"
+#include "validator.hpp"
#include "version.hpp"
#include <phosphor-logging/lg2.hpp>
@@ -210,6 +211,22 @@
return ret == 0;
}
+bool validateAndUpdate(sdbusplus::bus_t& bus,
+ const std::string& psuInventoryPath,
+ const std::string& imageDir)
+{
+ auto poweredOn = phosphor::power::util::isPoweredOn(bus, true);
+ validator::PSUUpdateValidator psuValidator(bus, psuInventoryPath);
+ if (!poweredOn && psuValidator.validToUpdate())
+ {
+ return updater::update(bus, psuInventoryPath, imageDir);
+ }
+ else
+ {
+ return false;
+ }
+}
+
Updater::Updater(const std::string& psuInventoryPath,
const std::string& devPath, const std::string& imageDir) :
bus(sdbusplus::bus::new_default()), psuInventoryPath(psuInventoryPath),
diff --git a/tools/power-utils/updater.hpp b/tools/power-utils/updater.hpp
index 21bc4cd..79ecc5b 100644
--- a/tools/power-utils/updater.hpp
+++ b/tools/power-utils/updater.hpp
@@ -53,6 +53,21 @@
bool update(sdbusplus::bus_t& bus, const std::string& psuInventoryPath,
const std::string& imageDir);
+/**
+ * Validate number of present PSUs vs number of required PSUs for this system,
+ * and validate all PSUs have same model before proceeding to Update PSU
+ * firmware
+ *
+ * @param[in] bus - The sdbusplus DBus bus connection
+ * @param[in] psuInventoryPath - The inventory path of the PSU
+ * @param[in] imageDir - The directory containing the PSU image
+ *
+ * @return true if successful, otherwise false
+ */
+bool validateAndUpdate(sdbusplus::bus_t& bus,
+ const std::string& psuInventoryPath,
+ const std::string& imageDir);
+
class Updater
{
public:
diff --git a/tools/power-utils/validator.cpp b/tools/power-utils/validator.cpp
new file mode 100644
index 0000000..7942be9
--- /dev/null
+++ b/tools/power-utils/validator.cpp
@@ -0,0 +1,170 @@
+#include "validator.hpp"
+
+#include "model.hpp"
+
+#include <phosphor-logging/lg2.hpp>
+
+#include <iostream>
+
+namespace validator
+{
+using namespace phosphor::power::util;
+constexpr auto supportedConfIntf =
+ "xyz.openbmc_project.Configuration.SupportedConfiguration";
+const auto IBMCFFPSInterface =
+ "xyz.openbmc_project.Configuration.IBMCFFPSConnector";
+const auto objectPath = "/";
+
+bool PSUUpdateValidator::areAllPsuSameModel()
+{
+ try
+ {
+ targetPsuModel = model::getModel(bus, psuPath);
+ psuPaths = getPSUInventoryPaths(bus);
+ for (const auto& path : psuPaths)
+ {
+ auto thisPsuModel = model::getModel(bus, path);
+ // All PSUs must have same model
+ if (targetPsuModel != thisPsuModel)
+ {
+ lg2::error(
+ "PSU models do not match, targetPsuModel= {TARGET}, thisPsuModel= {THISPSU}",
+ "TARGET", targetPsuModel, "THISPSU", thisPsuModel);
+ return false;
+ }
+ }
+ }
+ catch (const std::exception& e)
+ {
+ lg2::error("Failed to get all PSUs from EM, error {ERROR}", "ERROR", e);
+ return false;
+ }
+ return true;
+}
+
+bool PSUUpdateValidator::countPresentPsus()
+{
+ auto psuPaths = getPSUInventoryPaths(bus);
+ for (const auto& path : psuPaths)
+ {
+ auto present = false;
+ try
+ {
+ getProperty(INVENTORY_IFACE, PRESENT_PROP, path,
+ INVENTORY_MGR_IFACE, bus, present);
+ if (present)
+ {
+ if (!isItFunctional(path))
+ {
+ lg2::error("PSU {PATH} is not functional", "PATH", path);
+ return false;
+ }
+
+ presentPsuCount++;
+ }
+ }
+ catch (const std::exception& e)
+ {
+ lg2::error("Failed to get PSU present status, error {ERR} ", "ERR",
+ e);
+ return false;
+ }
+ }
+ return true;
+}
+
+bool PSUUpdateValidator::getRequiredPsus()
+{
+ try
+ {
+ supportedObjects = getSubTree(bus, objectPath, supportedConfIntf, 0);
+ }
+ catch (std::exception& e)
+ {
+ lg2::error("Failed to retrieve supported configuration");
+ return false;
+ }
+ for (const auto& [objPath, services] : supportedObjects)
+ {
+ if (objPath.empty() || services.empty())
+ {
+ continue;
+ }
+
+ std::string service = services.begin()->first;
+ try
+ {
+ properties =
+ getAllProperties(bus, objPath, supportedConfIntf, service);
+ }
+ catch (const std::exception& e)
+ {
+ lg2::error(
+ "Failed to get all PSU {PSUPATH} properties error: {ERR}",
+ "PSUPATH", objPath, "ERR", e);
+ return false;
+ }
+ auto propertyModel = properties.find("SupportedModel");
+ if (propertyModel == properties.end())
+ {
+ continue;
+ }
+ try
+ {
+ auto supportedModel = std::get<std::string>(propertyModel->second);
+ if ((supportedModel.empty()) || (supportedModel != targetPsuModel))
+ {
+ continue;
+ }
+ }
+ catch (const std::bad_variant_access& e)
+ {
+ lg2::error("Failed to get supportedModel, error: {ERR}", "ERR", e);
+ }
+
+ try
+ {
+ auto redundantCountProp = properties.find("RedundantCount");
+ if (redundantCountProp != properties.end())
+ {
+ redundantCount = static_cast<int>(
+ std::get<uint64_t>(redundantCountProp->second));
+ break;
+ }
+ }
+ catch (const std::bad_variant_access& e)
+ {
+ lg2::error("Redundant type mismatch, error: {ERR}", "ERR", e);
+ }
+ }
+ return true;
+}
+
+bool PSUUpdateValidator::isItFunctional(const std::string& path)
+{
+ try
+ {
+ bool isFunctional = false;
+ getProperty(OPERATIONAL_STATE_IFACE, FUNCTIONAL_PROP, path,
+ INVENTORY_MGR_IFACE, bus, isFunctional);
+ return isFunctional;
+ }
+ catch (const std::exception& e)
+ {
+ lg2::error("Failed to get PSU fault status, error {ERR} ", "ERR", e);
+ return false;
+ }
+}
+
+bool PSUUpdateValidator::validToUpdate()
+{
+ if (areAllPsuSameModel() && countPresentPsus() && getRequiredPsus())
+ {
+ if (presentPsuCount >= redundantCount)
+ {
+ return true;
+ }
+ }
+ return false;
+}
+} // namespace validator
diff --git a/tools/power-utils/validator.hpp b/tools/power-utils/validator.hpp
new file mode 100644
index 0000000..3ce235e
--- /dev/null
+++ b/tools/power-utils/validator.hpp
@@ -0,0 +1,101 @@
+/**
+ * Copyright © 2025 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "types.hpp"
+#include "utility.hpp"
+
+#include <sdbusplus/bus.hpp>
+
+#include <string>
+
+namespace validator
+{
+using namespace phosphor::power::util;
+/**
+ * @class PSUUpdateValidator
+ * @brief This class validates PSU configurations in OpenBMC.
+ */
+class PSUUpdateValidator
+{
+ public:
+ /**
+ * @brief Constructor - Initializes D-Bus connection.
+ *
+ * @param bus The sdbusplus DBus bus connection
+ * @param psuPath PSU inventory path
+ */
+ PSUUpdateValidator(sdbusplus::bus_t& bus, const std::string& psuPath) :
+ bus(bus), psuPath(psuPath)
+ {}
+
+ /**
+ * @brief Checks if all PSUs are of the same model.
+ *
+ * @return true if all PSUs have the same model.
+ * @return false if any PSU has a different model.
+ */
+ bool areAllPsuSameModel();
+
+ /**
+ * @brief Counts the number of PSUs that are physically present and
+ * operational
+ *
+ * @return true if successfully counted present PSUs.
+ * @return false on failure.
+ */
+ bool countPresentPsus();
+
+ /**
+ * @brief Retrieves the required number of PSUs for redundancy.
+ *
+ * @return true if successfully retrieved redundancy count.
+ * @return false on failure.
+ */
+ bool getRequiredPsus();
+
+ /**
+ * @brief Ensure all PSUs have same model, validate all PSUs present
+ * and functional meet or exceed the number of PSUs required for this
+ * system
+ *
+ * @return true if all configuration requirement are met.
+ * @return otherwise false
+ */
+ bool validToUpdate();
+
+ /**
+ * @brief Retrieves the operational PSU status.
+ *
+ * @return true if operational
+ * @return false on operational failure.
+ */
+ bool isItFunctional(const std::string& path);
+
+ private:
+ sdbusplus::bus::bus& bus; // D-Bus connection instance
+ std::vector<std::string> psuPaths; // List of PSU object paths
+ std::string targetPsuModel; // Model name of the reference PSU
+ std::string psuPath; // Path of the referenced PSU
+ DbusSubtree supportedObjects; // D-Bus PSU supported objects
+ DbusPropertyMap properties; // D-Bus PSU properties
+ int presentPsuCount = 0; // Count of physically present PSUs
+ int redundantCount = 0; // Total number of PSUs required to be
+ // in this system configuration.
+};
+
+} // namespace validator