/*
 * 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 {
// 温度原始值为64位,仅低3字节有效;按24位有符号数解析(支持负温度),转换为摄氏度数值
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);
}
} // namespace

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;
    }
    // 缓存槽位号作为全部日志的标识:SR 为按 Slot 展开的多实例模板(对象名固定 SSUCard_1),
    // 多 SSU 场景仅靠对象名/前缀无法区分日志归属
    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)));

    // 串行化本对象及全部子孙对象的回调线程:
    // devmon 的 I/O 池是多线程并发池,本对象状态
    // (m_mctp_obj / m_ssu_oob / m_bmc_role_status / m_ge_ports)会被多个线程并发访问:
    //   * mdb 属性 Set 派发(dispatcher 派发到对象 executor,I/O 池)
    //   * PowerState property_changed(Direct 连接,随 set_value 在派发线程同步执行)
    //   * mctp 重试 timer / ep_created_callback(mctp 对象 executor,I/O 池)
    //   * GE 轮询 timer(以 ge_port 驱动对象为 parent,经 parent 链解析到本组 strand)
    // 无同步时可能双重 start(mctp 对象泄漏)或 start/stop 交错(空指针/UAF coredump)。
    // 建组并绑定可让出的 I/O strand:executor 解析规则下组会传播给全部子孙对象
    // (bind_executor 只影响自身,不传播)。普通回调仍串行执行;mc::future/result 同步等待期间
    // 会临时让出串行权,避免 timer/RPC 完成任务被本对象自身堵住。
    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();
    // 监听PowerState属性变更(参考fan_object.cpp中ModelSource.property_changed()模式)
    // 注:CPLD硬件暂无电源采集能力,SR中PowerState暂写死为0;调试验证时通过mdbctl设置
    //     该属性模拟上电(1)/下电(0),触发带外任务的启动/停止。
    m_ssu.PowerState.property_changed().connect([this](const mc::variant& value, const auto& prop) {
        // 上电(1):评估启动MCTP/带外任务,EP创建完成后由回调内兜底set_ssu_location上送位置;
        // 下电(0):评估停止并销毁m_mctp_obj/m_ssu_oob。位置信息无需在此直接补发:
        // EP创建为异步链(最长60s),此刻m_ssu_oob必然未就绪,直接调用只会空跑。
        evaluate_oob_management();
    });

    // 监听机框SN变更:变化时上送槽位号和框SN(oob未就绪由ep_created兜底补齐)
    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();
    });

    // 主从判断:ControlOwner=1表示当前机型有主从,需监听BMC主从状态(Status)决定是否带外管理;
    // ControlOwner=0表示无主从,直接进行带外管理(不依赖Status)。
    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)));
    }

    // 监听注册后立即评估一次当前状态:
    // PowerState 为本地属性,evaluate_oob_management() 内部通过 get_value() 读取当前值,
    // 等价于"监听后主动获取一次",防止注册监听前 PowerState 已是 ON(1) 时,
    // 后续 property_changed 不再触发而丢失上电事件(Status 的对应兜底见 query_bmc_role_once())。
    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();

    // 移除BMC主从状态监听,避免stop后仍收到Status变更回调
    if (m_bmc_role_match_id != 0) {
        if (service != nullptr) {
            service->remove_match(m_bmc_role_match_id);
        }
        m_bmc_role_match_id = 0;
    }

    // 移除升级生命周期信号监听,避免stop后仍收到升级回调
    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;
    }

    // 注销固件信息,避免stop后FirmwareInventory仍残留本卡记录
    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);

            // Delete 方法签名 a{ss}s
            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)));
    }
    // 将teardown串行到strand执行:devmon经驱动ABI在宿主线程同步调用stop()(见scanner_abi.cpp),
    // 而GE轮询/mctp重试回调运行在strand上;若直接在本线程释放m_mctp_obj/m_ssu_oob,
    // 会与strand上并发的回调竞态(如get_ge_mac持mctp引用悬空 → coredump)。
    // this->post FIFO保证先入队的回调先执行完,teardown与全部回调串行;
    // future.get()同步等待,确保stop()返回时对象已彻底停止(满足框架两阶段卸载契约)。
    auto ex = executor();
    if (ex.running_in_this_thread()) {
        // 防御:若框架未来改为在strand上调用stop(),直接执行避免自我等待死锁
        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) {
            // 子对象是驱动类ge_port(object<ge_port>),非接口类GEPort(interface<GEPort>),
            // 二者无继承关系,必须转ge_port*(参考cx6_card.cpp中dynamic_cast<cx6_port*>惯例)
            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) {
            // 子对象是驱动类ub_port(object<ub_port>),非接口类UBPort(interface<UBPort>),
            // 二者无继承关系,必须转ub_port*
            auto* port = dynamic_cast<ub_port*>(child.get());
            if (port) {
                m_ub_ports.push_back(port);
                // 初始化阶段下发槽位号(仅日志标识,与OOB绑定解耦)
                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()
{
    // 前提约束:SR 中 SSUDrive 子对象为静态 2 块,与父对象同生命周期;
    // m_drives 仅在 start() 时收集一次,保存的是非拥有裸指针,之后不再刷新。
    // 因此不支持运行期动态增删 SSUDrive 子对象(若将来支持盘动态上下线,
    // 需改为按名查找或弱引用,避免子对象注销后 m_drives 悬垂)。
    auto children = get_children();
    for (auto& child : children) {
        auto name = child->get_name();
        if (name.find("SSUDrive") == 0) {
            // 子对象是驱动类ssu_drive(object<ssu_drive>),非接口类NVMe,
            // 二者无继承关系,必须转ssu_drive*
            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;
    }

    // 幂等兜底:重复start(主从/电源状态抖动、EP回调重复触发)时先停旧任务,
    // 避免旧timer不摘父引用泄漏且持续回调访问过期OOB
    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)); // 2秒轮询

    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)) {
        // 采集失败:SSUCard与全部硬盘温度状态置为无效(1);值未变化时跳过写库
        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);
            }
        }
        // 日志策略:仅在"采集成功→失败"翻转时打一条 error,持续失败降 dlog,避免周期刷屏
        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;
    }

    // 条目映射("条目索引→物理测温点"需与SSU/IMU侧协议对齐确认,见设计文档"温度数据条目映射"):
    // 索引0 -> SSUCard模组温度;索引3 -> 模组内所有SSUDrive共用的测温点(写入每个盘)。
    // 采集成功:第1个条目(索引0)低3字节 -> SSUCard温度
    if (temperatures.size() > SSU_TEMPERATURE_INDEX_CARD) {
        double card_celsius = ssu_extract_temperature(temperatures[SSU_TEMPERATURE_INDEX_CARD]);
        // 值/状态未变化时跳过写库,避免每2s重复 set_value 产生无谓的 PropertiesChanged/D-Bus 流量
        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);
        }
    }
    // 采集成功:第4个条目(索引3)低3字节 -> 每个硬盘温度
    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);
            }
        }
    }
    // 日志策略:仅在"采集失败→成功"翻转时打一条 notice,例行成功不打印,避免周期刷屏
    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();
        // timer 构造时以本驱动对象为 parent 挂入其 children(shared_ptr),
        // 仅 reset 成员不会析构旧 timer,反复上/下电会随父对象累积泄漏;
        // 此处显式摘除父引用后再释放,确保旧 timer 即刻析构。
        m_temperature_update_timer->set_parent(nullptr);
        m_temperature_update_timer.reset();
    }
    // 下电/停止后数据不再可信:温度状态置无效(值保留),避免北向/散热读到残留温度继续参与调速。
    // sr 初值 TemperatureStatus=1(Invalid) 即"无数据即无效";此前仅采集失败路径会置 Invalid,
    // 下电路径需保持一致。EP 创建失败也会走到这里,此时尚未采集过,复位等于初值,幂等无害。
    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";

        // Add 方法签名 a{ss}a{ss}bqi: FirmwareInfoTable(a{ss}) Updateable(b) Capability(q) MaxPackageSizeMiB(i)
        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;
    }

    // 有主从(ControlOwner=1)时,仅主BMC(Status=1)才进行带外管理;
    // 无主从(ControlOwner=0)时,不受主从状态约束,直接进行带外管理。
    if (m_shared_mgmt.ControlOwner.get_value().as<uint8_t>() == SSU_CONTROL_OWNER_YES) {
        return m_bmc_role_status == BMC_ROLE_ACTIVE;
    }
    return true;
}

// 幂等:无论PowerState/Status回调触发多少次,带外管理只会启动/停止一次,
// 重复触发不产生副作用(已启动不再重复启动,已停止再停止效果不变)。
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;
    }

    // 参考hi182x_card.cpp中VDPCI LLDP监听模式,订阅PropertiesChanged信号
    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) {
        // 经本对象 executor(串行 strand)投递:不能用 mc::post——它投递到全局 IO 线程池,
        // 会与 strand 上的 property_changed / timer 回调跨线程并发访问 m_bmc_role_status /
        // m_mctp_obj / m_ssu_oob(data race)。
        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"));

    // 监听建立后主动获取一次当前Status,防止监听前属性已变更(如已是active)导致
    // 后续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;
        }
        // PropertiesChanged 信号 args: [接口名, 变更属性字典 a{sv}, 失效属性列表 as]
        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; // 本次变更不涉及Status属性
        }
        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;
    }

    // 注册升级生命周期信号的监听,业务处理见 prepare/process/finish_upgrade()。
    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) {
            // 经本对象 executor(串行 strand)投递:不能用 mc::post——它投递到全局 IO 线程池,
            // 会与 strand 上的 property_changed / timer 回调跨线程并发访问 m_bmc_role_status /
            // m_mctp_obj / m_ssu_oob(data race)。
            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)));
    // 仅当Status实际变化时才打notice日志,重复收到相同值只做幂等评估,避免刷屏
    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));
    //    先停止所有GEPort的周期轮询任务(避免timer回调访问已释放的OOB对象)。
    //    依赖框架两阶段卸载契约:父对象 stop() 先于子对象析构(析构自叶向根),
    //    此处子驱动对象必然存活;ge_port::stop() 亦自清理兜底(幂等)。
    for (auto* port : m_ge_ports) {
        if (port) {
            port->stop_oob_update_task();
        }
    }

    // 释放所有UBPort持有的OOB引用(避免RPC回调访问已释放的OOB/mctp)
    for (auto* port : m_ub_ports) {
        if (port) {
            port->unbind_oob();
        }
    }

    // 停止BIOS启动配置周期轮询任务(timer回调同样引用m_ssu_oob)
    m_boot_options.stop_boot_options_update_task();

    // 停止BIOS固件版本轮询任务(timer回调同样引用m_ssu_oob)
    m_bios.stop_firmware_version_update_task();

    // 停止温度轮询任务(timer回调同样引用m_ssu_oob)
    stop_temperature_update_task();

    // 释放OOB对象(此时已无timer引用)
    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();
    }

    // 销毁MCTP transport(确保不会有新的MCTP请求)
    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();
        // mctp 构造时以本对象为 parent 挂入 children(shared_ptr),仅 reset 成员不会析构,
        // 反复上/下电会随父对象累积 mctp 及其重试 timer 链(每轮最多60个timer);
        // 显式摘除父引用后再释放,确保 mctp 即刻析构(析构置 m_alive=false,未决重试回调一并清理)。
        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]() {
        // EP创建/轮询完成回调运行在mctp调用线程(非本对象strand)。直接执行会与strand上
        // 的stop()/evaluate_oob_management()并发访问m_mctp_obj/m_ssu_oob/m_ge_ports,
        // 晚到回调(EP轮询最长60s)在teardown后触发时GEPort已脱离对象树,
        // start_oob_update_task内PortId.get_value()→property::get_object()取父对象会
        // 空指针coredump(UAF)。统一经本对象executor串行到strand处理,与teardown串行。
        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;
            }

            // 仅当endpoint创建成功才启动带外轮询:mctp重试60次失败后也会回调,
            // 此时endpoint未创建,若仍启动GE轮询,每次mctp.request都会因
            // "endpoint not created"直接失败,导致elog每5s×8口刷屏且空转无效轮询。
            // 失败时直接清理本次mctp(停止transport、摘除父引用),
            // 后续evaluate_oob_management()再次触发时会重新走start_mctp_communication()重试。
            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 {
                // 传入 mctp 的 shared_ptr(ssu_oob 内部保活):EP 回调经 executor 串行到 strand,
                // 但在途命令可能正通过 cooperative_wait_scope 让出串行权,stop_mctp_communication
                // 得以并发执行并 reset 本处引用;ssu_oob 持 shared_ptr 可防 mctp 被立即析构(UAF)
                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()));

                // 上送本卡槽位号和框SN到SSU固件(m_ssu_oob已就绪,按当前值下发,兜底)
                set_ssu_location();
                // 依次给每个GEPort子对象起带外更新任务(strand串行,与stop()的teardown互斥)
                for (auto* port : m_ge_ports) {
                    if (port) {
                        port->start_oob_update_task(m_ssu_oob, m_slot);
                    }
                }
                // 给每个UBPort子对象绑定OOB(供RPC SetSpeedGbps下发速率),并按设备树
                // ConfiguredSpeedGbps属性补发速率:SSU掉电期间storage写入属性但RPC未实际
                // 下发,MCTP就绪后无条件重新下发(哨兵值65535视为未配置跳过)
                for (auto* port : m_ub_ports) {
                    if (port) {
                        port->bind_oob(m_ssu_oob);
                        port->apply_configured_speed();
                    }
                }

                // 启动BIOS启动配置带外周期轮询任务
                m_boot_options.start_boot_options_update_task(m_ssu_oob, m_slot);

                // 启动BIOS固件版本带外周期轮询任务(1min)
                m_bios.start_firmware_version_update_task(m_ssu_oob, m_ssu_card.Slot.get_value().as<uint8_t>());

                // 启动温度带外周期轮询任务(2s,更新SSUCard与各硬盘温度)
                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;
}

} // namespace dev

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")))