* Copyright (c) 2026 Huawei Technologies Co., Ltd.
* openUBMC is licensed under Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
* http://license.coscl.org.cn/MulanPSL2
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "ssu_card.h"
#include <mc/future.h>
#include <mc/log.h>
#include <mc/runtime.h>
#include "ge_port.h"
#include "ssu_drive.h"
#include "ub_port.h"
namespace dev {
namespace {
double ssu_extract_temperature(int64_t raw)
{
int32_t value = static_cast<int32_t>(raw & 0xFFFFFF);
if ((value & 0x800000) != 0) {
value -= 0x1000000;
}
return static_cast<double>(value);
}
}
ssu_card::ssu_card()
{}
ssu_card::~ssu_card()
{}
bool ssu_card::init(mc::mutable_dict& csr_object, const mc::dict& connector)
{
try {
from_variant(csr_object, *this);
} catch (const std::exception& e) {
elog("ssu_card init failed: ${error}", ("error", e.what()));
return false;
}
m_slot = m_ssu_card.Slot.get_value().as<uint8_t>();
return true;
}
bool ssu_card::start()
{
ilog("ssu_card[ssu_slot=${ssu_slot}]: start() entered, system_id=${sys_id}",
("ssu_slot", static_cast<int>(m_slot))("sys_id", static_cast<int>(m_system_id)));
m_serial_group = mc::make_shared<mc::object>(this);
m_serial_group->bind_executor(mc::runtime::make_io_yielding_strand());
set_group(m_serial_group.get());
init_ge_ports();
init_ub_ports();
init_ssu_drives();
init_firmware_info();
init_upgrade_signal_listener();
m_ssu.PowerState.property_changed().connect([this](const mc::variant& value, const auto& prop) {
evaluate_oob_management();
});
m_chassis.SerialNumber.property_changed().connect([this](const mc::variant& value, const auto& prop) {
nlog("ssu_card[ssu_slot=${ssu_slot}]: SerialNumber property changed, backfilling ssu location",
("ssu_slot", static_cast<int>(m_slot)));
set_ssu_location();
});
if (m_shared_mgmt.ControlOwner.get_value().as<uint8_t>() == SSU_CONTROL_OWNER_YES) {
init_bmc_role_listener();
} else {
nlog("ssu_card[ssu_slot=${ssu_slot}]: ControlOwner=0, no master/standby, OOB management not gated by BMC role",
("ssu_slot", static_cast<int>(m_slot)));
}
evaluate_oob_management();
return true;
}
bool ssu_card::stop()
{
nlog("ssu_card[ssu_slot=${ssu_slot}]: stop() entered", ("ssu_slot", static_cast<int>(m_slot)));
auto* service = get_service();
if (m_bmc_role_match_id != 0) {
if (service != nullptr) {
service->remove_match(m_bmc_role_match_id);
}
m_bmc_role_match_id = 0;
}
if (m_upgrade_prepare_sig != 0) {
if (service != nullptr) {
service->remove_match(m_upgrade_prepare_sig);
}
m_upgrade_prepare_sig = 0;
}
if (m_upgrade_process_sig != 0) {
if (service != nullptr) {
service->remove_match(m_upgrade_process_sig);
}
m_upgrade_process_sig = 0;
}
if (m_upgrade_finish_sig != 0) {
if (service != nullptr) {
service->remove_match(m_upgrade_finish_sig);
}
m_upgrade_finish_sig = 0;
}
uint8_t slot = m_ssu_card.Slot.get_value().as<uint8_t>();
try {
if (service != nullptr) {
mc::variants firmware_info_bios;
std::string id = "BIOS_SSU_" + std::to_string(slot);
firmware_info_bios.push_back(mc::dict{});
firmware_info_bios.push_back(id);
service->call("/bmc/kepler/UpdateService/FirmwareInventory", "bmc.kepler.firmware_mgmt",
"bmc.kepler.UpdateService.FirmwareInventory", "Delete", firmware_info_bios, "a{ss}s",
mc::milliseconds(5000));
nlog("ssu_card[ssu_slot=${ssu_slot}]: stop(), firmware info deleted",
("ssu_slot", static_cast<int>(m_slot)));
}
} catch (const std::exception& e) {
elog("ssu_card[ssu_slot=${ssu_slot}]: stop(), failed to delete firmware info, error=${ex}",
("ssu_slot", static_cast<int>(m_slot))("ex", e.what()));
} catch (...) {
elog("ssu_card[ssu_slot=${ssu_slot}]: stop(), unknown exception deleting firmware info",
("ssu_slot", static_cast<int>(m_slot)));
}
auto ex = executor();
if (ex.running_in_this_thread()) {
stop_mctp_communication();
m_ge_ports.clear();
m_ub_ports.clear();
m_drives.clear();
} else {
auto promise = mc::make_promise<void>(ex);
auto future = promise.get_future();
this->post([this, promise = std::move(promise)]() mutable {
stop_mctp_communication();
m_ge_ports.clear();
m_ub_ports.clear();
m_drives.clear();
promise.set_value();
});
future.get();
}
ilog("ssu_card[ssu_slot=${ssu_slot}]: stop() completed", ("ssu_slot", static_cast<int>(m_slot)));
return true;
}
ssu_oob* ssu_card::get_ssu_oob()
{
if (!m_ssu_oob) {
wlog("ssu_card[ssu_slot=${ssu_slot}]: get_ssu_oob() called but ssu_oob is null",
("ssu_slot", static_cast<int>(m_slot)));
}
return m_ssu_oob.get();
}
void ssu_card::init_ge_ports()
{
auto children = get_children();
for (auto& child : children) {
auto name = child->get_name();
if (name.find("GEPort") == 0) {
auto* port = dynamic_cast<ge_port*>(child.get());
if (port) {
m_ge_ports.push_back(port);
ilog("ssu_card[ssu_slot=${ssu_slot}]: found GEPort child, name=${name}",
("ssu_slot", static_cast<int>(m_slot))("name", name));
} else {
elog("ssu_card[ssu_slot=${ssu_slot}]: GEPort child ${name} is not ge_port driver object, skip",
("ssu_slot", static_cast<int>(m_slot))("name", name));
}
}
}
ilog("ssu_card[ssu_slot=${ssu_slot}]: init_ge_ports done, count=${count}",
("ssu_slot", static_cast<int>(m_slot))("count", m_ge_ports.size()));
}
void ssu_card::init_ub_ports()
{
auto children = get_children();
for (auto& child : children) {
auto name = child->get_name();
if (name.find("UBPort") == 0) {
auto* port = dynamic_cast<ub_port*>(child.get());
if (port) {
m_ub_ports.push_back(port);
port->set_slot(m_slot);
ilog("ssu_card[ssu_slot=${ssu_slot}]: found UBPort child, name=${name}",
("ssu_slot", static_cast<int>(m_slot))("name", name));
} else {
elog("ssu_card[ssu_slot=${ssu_slot}]: UBPort child ${name} is not ub_port driver object, skip",
("ssu_slot", static_cast<int>(m_slot))("name", name));
}
}
}
ilog("ssu_card[ssu_slot=${ssu_slot}]: init_ub_ports done, count=${count}",
("ssu_slot", static_cast<int>(m_slot))("count", m_ub_ports.size()));
}
void ssu_card::init_ssu_drives()
{
auto children = get_children();
for (auto& child : children) {
auto name = child->get_name();
if (name.find("SSUDrive") == 0) {
auto* drive = dynamic_cast<ssu_drive*>(child.get());
if (drive) {
m_drives.push_back(drive);
ilog("ssu_card[ssu_slot=${ssu_slot}]: found SSUDrive child, name=${name}",
("ssu_slot", static_cast<int>(m_slot))("name", name));
} else {
elog("ssu_card[ssu_slot=${ssu_slot}]: SSUDrive child ${name} is not ssu_drive driver object, skip",
("ssu_slot", static_cast<int>(m_slot))("name", name));
}
}
}
ilog("ssu_card[ssu_slot=${ssu_slot}]: init_ssu_drives done, count=${count}",
("ssu_slot", static_cast<int>(m_slot))("count", m_drives.size()));
}
void ssu_card::start_temperature_update_task()
{
if (!m_ssu_oob) {
elog("ssu_card[ssu_slot=${ssu_slot}]: start_temperature_update_task called but ssu_oob is null",
("ssu_slot", static_cast<int>(m_slot)));
return;
}
stop_temperature_update_task();
m_temperature_update_timer = mc::make_shared<mc::timer>(this);
m_temperature_update_timer->timeout.connect([this]() {
update_temperature_once();
});
m_temperature_update_timer->set_single_shot(false);
m_temperature_update_timer->start(mc::milliseconds(SSU_TEMPERATURE_POLL_INTERVAL_MS));
nlog("ssu_card[ssu_slot=${ssu_slot}]: temperature update task started, interval_ms=${interval}",
("ssu_slot", static_cast<int>(m_slot))("interval", SSU_TEMPERATURE_POLL_INTERVAL_MS));
}
void ssu_card::update_temperature_once()
{
if (!m_ssu_oob) {
return;
}
std::vector<int64_t> temperatures;
if (!m_ssu_oob->get_temperature(temperatures)) {
if (m_temperature.TemperatureStatus.get_value().as<uint8_t>() != SSU_TEMPERATURE_STATUS_INVALID) {
m_temperature.TemperatureStatus.set_value(SSU_TEMPERATURE_STATUS_INVALID);
}
for (auto* drive : m_drives) {
if (drive) {
drive->update_temperature_status(SSU_TEMPERATURE_STATUS_INVALID);
}
}
if (m_temperature_result.on_fail()) {
elog("ssu_card[ssu_slot=${ssu_slot}]: get_temperature failed, temperature status set to invalid",
("ssu_slot", static_cast<int>(m_slot)));
} else {
dlog("ssu_card[ssu_slot=${ssu_slot}]: get_temperature still failing, temperature status remains invalid",
("ssu_slot", static_cast<int>(m_slot)));
}
return;
}
if (temperatures.size() > SSU_TEMPERATURE_INDEX_CARD) {
double card_celsius = ssu_extract_temperature(temperatures[SSU_TEMPERATURE_INDEX_CARD]);
if (m_temperature.TemperatureCelsius.get_value().as<double>() != card_celsius) {
m_temperature.TemperatureCelsius.set_value(card_celsius);
}
if (m_temperature.TemperatureStatus.get_value().as<uint8_t>() != SSU_TEMPERATURE_STATUS_NORMAL) {
m_temperature.TemperatureStatus.set_value(SSU_TEMPERATURE_STATUS_NORMAL);
}
}
if (temperatures.size() > SSU_TEMPERATURE_INDEX_DRIVE) {
double drive_celsius = ssu_extract_temperature(temperatures[SSU_TEMPERATURE_INDEX_DRIVE]);
for (auto* drive : m_drives) {
if (drive) {
drive->update_temperature(drive_celsius, SSU_TEMPERATURE_STATUS_NORMAL);
}
}
}
if (m_temperature_result.on_recover()) {
nlog("ssu_card[ssu_slot=${ssu_slot}]: temperature acquisition recovered, count=${count}",
("ssu_slot", static_cast<int>(m_slot))("count", temperatures.size()));
}
}
void ssu_card::stop_temperature_update_task()
{
if (m_temperature_update_timer) {
m_temperature_update_timer->stop();
m_temperature_update_timer->set_parent(nullptr);
m_temperature_update_timer.reset();
}
if (m_temperature.TemperatureStatus.get_value().as<uint8_t>() != SSU_TEMPERATURE_STATUS_INVALID) {
m_temperature.TemperatureStatus.set_value(SSU_TEMPERATURE_STATUS_INVALID);
}
for (auto* drive : m_drives) {
if (drive) {
drive->update_temperature_status(SSU_TEMPERATURE_STATUS_INVALID);
}
}
m_temperature_result.reset();
nlog("ssu_card[ssu_slot=${ssu_slot}]: temperature update task stopped", ("ssu_slot", static_cast<int>(m_slot)));
}
void ssu_card::init_firmware_info()
{
auto* service = get_service();
if (service == nullptr) {
elog("ssu_card[ssu_slot=${ssu_slot}]: init_firmware_info(), service not available, firmware info not "
"registered",
("ssu_slot", static_cast<int>(m_slot)));
return;
}
uint8_t slot = m_ssu_card.Slot.get_value().as<uint8_t>();
try {
mc::variants firmware_info_bios;
mc::dict bios_info;
bios_info["Id"] = "BIOS_SSU_" + std::to_string(slot);
bios_info["Name"] = "Ssu_" + std::to_string(slot) + "_Bios";
bios_info["Version"] = m_bios.Version.get_value().as<std::string>();
bios_info["BuildNum"] = "";
bios_info["ReleaseDate"] = "";
bios_info["LowestSupportedVersion"] = "";
bios_info["SoftwareId"] = "BIOS-SSU";
bios_info["Manufacturer"] = "Huawei";
bios_info["Location"] = "";
bios_info["State"] = "Enabled";
bios_info["Severity"] = "Informational";
bios_info["StageSupported"] = "true";
bios_info["RelatedItem"] = "";
bios_info["ComponentID"] = std::to_string(0x24);
bios_info["SubComponentID"] = std::to_string(0x24010000);
bios_info["FirmwareType"] = "SSUBios";
bios_info["TargetUIDs"] = "";
bios_info["ActiveCondition"] = "PowerOn";
firmware_info_bios.push_back(mc::dict{});
firmware_info_bios.push_back(bios_info);
firmware_info_bios.push_back(true);
firmware_info_bios.push_back(mc::variant(static_cast<uint16_t>(1)));
firmware_info_bios.push_back(mc::variant(static_cast<int32_t>(10)));
service->call("/bmc/kepler/UpdateService/FirmwareInventory", "bmc.kepler.firmware_mgmt",
"bmc.kepler.UpdateService.FirmwareInventory", "Add", firmware_info_bios, "a{ss}a{ss}bqi",
mc::milliseconds(5000));
nlog("ssu_card[ssu_slot=${ssu_slot}]: init_firmware_info(), firmware info registered",
("ssu_slot", static_cast<int>(m_slot)));
} catch (const std::exception& e) {
elog("ssu_card[ssu_slot=${ssu_slot}]: init_firmware_info(), failed to register firmware info, error=${ex}",
("ssu_slot", static_cast<int>(m_slot))("ex", e.what()));
} catch (...) {
elog("ssu_card[ssu_slot=${ssu_slot}]: init_firmware_info(), unknown exception registering firmware info",
("ssu_slot", static_cast<int>(m_slot)));
}
}
bool ssu_card::should_run_oob_management() const
{
uint8_t power_state = m_ssu.PowerState.get_value().as<uint8_t>();
if (power_state != SSU_POWER_STATE_ON) {
return false;
}
if (m_shared_mgmt.ControlOwner.get_value().as<uint8_t>() == SSU_CONTROL_OWNER_YES) {
return m_bmc_role_status == BMC_ROLE_ACTIVE;
}
return true;
}
void ssu_card::evaluate_oob_management()
{
uint8_t power_state = m_ssu.PowerState.get_value().as<uint8_t>();
uint8_t control_owner = m_shared_mgmt.ControlOwner.get_value().as<uint8_t>();
bool should_run = should_run_oob_management();
nlog("ssu_card[ssu_slot=${ssu_slot}]: evaluate_oob_management(), power_state=${power}, control_owner=${owner}, "
"bmc_role_status=${role}, should_run=${run}",
("ssu_slot",
static_cast<int>(m_slot))("power", static_cast<int>(power_state))("owner", static_cast<int>(control_owner))(
"role", static_cast<int>(m_bmc_role_status))("run", static_cast<int>(should_run)));
if (should_run) {
if (!m_mctp_obj) {
nlog("ssu_card[ssu_slot=${ssu_slot}]: OOB enable condition met and not started yet, starting MCTP "
"communication",
("ssu_slot", static_cast<int>(m_slot)));
start_mctp_communication();
} else {
ilog("ssu_card[ssu_slot=${ssu_slot}]: OOB enable condition met but already running, idempotent skip, no "
"duplicate start",
("ssu_slot", static_cast<int>(m_slot)));
}
} else {
if (m_mctp_obj) {
nlog("ssu_card[ssu_slot=${ssu_slot}]: OOB disable condition met and still running, stopping MCTP "
"communication",
("ssu_slot", static_cast<int>(m_slot)));
stop_mctp_communication();
} else {
ilog("ssu_card[ssu_slot=${ssu_slot}]: OOB disable condition met but already stopped, idempotent skip, no "
"duplicate stop",
("ssu_slot", static_cast<int>(m_slot)));
}
}
}
void ssu_card::set_ssu_location()
{
auto sn = m_chassis.SerialNumber.get_value().as<std::string>();
auto slot_id = m_ssu_card.Slot.get_value().as<uint8_t>();
nlog("ssu_card[ssu_slot=${ssu_slot}]: set_ssu_location() called, sn_len=${len}, slot=${slot}, "
"ssu_oob_ready=${ready}",
("ssu_slot", static_cast<int>(m_slot))("len", sn.size())("slot", static_cast<int>(slot_id))(
"ready", m_ssu_oob != nullptr));
if (!m_ssu_oob) {
nlog("ssu_card[ssu_slot=${ssu_slot}]: ssu_oob not ready, skip set_ssu_location (will be backfilled on "
"endpoint create)",
("ssu_slot", static_cast<int>(m_slot)));
return;
}
if (!m_ssu_oob->set_ssu_location(sn, slot_id)) {
elog("ssu_card[ssu_slot=${ssu_slot}]: set_ssu_location failed, sn=${sn}, sn_len=${len}",
("ssu_slot", static_cast<int>(m_slot))("sn", sn)("len", sn.size()));
}
}
void ssu_card::init_bmc_role_listener()
{
auto* service = get_service();
if (service == nullptr) {
elog("ssu_card[ssu_slot=${ssu_slot}]: init_bmc_role_listener(), service not available, BMC role listener "
"not registered",
("ssu_slot", static_cast<int>(m_slot)));
return;
}
if (m_bmc_role_match_id != 0) {
ilog("ssu_card[ssu_slot=${ssu_slot}]: init_bmc_role_listener(), already registered match_id=${id}, "
"idempotent skip",
("ssu_slot", static_cast<int>(m_slot))("id", m_bmc_role_match_id));
return;
}
mc::engine::match_rule rule;
rule.type = "signal";
rule.interface_name = "org.freedesktop.DBus.Properties";
rule.member_name = "PropertiesChanged";
rule.path = mc::string(BMC_GLOBAL_OBJECT_PATH);
mc::engine::filter_spec no_op_filter;
m_bmc_role_match_id = service->add_match(rule, no_op_filter, [this](const mc::engine::message& msg) {
this->post([this, msg] {
handle_bmc_role_changed(msg);
});
});
nlog("ssu_card[ssu_slot=${ssu_slot}]: init_bmc_role_listener(), BMC role listener registered, match_id=${id}, "
"path=${path}, iface=${iface}, member=${member}",
("ssu_slot", static_cast<int>(m_slot))("id", m_bmc_role_match_id)("path", BMC_GLOBAL_OBJECT_PATH)(
"iface", "org.freedesktop.DBus.Properties")("member", "PropertiesChanged"));
query_bmc_role_once();
}
void ssu_card::handle_bmc_role_changed(const mc::engine::message& msg)
{
try {
const auto* sig = msg.try_as<mc::engine::signal_payload>();
if (sig == nullptr || sig->args.size() < 2) {
dlog("ssu_card[ssu_slot=${ssu_slot}]: invalid PropertiesChanged signal payload",
("ssu_slot", static_cast<int>(m_slot)));
return;
}
std::string changed_iface = sig->args[0].as_string();
if (changed_iface != BMC_GLOBAL_IFACE) {
return;
}
if (!sig->args[1].is_dict()) {
dlog("ssu_card[ssu_slot=${ssu_slot}]: PropertiesChanged args[1] is not a dict",
("ssu_slot", static_cast<int>(m_slot)));
return;
}
auto changed_props = sig->args[1].as_dict();
if (!changed_props.contains(BMC_GLOBAL_STATUS_PROP)) {
return;
}
if (!changed_props[BMC_GLOBAL_STATUS_PROP].is_numeric()) {
wlog("ssu_card[ssu_slot=${ssu_slot}]: BMC role Status value is not numeric",
("ssu_slot", static_cast<int>(m_slot)));
return;
}
uint8_t status = changed_props[BMC_GLOBAL_STATUS_PROP].as<uint8_t>();
ilog("ssu_card[ssu_slot=${ssu_slot}]: BMC role Status changed, status=${status}",
("ssu_slot", static_cast<int>(m_slot))("status", static_cast<int>(status)));
update_oob_management(status);
} catch (const std::exception& e) {
elog("ssu_card[ssu_slot=${ssu_slot}]: failed to handle BMC role change, error=${err}",
("ssu_slot", static_cast<int>(m_slot))("err", e.what()));
}
}
void ssu_card::init_upgrade_signal_listener()
{
auto* service = get_service();
if (service == nullptr) {
elog("ssu_card[ssu_slot=${ssu_slot}]: init_upgrade_signal_listener(), service not available, upgrade signal "
"listener not registered",
("ssu_slot", static_cast<int>(m_slot)));
return;
}
SignalDef signals[] = {
{"UpgradePrepareSignal", &m_upgrade_prepare_sig,
[this](const mc::engine::message& msg) {
prepare_upgrade(msg);
}},
{"UpgradeProcessSignal", &m_upgrade_process_sig,
[this](const mc::engine::message& msg) {
process_upgrade(msg);
}},
{"UpgradeFinishSignal", &m_upgrade_finish_sig,
[this](const mc::engine::message& msg) {
finish_upgrade(msg);
}},
};
for (auto& sig : signals) {
if (*(sig.match_id) != 0) {
ilog("ssu_card[ssu_slot=${ssu_slot}]: init_upgrade_signal_listener(), ${member} already registered "
"match_id=${id}, idempotent skip",
("ssu_slot", static_cast<int>(m_slot))("member", sig.member_name)("id", *(sig.match_id)));
continue;
}
mc::engine::match_rule rule;
rule.type = "signal";
rule.interface_name = "bmc.kepler.UpdateService";
rule.member_name = sig.member_name;
rule.path = "/bmc/kepler/UpdateService";
mc::engine::filter_spec no_op_filter;
auto update_func = sig.update_func;
*(sig.match_id) = service->add_match(rule, no_op_filter, [this, update_func](const mc::engine::message& msg) {
this->post([this, msg, update_func] {
update_func(msg);
});
});
nlog("ssu_card[ssu_slot=${ssu_slot}]: init_upgrade_signal_listener(), ${member} registered, match_id=${id}",
("ssu_slot", static_cast<int>(m_slot))("member", sig.member_name)("id", *(sig.match_id)));
}
}
void ssu_card::prepare_upgrade(const mc::engine::message& msg)
{
auto* service = get_service();
if (service == nullptr) {
elog("ssu_card[ssu_slot=${ssu_slot}]: prepare_upgrade(), service not available, cannot reply PrepareReply",
("ssu_slot", static_cast<int>(m_slot)));
return;
}
const auto* sig = msg.try_as<mc::engine::signal_payload>();
if (!sig || sig->args.size() < 6) {
dlog("ssu_card[ssu_slot=${ssu_slot}]: prepare_upgrade(), invalid UpgradePrepareSignal args, size=${size}",
("ssu_slot", static_cast<int>(m_slot))("size", sig ? sig->args.size() : 0));
return;
}
mc::dict ctx = sig->args[0].as<mc::dict>();
int8_t system_id = sig->args[1].as<int8_t>();
std::string firmware_type = sig->args[2].as<std::string>();
std::string cfg_path = sig->args[3].as<std::string>();
std::string hpm_path = sig->args[4].as<std::string>();
mc::dict message_data = sig->args[5].as<mc::dict>();
int8_t upgrade_res = UPGRADE_REPLY_NOT_SUPPORT;
std::string local_version = m_bios.Version.get_value().as<std::string>();
nlog(
"ssu_card[ssu_slot=${ssu_slot}]: prepare_upgrade() signal received, system_id=${sys_id}, firmware_type=${type}",
("ssu_slot", static_cast<int>(m_slot))("sys_id", static_cast<int>(system_id))("type", firmware_type));
if (firmware_type == "SSUBios") {
if (message_data.contains("ForceUpdate") && message_data["ForceUpdate"].as<std::string>() == "false" &&
message_data.contains("Version") && message_data["Version"].as<std::string>() == local_version) {
upgrade_res = UPGRADE_REPLY_SAME_VERSION;
} else {
upgrade_res = m_bios.prepare_upgrade(m_ssu_oob);
}
} else {
nlog("ssu_card[ssu_slot=${ssu_slot}]: prepare_upgrade() ignored, non-SSUBios firmware_type=${type}",
("ssu_slot", static_cast<int>(m_slot))("type", firmware_type));
return;
}
ilog("ssu_card[ssu_slot=${ssu_slot}]: prepare_upgrade(), system_id=${sys_id}, firmware_type=${type}, "
"upgrade_res=${res}, local_version=${ver}, cfg_path=${cfg}, hpm_path=${hpm}",
("ssu_slot", static_cast<int>(m_slot))("sys_id", static_cast<int>(system_id))("type", firmware_type)(
"res", static_cast<int>(upgrade_res))("ver", local_version)("cfg", cfg_path)("hpm", hpm_path));
try {
mc::variants update_prepare_reply;
update_prepare_reply.push_back(mc::dict{});
update_prepare_reply.push_back(system_id);
update_prepare_reply.push_back(firmware_type);
update_prepare_reply.push_back(local_version);
update_prepare_reply.push_back(upgrade_res);
update_prepare_reply.push_back(message_data);
service->call("/bmc/kepler/UpdateService", "bmc.kepler.firmware_mgmt", "bmc.kepler.UpdateService",
"PrepareReply", update_prepare_reply, "a{ss}issia{ss}", mc::milliseconds(5000));
} catch (const std::exception& e) {
elog("ssu_card[ssu_slot=${ssu_slot}]: prepare_upgrade(), failed to send PrepareReply, error=${ex}",
("ssu_slot", static_cast<int>(m_slot))("ex", e.what()));
} catch (...) {
elog("ssu_card[ssu_slot=${ssu_slot}]: prepare_upgrade(), unknown exception sending PrepareReply",
("ssu_slot", static_cast<int>(m_slot)));
}
}
void ssu_card::process_upgrade(const mc::engine::message& msg)
{
auto* service = get_service();
if (service == nullptr) {
elog("ssu_card[ssu_slot=${ssu_slot}]: process_upgrade(), service not available, cannot reply ProcessReply",
("ssu_slot", static_cast<int>(m_slot)));
return;
}
const auto* sig = msg.try_as<mc::engine::signal_payload>();
if (!sig || sig->args.size() < 5) {
dlog("ssu_card[ssu_slot=${ssu_slot}]: process_upgrade(), invalid UpgradeProcessSignal args, size=${size}",
("ssu_slot", static_cast<int>(m_slot))("size", sig ? sig->args.size() : 0));
return;
}
mc::dict ctx = sig->args[0].as<mc::dict>();
int8_t system_id = sig->args[1].as<int8_t>();
std::string firmware_type = sig->args[2].as<std::string>();
std::string file_path = sig->args[3].as<std::string>();
mc::dict message_data = sig->args[4].as<mc::dict>();
int8_t upgrade_res = UPGRADE_REPLY_NOT_SUPPORT;
nlog("ssu_card[ssu_slot=${ssu_slot}]: process_upgrade() signal received, system_id=${sys_id}, "
"firmware_type=${type}, file_path=${path}",
("ssu_slot", static_cast<int>(m_slot))("sys_id",
static_cast<int>(system_id))("type", firmware_type)("path", file_path));
if (firmware_type == "SSUBios") {
upgrade_res = m_bios.process_upgrade(file_path);
} else {
nlog("ssu_card[ssu_slot=${ssu_slot}]: process_upgrade() ignored, non-SSUBios firmware_type=${type}",
("ssu_slot", static_cast<int>(m_slot))("type", firmware_type));
return;
}
ilog("ssu_card[ssu_slot=${ssu_slot}]: process_upgrade(), system_id=${sys_id}, firmware_type=${type}, "
"upgrade_res=${res}, file_path=${path}",
("ssu_slot", static_cast<int>(m_slot))("sys_id", static_cast<int>(system_id))("type", firmware_type)(
"res", static_cast<int>(upgrade_res))("path", file_path));
try {
mc::variants update_process_reply;
update_process_reply.push_back(mc::dict{});
update_process_reply.push_back(system_id);
update_process_reply.push_back(firmware_type);
update_process_reply.push_back(upgrade_res);
update_process_reply.push_back(message_data);
service->call("/bmc/kepler/UpdateService", "bmc.kepler.firmware_mgmt", "bmc.kepler.UpdateService",
"ProcessReply", update_process_reply, "a{ss}isia{ss}", mc::milliseconds(5000));
} catch (const std::exception& e) {
elog("ssu_card[ssu_slot=${ssu_slot}]: process_upgrade(), failed to send ProcessReply, error=${ex}",
("ssu_slot", static_cast<int>(m_slot))("ex", e.what()));
} catch (...) {
elog("ssu_card[ssu_slot=${ssu_slot}]: process_upgrade(), unknown exception sending ProcessReply",
("ssu_slot", static_cast<int>(m_slot)));
}
}
void ssu_card::finish_upgrade(const mc::engine::message& msg)
{
auto* service = get_service();
if (service == nullptr) {
elog("ssu_card[ssu_slot=${ssu_slot}]: finish_upgrade(), service not available, cannot reply FinishReply",
("ssu_slot", static_cast<int>(m_slot)));
return;
}
const auto* sig = msg.try_as<mc::engine::signal_payload>();
if (!sig || sig->args.size() < 4) {
dlog("ssu_card[ssu_slot=${ssu_slot}]: finish_upgrade(), invalid UpgradeFinishSignal args, size=${size}",
("ssu_slot", static_cast<int>(m_slot))("size", sig ? sig->args.size() : 0));
return;
}
mc::dict ctx = sig->args[0].as<mc::dict>();
int8_t system_id = sig->args[1].as<int8_t>();
std::string firmware_type = sig->args[2].as<std::string>();
mc::dict message_data = sig->args[3].as<mc::dict>();
int8_t upgrade_res = UPGRADE_REPLY_NOT_SUPPORT;
nlog("ssu_card[ssu_slot=${ssu_slot}]: finish_upgrade() signal received, system_id=${sys_id}, firmware_type=${type}",
("ssu_slot", static_cast<int>(m_slot))("sys_id", static_cast<int>(system_id))("type", firmware_type));
if (firmware_type == "SSUBios") {
upgrade_res = m_bios.finish_upgrade();
} else {
nlog("ssu_card[ssu_slot=${ssu_slot}]: finish_upgrade() ignored, non-SSUBios firmware_type=${type}",
("ssu_slot", static_cast<int>(m_slot))("type", firmware_type));
return;
}
ilog("ssu_card[ssu_slot=${ssu_slot}]: finish_upgrade(), system_id=${sys_id}, firmware_type=${type}, "
"upgrade_res=${res}",
("ssu_slot", static_cast<int>(m_slot))("sys_id", static_cast<int>(system_id))("type", firmware_type)(
"res", static_cast<int>(upgrade_res)));
try {
mc::variants update_finish_reply;
update_finish_reply.push_back(mc::dict{});
update_finish_reply.push_back(system_id);
update_finish_reply.push_back(firmware_type);
update_finish_reply.push_back(upgrade_res);
update_finish_reply.push_back(message_data);
service->call("/bmc/kepler/UpdateService", "bmc.kepler.firmware_mgmt", "bmc.kepler.UpdateService",
"FinishReply", update_finish_reply, "a{ss}isia{ss}", mc::milliseconds(5000));
} catch (const std::exception& e) {
elog("ssu_card[ssu_slot=${ssu_slot}]: finish_upgrade(), failed to send FinishReply, error=${ex}",
("ssu_slot", static_cast<int>(m_slot))("ex", e.what()));
} catch (...) {
elog("ssu_card[ssu_slot=${ssu_slot}]: finish_upgrade(), unknown exception sending FinishReply",
("ssu_slot", static_cast<int>(m_slot)));
}
}
void ssu_card::update_oob_management(uint8_t status)
{
nlog("ssu_card[ssu_slot=${ssu_slot}]: update_oob_management() called, status=${status}, prev_status=${prev}",
("ssu_slot", static_cast<int>(m_slot))("status",
static_cast<int>(status))("prev", static_cast<int>(m_bmc_role_status)));
if (m_bmc_role_status == status) {
evaluate_oob_management();
return;
}
m_bmc_role_status = status;
if (status == BMC_ROLE_ACTIVE) {
nlog("ssu_card[ssu_slot=${ssu_slot}]: BMC role is active (1), enabling OOB management if powered on",
("ssu_slot", static_cast<int>(m_slot)));
} else if (status == BMC_ROLE_STANDBY) {
nlog("ssu_card[ssu_slot=${ssu_slot}]: BMC role is standby (0), OOB management disabled",
("ssu_slot", static_cast<int>(m_slot)));
} else if (status == BMC_ROLE_INVALID) {
nlog("ssu_card[ssu_slot=${ssu_slot}]: BMC role Status is invalid (255), OOB management disabled",
("ssu_slot", static_cast<int>(m_slot)));
} else {
wlog("ssu_card[ssu_slot=${ssu_slot}]: unknown BMC role status ${status}, treat as invalid, OOB management "
"disabled",
("ssu_slot", static_cast<int>(m_slot))("status", static_cast<int>(status)));
}
evaluate_oob_management();
}
void ssu_card::query_bmc_role_once()
{
auto* service = get_service();
if (service == nullptr) {
elog("ssu_card[ssu_slot=${ssu_slot}]: service not available for BMC role query",
("ssu_slot", static_cast<int>(m_slot)));
return;
}
try {
mc::variant result =
service->call(BMC_GLOBAL_OBJECT_PATH, BMC_GLOBAL_SERVICE, "org.freedesktop.DBus.Properties", "Get",
mc::variants{std::string(BMC_GLOBAL_IFACE), std::string(BMC_GLOBAL_STATUS_PROP)}, "ss",
mc::milliseconds(5000));
if (result.is_numeric()) {
uint8_t status = result.as<uint8_t>();
ilog("ssu_card[ssu_slot=${ssu_slot}]: BMC role Status queried, status=${status}",
("ssu_slot", static_cast<int>(m_slot))("status", static_cast<int>(status)));
update_oob_management(status);
} else {
wlog("ssu_card[ssu_slot=${ssu_slot}]: BMC role Status query returned non-numeric result, keep current "
"state",
("ssu_slot", static_cast<int>(m_slot)));
}
} catch (const std::exception& e) {
elog("ssu_card[ssu_slot=${ssu_slot}]: BMC role Status query failed, error=${err}",
("ssu_slot", static_cast<int>(m_slot))("err", e.what()));
}
}
void ssu_card::stop_mctp_communication()
{
nlog("ssu_card[ssu_slot=${ssu_slot}]: stop_mctp_communication() entered, mctp_obj=${mctp}, ssu_oob_ready=${oob}",
("ssu_slot", static_cast<int>(m_slot))("mctp", m_mctp_obj != nullptr)("oob", m_ssu_oob != nullptr));
for (auto* port : m_ge_ports) {
if (port) {
port->stop_oob_update_task();
}
}
for (auto* port : m_ub_ports) {
if (port) {
port->unbind_oob();
}
}
m_boot_options.stop_boot_options_update_task();
m_bios.stop_firmware_version_update_task();
stop_temperature_update_task();
if (m_ssu_oob) {
ilog("ssu_card[ssu_slot=${ssu_slot}]: releasing ssu_oob", ("ssu_slot", static_cast<int>(m_slot)));
m_ssu_oob.reset();
}
if (m_mctp_obj) {
ilog("ssu_card[ssu_slot=${ssu_slot}]: destroying mctp transport, transport=${tp}",
("ssu_slot", static_cast<int>(m_slot))("tp", m_mctp_obj->get_transport_path()));
m_mctp_obj->destroy_transport_obj();
m_mctp_obj->set_parent(nullptr);
m_mctp_obj.reset();
ilog("ssu_card[ssu_slot=${ssu_slot}]: mctp transport destroyed", ("ssu_slot", static_cast<int>(m_slot)));
} else {
wlog("ssu_card[ssu_slot=${ssu_slot}]: stop_mctp_communication() called but mctp_obj is null",
("ssu_slot", static_cast<int>(m_slot)));
}
}
bool ssu_card::start_mctp_communication()
{
nlog("ssu_card[ssu_slot=${ssu_slot}]: start_mctp_communication() begin, phy_addr=${phy}, msg_type=${msg}",
("ssu_slot", static_cast<int>(m_slot))("phy", SSU_MCTP_TARGET_PHY_ADDR)(
"msg", static_cast<int>(MCTP_MESSAGE_TYPE::MCTP_MESSAGE_TYPE_NVME)));
m_mctp_obj = mc::make_shared<mctp>(this, SSU_MCTP_TARGET_PHY_ADDR, MCTP_MESSAGE_TYPE::MCTP_MESSAGE_TYPE_NVME,
std::string(get_position()));
if (!m_mctp_obj) {
elog("ssu_card[ssu_slot=${ssu_slot}]: failed to create mctp object", ("ssu_slot", static_cast<int>(m_slot)));
return false;
}
ilog("ssu_card[ssu_slot=${ssu_slot}]: mctp object created, transport_path=${tp}, endpoint_path=${ep}",
("ssu_slot",
static_cast<int>(m_slot))("tp", m_mctp_obj->get_transport_path())("ep", m_mctp_obj->get_endpoint_path()));
auto ep_created_callback = [this]() {
auto ex = executor();
auto run = [this]() {
nlog("ssu_card[ssu_slot=${ssu_slot}]: EP creation callback triggered (strand)",
("ssu_slot", static_cast<int>(m_slot)));
if (!m_mctp_obj) {
elog("ssu_card[ssu_slot=${ssu_slot}]: mctp_obj is null in callback",
("ssu_slot", static_cast<int>(m_slot)));
return;
}
if (!m_mctp_obj->is_create_endpoint_success()) {
elog("ssu_card[ssu_slot=${ssu_slot}]: endpoint creation failed after retries, tear down mctp, retry "
"on next evaluate",
("ssu_slot", static_cast<int>(m_slot)));
stop_mctp_communication();
return;
}
ilog("ssu_card[ssu_slot=${ssu_slot}]: endpoint ready, transport=${tp}, endpoint=${ep}",
("ssu_slot", static_cast<int>(m_slot))("tp", m_mctp_obj->get_transport_path())(
"ep", m_mctp_obj->get_endpoint_path()));
try {
m_ssu_oob = std::make_shared<ssu_oob>(m_mctp_obj, m_slot);
if (!m_ssu_oob) {
elog("ssu_card[ssu_slot=${ssu_slot}]: failed to create ssu_oob (null)",
("ssu_slot", static_cast<int>(m_slot)));
return;
}
ilog("ssu_card[ssu_slot=${ssu_slot}]: SSU OOB initialized successfully, endpoint=${ep}",
("ssu_slot", static_cast<int>(m_slot))("ep", m_mctp_obj->get_endpoint_path()));
set_ssu_location();
for (auto* port : m_ge_ports) {
if (port) {
port->start_oob_update_task(m_ssu_oob, m_slot);
}
}
for (auto* port : m_ub_ports) {
if (port) {
port->bind_oob(m_ssu_oob);
port->apply_configured_speed();
}
}
m_boot_options.start_boot_options_update_task(m_ssu_oob, m_slot);
m_bios.start_firmware_version_update_task(m_ssu_oob, m_ssu_card.Slot.get_value().as<uint8_t>());
start_temperature_update_task();
} catch (const std::exception& e) {
elog("ssu_card[ssu_slot=${ssu_slot}]: exception creating ssu_oob, error=${err}",
("ssu_slot", static_cast<int>(m_slot))("err", e.what()));
return;
}
};
if (ex.running_in_this_thread()) {
run();
} else {
this->post(std::move(run));
}
};
ilog("ssu_card[ssu_slot=${ssu_slot}]: calling create_transport_and_endpoint, module=${mod}",
("ssu_slot", static_cast<int>(m_slot))("mod", std::string(get_object_name())));
m_mctp_obj->create_transport_and_endpoint(std::string(get_object_name()), ep_created_callback);
ilog("ssu_card[ssu_slot=${ssu_slot}]: create_transport_and_endpoint dispatched, transport=${tp}",
("ssu_slot", static_cast<int>(m_slot))("tp", m_mctp_obj->get_transport_path()));
ilog("ssu_card[ssu_slot=${ssu_slot}]: start_mctp_communication() end, waiting for mctpd to create endpoint (poll "
"up to 60s)",
("ssu_slot", static_cast<int>(m_slot)));
return true;
}
}
MC_REFLECT(dev::ssu_card,
((m_system_id, "SystemId"))((m_ssu_card, "bmc.dev.Board"))((m_ssu, "bmc.dev.SSU"))(
(m_shared_mgmt, "bmc.dev.SharedManagement"))((m_chassis, "bmc.dev.Chassis"))((m_bios, "bmc.dev.Bios"))(
(m_boot_options, "bmc.dev.BootOptions"))((m_chip, "bmc.dev.Chip"))((m_temperature,
"bmc.dev.Temperature")))