| /* |
| * SPDX-FileCopyrightText: Copyright OpenBMC Authors |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| |
| #include "MctpMockTestBase.hpp" |
| #include "MockMctpRequester.hpp" |
| #include "NvidiaGpuMctpVdm.hpp" |
| #include "NvidiaSmaLeakSensor.hpp" |
| #include "OcpMctpVdm.hpp" |
| #include "TestUtils.hpp" |
| #include "Thresholds.hpp" |
| |
| #include <MessagePackUnpackUtils.hpp> |
| |
| #include <cmath> |
| #include <cstdint> |
| #include <memory> |
| #include <string> |
| #include <system_error> |
| #include <utility> |
| #include <vector> |
| |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| |
| namespace |
| { |
| |
| std::vector<uint8_t> buildLeakDetectionInfoResponse(uint16_t adcReadingMv) |
| { |
| // dataSize = numSensors(1) + numThresholdLevels(1) + |
| // numSensors * (sensorId(1) + leakState(1) + |
| // thresholds(2*numThresholdLevels) + adcReadingMv(2)) |
| // We mock 1 sensor with 0 thresholds |
| uint16_t dataSize = 1 + 1 + 1 * (1 + 1 + 0 + 2); |
| |
| std::vector<uint8_t> buf( |
| ocp::accelerator_management::commonResponseSize + dataSize); |
| PackBuffer pack(buf); |
| ocp::accelerator_management::packHeader( |
| pack, gpu::nvidiaPciVendorId, |
| ocp::accelerator_management::MessageType::RESPONSE, 0, |
| static_cast<uint8_t>(gpu::MessageType::PLATFORM_ENVIRONMENTAL)); |
| pack.pack(static_cast<uint8_t>( |
| gpu::PlatformEnvironmentalCommands::GET_LEAK_DETECTION_INFO)); |
| pack.pack(static_cast<uint8_t>( |
| ocp::accelerator_management::CompletionCode::SUCCESS)); |
| pack.pack(static_cast<uint16_t>(0)); // reserved |
| pack.pack(dataSize); |
| |
| // payload |
| pack.pack(static_cast<uint8_t>(1)); // numSensors |
| pack.pack(static_cast<uint8_t>(0)); // numThresholdLevels |
| |
| // sensor 1 |
| pack.pack(static_cast<uint8_t>(0)); // sensorId |
| pack.pack(static_cast<uint8_t>(0)); // leakState |
| pack.pack(adcReadingMv); // adcReadingMv |
| |
| return buf; |
| } |
| |
| std::vector<uint8_t> buildLeakDetectionInfoEmptyResponse() |
| { |
| // dataSize = numSensors(1) + numThresholdLevels(1) |
| // We mock 0 sensors |
| uint16_t dataSize = 1 + 1; |
| |
| std::vector<uint8_t> buf( |
| ocp::accelerator_management::commonResponseSize + dataSize); |
| PackBuffer pack(buf); |
| ocp::accelerator_management::packHeader( |
| pack, gpu::nvidiaPciVendorId, |
| ocp::accelerator_management::MessageType::RESPONSE, 0, |
| static_cast<uint8_t>(gpu::MessageType::PLATFORM_ENVIRONMENTAL)); |
| pack.pack(static_cast<uint8_t>( |
| gpu::PlatformEnvironmentalCommands::GET_LEAK_DETECTION_INFO)); |
| pack.pack(static_cast<uint8_t>( |
| ocp::accelerator_management::CompletionCode::SUCCESS)); |
| pack.pack(static_cast<uint16_t>(0)); // reserved |
| pack.pack(dataSize); |
| |
| // payload |
| pack.pack(static_cast<uint8_t>(0)); // numSensors |
| pack.pack(static_cast<uint8_t>(0)); // numThresholdLevels |
| |
| return buf; |
| } |
| |
| std::vector<uint8_t> buildLeakErrorResponse(uint8_t cc, uint16_t reasonCode) |
| { |
| return test_utils::buildPlatformEnvErrorResponse( |
| gpu::PlatformEnvironmentalCommands::GET_LEAK_DETECTION_INFO, cc, |
| reasonCode); |
| } |
| |
| class NvidiaSmaLeakSensorTest : public MctpMockTestBase |
| { |
| protected: |
| static std::shared_ptr<NvidiaSmaLeakSensor> createSensor( |
| const std::string& name = "GPU_LEAK_0", |
| std::vector<thresholds::Threshold> thresholds = {}, |
| gpu::DeviceIdentification deviceType = |
| gpu::DeviceIdentification::DEVICE_GPU, |
| uint8_t eid = test_utils::defaultEid, uint8_t sensorId = 0) |
| { |
| return std::make_shared<NvidiaSmaLeakSensor>( |
| bus(), requester(), name, "/test/config", eid, sensorId, objects(), |
| std::move(thresholds), deviceType); |
| } |
| |
| static std::string leakPath(const std::string& name) |
| { |
| // sensor path prefix in NvidiaSmaLeakSensor.cpp is |
| // "/xyz/openbmc_project/sensors/" and it appends "voltage/" + |
| // escapeName(name) |
| return "/xyz/openbmc_project/sensors/voltage/" + name; |
| } |
| }; |
| |
| // Constructor — D-Bus interface creation |
| |
| TEST_F(NvidiaSmaLeakSensorTest, ConstructorCreatesDbusInterfaces) |
| { |
| const std::string name = "leak_ctor_iface"; |
| const std::shared_ptr<NvidiaSmaLeakSensor> sensor = createSensor(name); |
| const std::string path = leakPath(name); |
| |
| EXPECT_TRUE(std::isnan(getProperty<double>( |
| path, "xyz.openbmc_project.Sensor.Value", "Value"))); |
| EXPECT_EQ(getProperty<double>(path, "xyz.openbmc_project.Sensor.Value", |
| "MaxValue"), |
| 5.0); |
| EXPECT_EQ(getProperty<double>(path, "xyz.openbmc_project.Sensor.Value", |
| "MinValue"), |
| 0.0); |
| EXPECT_EQ(getProperty<std::string>(path, "xyz.openbmc_project.Sensor.Value", |
| "Unit"), |
| "xyz.openbmc_project.Sensor.Value.Unit.Volts"); |
| } |
| |
| // Constructor — threshold interfaces |
| |
| TEST_F(NvidiaSmaLeakSensorTest, ConstructorWithWarningThreshold) |
| { |
| const std::string name = "warn_thr"; |
| const std::shared_ptr<NvidiaSmaLeakSensor> sensor = createSensor( |
| name, {thresholds::Threshold{thresholds::Level::WARNING, |
| thresholds::Direction::HIGH, 1.7}}); |
| const std::string path = leakPath(name); |
| |
| EXPECT_EQ(getProperty<double>( |
| path, "xyz.openbmc_project.Sensor.Threshold.Warning", |
| "WarningHigh"), |
| 1.7); |
| } |
| |
| TEST_F(NvidiaSmaLeakSensorTest, ConstructorWithCriticalThreshold) |
| { |
| const std::string name = "crit_thr"; |
| const std::shared_ptr<NvidiaSmaLeakSensor> sensor = createSensor( |
| name, {thresholds::Threshold{thresholds::Level::CRITICAL, |
| thresholds::Direction::HIGH, 1.8}}); |
| const std::string path = leakPath(name); |
| |
| EXPECT_EQ(getProperty<double>( |
| path, "xyz.openbmc_project.Sensor.Threshold.Critical", |
| "CriticalHigh"), |
| 1.8); |
| } |
| |
| TEST_F(NvidiaSmaLeakSensorTest, ConstructorWithMultipleThresholds) |
| { |
| const std::string name = "multi_thr"; |
| const std::shared_ptr<NvidiaSmaLeakSensor> sensor = createSensor( |
| name, {thresholds::Threshold{thresholds::Level::WARNING, |
| thresholds::Direction::HIGH, 1.7}, |
| thresholds::Threshold{thresholds::Level::CRITICAL, |
| thresholds::Direction::HIGH, 1.8}}); |
| const std::string path = leakPath(name); |
| |
| EXPECT_EQ(getProperty<double>( |
| path, "xyz.openbmc_project.Sensor.Threshold.Warning", |
| "WarningHigh"), |
| 1.7); |
| EXPECT_EQ(getProperty<double>( |
| path, "xyz.openbmc_project.Sensor.Threshold.Critical", |
| "CriticalHigh"), |
| 1.8); |
| } |
| |
| // Sensor Update — successful readings |
| |
| TEST_F(NvidiaSmaLeakSensorTest, UpdateSuccessValidReading) |
| { |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .WillOnce( |
| mock_mctp::respondWith({}, buildLeakDetectionInfoResponse(1500))); |
| |
| const std::shared_ptr<NvidiaSmaLeakSensor> sensor = |
| createSensor("leak_valid_0"); |
| sensor->update(); |
| |
| EXPECT_DOUBLE_EQ( |
| getProperty<double>(leakPath("leak_valid_0"), |
| "xyz.openbmc_project.Sensor.Value", "Value"), |
| 1.5); |
| } |
| |
| TEST_F(NvidiaSmaLeakSensorTest, UpdateSuccessZeroReading) |
| { |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .WillOnce( |
| mock_mctp::respondWith({}, buildLeakDetectionInfoResponse(0))); |
| |
| const std::shared_ptr<NvidiaSmaLeakSensor> sensor = |
| createSensor("leak_zero_0"); |
| sensor->update(); |
| |
| EXPECT_DOUBLE_EQ( |
| getProperty<double>(leakPath("leak_zero_0"), |
| "xyz.openbmc_project.Sensor.Value", "Value"), |
| 0.0); |
| } |
| |
| TEST_F(NvidiaSmaLeakSensorTest, UpdateSuccessEmptySensors) |
| { |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .WillOnce( |
| mock_mctp::respondWith({}, buildLeakDetectionInfoEmptyResponse())); |
| |
| const std::shared_ptr<NvidiaSmaLeakSensor> sensor = |
| createSensor("leak_empty_0"); |
| sensor->update(); |
| |
| // With empty response, the sensor retains its initial NaN value |
| EXPECT_TRUE(std::isnan( |
| getProperty<double>(leakPath("leak_empty_0"), |
| "xyz.openbmc_project.Sensor.Value", "Value"))); |
| } |
| |
| // Sensor Update — threshold crossed reading |
| |
| TEST_F(NvidiaSmaLeakSensorTest, UpdateWarningThresholdCrossed) |
| { |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .WillOnce( |
| mock_mctp::respondWith({}, buildLeakDetectionInfoResponse(1000))); |
| |
| const std::string name = "warn_thr_cros_0"; |
| const std::shared_ptr<NvidiaSmaLeakSensor> sensor = createSensor( |
| name, {thresholds::Threshold{thresholds::Level::WARNING, |
| thresholds::Direction::LOW, 1.5}}); |
| sensor->update(); |
| |
| EXPECT_DOUBLE_EQ( |
| getProperty<double>(leakPath(name), "xyz.openbmc_project.Sensor.Value", |
| "Value"), |
| 1.0); |
| |
| // Verify the dbus alarm property was asserted |
| EXPECT_TRUE(getProperty<bool>( |
| leakPath(name), "xyz.openbmc_project.Sensor.Threshold.Warning", |
| "WarningAlarmLow")); |
| } |
| |
| TEST_F(NvidiaSmaLeakSensorTest, UpdateCriticalThresholdCrossed) |
| { |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .WillOnce( |
| mock_mctp::respondWith({}, buildLeakDetectionInfoResponse(1000))); |
| |
| const std::string name = "crit_thr_cros_0"; |
| const std::shared_ptr<NvidiaSmaLeakSensor> sensor = createSensor( |
| name, {thresholds::Threshold{thresholds::Level::CRITICAL, |
| thresholds::Direction::LOW, 1.2}}); |
| sensor->update(); |
| |
| EXPECT_DOUBLE_EQ( |
| getProperty<double>(leakPath(name), "xyz.openbmc_project.Sensor.Value", |
| "Value"), |
| 1.0); |
| |
| // Verify the dbus alarm property was asserted |
| EXPECT_TRUE(getProperty<bool>( |
| leakPath(name), "xyz.openbmc_project.Sensor.Threshold.Critical", |
| "CriticalAlarmLow")); |
| } |
| |
| TEST_F(NvidiaSmaLeakSensorTest, UpdateMultipleThresholdsCrossed) |
| { |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .WillOnce( |
| mock_mctp::respondWith({}, buildLeakDetectionInfoResponse(1000))); |
| |
| const std::string name = "mult_thr_cros_0"; |
| const std::shared_ptr<NvidiaSmaLeakSensor> sensor = createSensor( |
| name, {thresholds::Threshold{thresholds::Level::WARNING, |
| thresholds::Direction::LOW, 1.5}, |
| thresholds::Threshold{thresholds::Level::CRITICAL, |
| thresholds::Direction::LOW, 1.2}}); |
| sensor->update(); |
| |
| EXPECT_DOUBLE_EQ( |
| getProperty<double>(leakPath(name), "xyz.openbmc_project.Sensor.Value", |
| "Value"), |
| 1.0); |
| |
| // Verify the dbus alarm property was asserted |
| EXPECT_TRUE(getProperty<bool>( |
| leakPath(name), "xyz.openbmc_project.Sensor.Threshold.Critical", |
| "CriticalAlarmLow")); |
| EXPECT_TRUE(getProperty<bool>( |
| leakPath(name), "xyz.openbmc_project.Sensor.Threshold.Warning", |
| "WarningAlarmLow")); |
| } |
| |
| // Sensor Update — error handling |
| |
| TEST_F(NvidiaSmaLeakSensorTest, UpdateMctpTransportError) |
| { |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .WillOnce(mock_mctp::respondWith( |
| std::make_error_code(std::errc::timed_out), {})); |
| |
| const std::shared_ptr<NvidiaSmaLeakSensor> sensor = |
| createSensor("leak_mctp_err_0"); |
| sensor->update(); |
| |
| EXPECT_TRUE(std::isnan( |
| getProperty<double>(leakPath("leak_mctp_err_0"), |
| "xyz.openbmc_project.Sensor.Value", "Value"))); |
| } |
| |
| TEST_F(NvidiaSmaLeakSensorTest, UpdateBadCompletionCodeError) |
| { |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .WillOnce(mock_mctp::respondWith( |
| {}, buildLeakErrorResponse( |
| static_cast<uint8_t>( |
| ocp::accelerator_management::CompletionCode::ERROR), |
| 0))); |
| |
| const std::shared_ptr<NvidiaSmaLeakSensor> sensor = |
| createSensor("leak_bad_cc_0"); |
| sensor->update(); |
| |
| EXPECT_TRUE(std::isnan( |
| getProperty<double>(leakPath("leak_bad_cc_0"), |
| "xyz.openbmc_project.Sensor.Value", "Value"))); |
| } |
| |
| // Destructor |
| |
| TEST_F(NvidiaSmaLeakSensorTest, DestructorDoesNotCrash) |
| { |
| std::shared_ptr<NvidiaSmaLeakSensor> sensor = createSensor("leak_dtor"); |
| ASSERT_NE(sensor, nullptr); |
| ASSERT_NE(sensor->sensorInterface, nullptr); |
| sensor.reset(); |
| } |
| |
| } // namespace |
