| /* |
| * SPDX-FileCopyrightText: Copyright OpenBMC Authors |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| |
| #include "MctpMockTestBase.hpp" |
| #include "MessagePackUnpackUtils.hpp" |
| #include "MockMctpRequester.hpp" |
| #include "NvidiaGpuMctpVdm.hpp" |
| #include "NvidiaGpuMemoryDevice.hpp" |
| #include "OcpMctpVdm.hpp" |
| #include "TestUtils.hpp" |
| |
| #include <sdbusplus/exception.hpp> |
| |
| #include <cstdint> |
| #include <memory> |
| #include <span> |
| #include <string> |
| #include <system_error> |
| #include <vector> |
| |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| |
| namespace |
| { |
| |
| const std::string eccIface = "xyz.openbmc_project.Memory.MemoryECC"; |
| |
| // Build a successful GET_ECC_ERROR_COUNTS response: |
| // common response header + uint16 flags + 5 x uint32_t |
| std::vector<uint8_t> buildEccResponse(uint16_t flags, uint32_t sramCorr, |
| uint32_t sramSecded, uint32_t sramParity, |
| uint32_t dramCorr, uint32_t dramUncorr) |
| { |
| const uint16_t dataSize = sizeof(uint16_t) + (sizeof(uint32_t) * 5); |
| std::vector<uint8_t> buf( |
| ocp::accelerator_management::commonResponseSize + dataSize, 0); |
| 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_ECC_ERROR_COUNTS)); |
| pack.pack(static_cast<uint8_t>( |
| ocp::accelerator_management::CompletionCode::SUCCESS)); |
| pack.pack(static_cast<uint16_t>(0)); // reasonCode |
| pack.pack(dataSize); |
| pack.pack(flags); |
| pack.pack(sramCorr); |
| pack.pack(sramSecded); |
| pack.pack(sramParity); |
| pack.pack(dramCorr); |
| pack.pack(dramUncorr); |
| EXPECT_EQ(pack.getError(), 0); |
| return buf; |
| } |
| |
| std::vector<uint8_t> buildErrorResponse() |
| { |
| return test_utils::buildPlatformEnvErrorResponse( |
| gpu::PlatformEnvironmentalCommands::GET_ECC_ERROR_COUNTS, |
| static_cast<uint8_t>( |
| ocp::accelerator_management::CompletionCode::ERROR), |
| 0x1234); |
| } |
| |
| class NvidiaGpuMemoryDeviceTest : public MctpMockTestBase |
| { |
| protected: |
| static std::shared_ptr<NvidiaGpuMemoryDevice> createDevice( |
| const std::string& name = "GPU_MEM_DEV", |
| uint8_t eid = test_utils::defaultEid) |
| { |
| return std::make_shared<NvidiaGpuMemoryDevice>(bus(), requester(), name, |
| eid, objects()); |
| } |
| |
| static std::string gpuPath(const std::string& name) |
| { |
| return "/xyz/openbmc_project/inventory/" + name; |
| } |
| |
| static std::string dramPath(const std::string& name) |
| { |
| return "/xyz/openbmc_project/inventory/" + name + "_DRAM_0"; |
| } |
| }; |
| |
| TEST_F(NvidiaGpuMemoryDeviceTest, ConstructorDoesNotCrash) |
| { |
| auto dev = createDevice("memdev_ctor"); |
| ASSERT_NE(dev, nullptr); |
| } |
| |
| TEST_F(NvidiaGpuMemoryDeviceTest, UpdateSuccessSetsEccCounts) |
| { |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .WillOnce( |
| mock_mctp::respondWith({}, buildEccResponse(0, 5, 2, 4, 7, 9))); |
| |
| auto dev = createDevice("memdev_succ"); |
| dev->update(); |
| |
| // SRAM: ceCount = sramCorrected (5); ueCount = secded + parity (2 + 4) |
| EXPECT_EQ(getProperty<int64_t>(gpuPath("memdev_succ"), eccIface, "ceCount"), |
| 5); |
| EXPECT_EQ(getProperty<int64_t>(gpuPath("memdev_succ"), eccIface, "ueCount"), |
| 6); |
| |
| // DRAM: ceCount = dramCorrected (7); ueCount = dramUncorrected (9) |
| EXPECT_EQ( |
| getProperty<int64_t>(dramPath("memdev_succ"), eccIface, "ceCount"), 7); |
| EXPECT_EQ( |
| getProperty<int64_t>(dramPath("memdev_succ"), eccIface, "ueCount"), 9); |
| } |
| |
| TEST_F(NvidiaGpuMemoryDeviceTest, UpdateSendsRequest) |
| { |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .Times(testing::AtLeast(1)) |
| .WillRepeatedly(mock_mctp::respondWith({}, {})); |
| |
| auto dev = createDevice("memdev_sends"); |
| dev->update(); |
| } |
| |
| TEST_F(NvidiaGpuMemoryDeviceTest, UpdateRequestContainsCorrectEid) |
| { |
| constexpr uint8_t testEid = 42; |
| EXPECT_CALL(mctpMock, sendRecvMsg(testEid, testing::_, testing::_)) |
| .WillOnce(mock_mctp::respondWith({}, {})); |
| |
| auto dev = createDevice("memdev_eid", testEid); |
| dev->update(); |
| } |
| |
| TEST_F(NvidiaGpuMemoryDeviceTest, UpdateVerifiesRequestEncoding) |
| { |
| // Copy the request bytes before completing the call: the reqMsg span is |
| // a view into caller-owned memory, valid only during the call. |
| std::vector<uint8_t> lastRequest; |
| const std::vector<uint8_t> response; |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .WillOnce([&](uint8_t /*eid*/, std::span<const uint8_t> reqMsg, |
| auto callback) { |
| lastRequest.assign(reqMsg.begin(), reqMsg.end()); |
| callback(std::error_code{}, response); |
| }); |
| |
| auto dev = createDevice("memdev_enc"); |
| dev->update(); |
| |
| ASSERT_FALSE(lastRequest.empty()); |
| |
| UnpackBuffer unpack(lastRequest); |
| ocp::accelerator_management::MessageType ocpMsgType{}; |
| uint8_t instanceId = 0; |
| uint8_t msgType = 0; |
| EXPECT_EQ(ocp::accelerator_management::unpackHeader( |
| unpack, gpu::nvidiaPciVendorId, ocpMsgType, instanceId, |
| msgType), |
| 0); |
| |
| uint8_t command = 0; |
| unpack.unpack(command); |
| EXPECT_EQ(command, |
| static_cast<uint8_t>( |
| gpu::PlatformEnvironmentalCommands::GET_ECC_ERROR_COUNTS)); |
| EXPECT_EQ(unpack.getError(), 0); |
| } |
| |
| TEST_F(NvidiaGpuMemoryDeviceTest, UpdateMctpTransportErrorNoCrash) |
| { |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .WillOnce(mock_mctp::respondWith( |
| std::make_error_code(std::errc::timed_out), {})); |
| |
| auto dev = createDevice("memdev_mctp_err"); |
| EXPECT_NO_THROW(dev->update()); |
| } |
| |
| TEST_F(NvidiaGpuMemoryDeviceTest, UpdateDecodeErrorNoCrash) |
| { |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .WillOnce(mock_mctp::respondWith({}, buildErrorResponse())); |
| |
| auto dev = createDevice("memdev_dec_err"); |
| EXPECT_NO_THROW(dev->update()); |
| } |
| |
| TEST_F(NvidiaGpuMemoryDeviceTest, UpdateEmptyBufferNoCrash) |
| { |
| EXPECT_CALL(mctpMock, sendRecvMsg).WillOnce(mock_mctp::respondWith({}, {})); |
| |
| auto dev = createDevice("memdev_empty"); |
| EXPECT_NO_THROW(dev->update()); |
| } |
| |
| TEST_F(NvidiaGpuMemoryDeviceTest, UpdateTinyBufferNoCrash) |
| { |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .WillOnce(mock_mctp::respondWith({}, {0x00, 0x01})); |
| |
| auto dev = createDevice("memdev_tiny"); |
| EXPECT_NO_THROW(dev->update()); |
| } |
| |
| TEST_F(NvidiaGpuMemoryDeviceTest, UpdateSuccessThenErrorKeepsPreviousValue) |
| { |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .WillOnce( |
| mock_mctp::respondWith({}, buildEccResponse(0, 5, 2, 4, 7, 9))) |
| .WillOnce(mock_mctp::respondWith({}, buildErrorResponse())); |
| |
| auto dev = createDevice("memdev_keep"); |
| |
| dev->update(); |
| EXPECT_EQ(getProperty<int64_t>(gpuPath("memdev_keep"), eccIface, "ceCount"), |
| 5); |
| EXPECT_EQ( |
| getProperty<int64_t>(dramPath("memdev_keep"), eccIface, "ueCount"), 9); |
| |
| // A subsequent error response must not overwrite the last good counts on |
| // either the GPU or the DRAM interface. |
| dev->update(); |
| EXPECT_EQ(getProperty<int64_t>(gpuPath("memdev_keep"), eccIface, "ceCount"), |
| 5); |
| EXPECT_EQ(getProperty<int64_t>(gpuPath("memdev_keep"), eccIface, "ueCount"), |
| 6); |
| EXPECT_EQ( |
| getProperty<int64_t>(dramPath("memdev_keep"), eccIface, "ceCount"), 7); |
| EXPECT_EQ( |
| getProperty<int64_t>(dramPath("memdev_keep"), eccIface, "ueCount"), 9); |
| } |
| |
| TEST_F(NvidiaGpuMemoryDeviceTest, DestructorRemovesInterfaces) |
| { |
| const std::string name = "memdev_dtor"; |
| { |
| auto dev = createDevice(name); |
| ASSERT_NE(dev, nullptr); |
| EXPECT_NO_THROW( |
| getProperty<int64_t>(gpuPath(name), eccIface, "ceCount")); |
| EXPECT_NO_THROW( |
| getProperty<int64_t>(dramPath(name), eccIface, "ceCount")); |
| } |
| drainPendingAsync(); |
| EXPECT_THROW(getProperty<int64_t>(gpuPath(name), eccIface, "ceCount"), |
| sdbusplus::exception_t); |
| EXPECT_THROW(getProperty<int64_t>(dramPath(name), eccIface, "ceCount"), |
| sdbusplus::exception_t); |
| } |
| |
| } // namespace |
