| #ifndef THIRD_PARTY_GBMCWEB_INCLUDE_GOOGLE_GOOGLE_SERVICE_NVME_H_ |
| #define THIRD_PARTY_GBMCWEB_INCLUDE_GOOGLE_GOOGLE_SERVICE_NVME_H_ |
| |
| #include <systemd/sd-bus.h> |
| |
| #include <array> |
| #include <cstddef> |
| #include <cstdint> |
| #include <filesystem> // NOLINT |
| #include <functional> |
| #include <memory> |
| #include <optional> |
| #include <span> // NOLINT |
| #include <string> |
| #include <string_view> |
| #include <tuple> |
| #include <utility> |
| #include <vector> |
| |
| #include "absl/functional/any_invocable.h" |
| #include "bmcweb_config.h" |
| #include "app.hpp" |
| #include "http_request.hpp" |
| #include "logging.hpp" |
| #include "utility.hpp" |
| #include "async_resp.hpp" |
| #include "dbus_utility.hpp" |
| #include "error_messages.hpp" |
| #include "query.hpp" |
| #include "dbus_utils.hpp" |
| #include "json_utils.hpp" |
| #include "storage_utils.hpp" |
| #include <nlohmann/json.hpp> |
| #include "managed_store.hpp" |
| #include "managed_store_types.hpp" |
| #include "sdbusplus/message.hpp" |
| #include "sdbusplus/message/native_types.hpp" |
| |
| namespace crow { |
| namespace google_api { |
| |
| using NVMeControllerHandlerCb = std::function<void( |
| const boost::system::error_code ec, const std::string& storagePath, |
| const std::vector<std::string>& controllerList)>; |
| |
| using boost::asio::posix::stream_descriptor; |
| |
| static std::shared_ptr<boost::asio::io_context> fdIOContext; // NOLINT |
| |
| static void fetchFile( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::shared_ptr<stream_descriptor>& fileConn, |
| const std::shared_ptr<std::array<char, 1024>>& readBuffer = |
| std::make_shared<std::array<char, 1024>>(), |
| const std::shared_ptr<std::string>& output = |
| std::make_shared<std::string>()) { |
| if (!fileConn) { |
| BMCWEB_LOG_ERROR << "Fetch File Context is not setup properly"; |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| fileConn->async_read_some( |
| boost::asio::buffer(*readBuffer), |
| [asyncResp, fileConn, readBuffer, output]( |
| const boost::system::error_code& ec, |
| const std::size_t& bytesTransferred) { |
| if (ec == boost::asio::error::eof) { |
| asyncResp->res.stringResponse->clear(); |
| asyncResp->res.addHeader(boost::beast::http::field::content_type, |
| "application/octet-stream"); |
| asyncResp->res.body() = std::move(*output); |
| fileConn->close(); |
| return; |
| } |
| if (ec) { |
| BMCWEB_LOG_ERROR << "Failed to async_read_some" << ec.message(); |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| *output += std::string(readBuffer->begin(), |
| readBuffer->begin() + bytesTransferred); |
| fetchFile(asyncResp, fileConn, readBuffer, output); |
| }); |
| } |
| |
| inline void populateCustomNVMeControllerLink( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& systemName, const std::string& storageId, |
| const sdbusplus::message::object_path& controllerPath) { |
| constexpr std::array<std::string_view, 1> interfaces = { |
| "xyz.openbmc_project.Inventory.Item.StorageController"}; |
| managedStore::ManagedObjectStoreContext requestContext(asyncResp); |
| managedStore::GetManagedObjectStore()->getAssociatedSubTreePaths( |
| controllerPath / customNVMeAssociation, |
| sdbusplus::message::object_path("/xyz/openbmc_project/inventory"), 0, |
| interfaces, requestContext, |
| [asyncResp, systemName, storageId, controllerPath]( |
| const boost::system::error_code& ec, |
| const dbus::utility::MapperGetSubTreePathsResponse& customNVMeList) { |
| if (ec && ec.value() != EBADR) { |
| BMCWEB_LOG_ERROR << "Failed to get " << customNVMe |
| << "Controllers for controller " |
| << controllerPath.str; |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| if (customNVMeList.size() > 1) { |
| BMCWEB_LOG_ERROR << "More than 1 " << customNVMe |
| << "Controller for controller " |
| << controllerPath.str; |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| if (customNVMeList.empty()) { |
| return; |
| } |
| |
| const sdbusplus::message::object_path path{customNVMeList[0]}; |
| |
| redfish::storage_utils::findStorageForController( |
| asyncResp, storageId, path, |
| [asyncResp, systemName, |
| path](const std::optional<sdbusplus::message::object_path>& |
| canonStoragePath) { |
| if (canonStoragePath) { |
| const std::string canonStorageId = canonStoragePath->filename(); |
| const std::string id = path.filename(); |
| asyncResp->res.jsonValue[std::string(customNVMe) + "Controller"] |
| ["@odata.id"] = |
| crow::utility::urlFromPieces( |
| "redfish", "v1", "Systems", systemName, "Storage", |
| canonStorageId, "Controllers", id); |
| } |
| }); |
| }); |
| } |
| |
| inline void checkPrimary( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const sdbusplus::message::object_path& controllerPath) { |
| constexpr std::array<std::string_view, 1> interfaces = { |
| "xyz.openbmc_project.Inventory.Item.StorageController"}; |
| managedStore::ManagedObjectStoreContext requestContext(asyncResp); |
| |
| managedStore::GetManagedObjectStore()->getAssociatedSubTreePaths( |
| controllerPath / "primary", |
| sdbusplus::message::object_path("/xyz/openbmc_project/inventory"), 0, |
| interfaces, requestContext, |
| [asyncResp, controllerPath]( |
| const boost::system::error_code& ec, |
| const dbus::utility::MapperGetSubTreePathsResponse& controllerList) { |
| if (ec) { |
| BMCWEB_LOG_ERROR << "getAssociatedSubTreePaths for path " |
| << controllerPath.str << " failed with code " << ec; |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| asyncResp->res.jsonValue["ControllerType"] = |
| controllerList.empty() ? "Primary" : "Secondary"; |
| }); |
| } |
| |
| inline void populateNVMeController( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& systemName, const std::string& nvmeId, |
| const std::string& controllerId, const std::string& controllerPath) { |
| constexpr std::array<std::string_view, 1> interfaces{ |
| "xyz.openbmc_project.NVMe.NVMeAdmin"}; |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| managedStore::GetManagedObjectStore()->getDbusObject( |
| controllerPath, interfaces, context, |
| [asyncResp, systemName, nvmeId, controllerId, controllerPath]( |
| const boost::system::error_code ec, |
| const dbus::utility::MapperGetObject& objects) { |
| if (ec) { |
| BMCWEB_LOG_ERROR << "GetObject for path " << controllerPath |
| << " failed with code " << ec; |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| if (objects.size() != 1) { |
| redfish::messages::internalError(asyncResp->res); |
| BMCWEB_LOG_ERROR << "Service supporting " << controllerPath |
| << " is not equal to 1"; |
| return; |
| } |
| |
| asyncResp->res.jsonValue["@odata.type"] = |
| "#NVMeController.v1_0_0.NVMeController"; |
| asyncResp->res.jsonValue["@odata.id"] = crow::utility::urlFromPieces( |
| "google", "v1", "NVMe", nvmeId, "Controllers", controllerId); |
| asyncResp->res.jsonValue["Name"] = "Google NVMe Controller"; |
| |
| // NVMe actions |
| asyncResp->res |
| .jsonValue["Actions"]["#NVMeController.AdminNonDataCmd"]["target"] = |
| crow::utility::urlFromPieces("google", "v1", "NVMe", nvmeId, |
| "Controllers", controllerId, "Actions", |
| "NVMeController.AdminNonDataCmd"); |
| asyncResp->res |
| .jsonValue["Actions"]["#NVMeController.LockdownInband"]["target"] = |
| crow::utility::urlFromPieces("google", "v1", "NVMe", nvmeId, |
| "Controllers", controllerId, "Actions", |
| "NVMeController.LockdownInband"); |
| asyncResp->res |
| .jsonValue["Actions"]["#NVMeController.GetLogPage"]["target"] = |
| crow::utility::urlFromPieces("google", "v1", "NVMe", nvmeId, |
| "Controllers", controllerId, "Actions", |
| "NVMeController.GetLogPage"); |
| asyncResp->res |
| .jsonValue["Actions"]["#NVMeController.Identify"]["target"] = |
| crow::utility::urlFromPieces("google", "v1", "NVMe", nvmeId, |
| "Controllers", controllerId, "Actions", |
| "NVMeController.Identify"); |
| asyncResp->res.jsonValue["Links"]["NVMe"]["@odata.id"] = |
| crow::utility::urlFromPieces("google", "v1", "NVMe", nvmeId); |
| asyncResp->res.jsonValue["StorageController"]["@odata.id"] = |
| crow::utility::urlFromPieces("redfish", "v1", "Systems", systemName, |
| "Storage", nvmeId, "Controllers", |
| controllerId); |
| if (enableCustomNVMe) { |
| asyncResp->res.jsonValue["Actions"]["#NVMeController." + |
| std::string(customNVMe) + |
| "Identify"]["target"] = |
| crow::utility::urlFromPieces( |
| "google", "v1", "NVMe", nvmeId, "Controllers", controllerId, |
| "Actions", |
| "NVMeController." + std::string(customNVMe) + "Identify"); |
| populateCustomNVMeControllerLink(asyncResp, systemName, nvmeId, |
| controllerPath); |
| checkPrimary(asyncResp, controllerPath); |
| } |
| }); |
| } |
| |
| inline void setupNVMeController( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& systemName, const std::string& nvmeId, |
| const std::string& controllerId, |
| const std::vector<std::string>& controllerList) { |
| if (controllerList.empty()) { |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| for (const auto& controller : controllerList) { |
| if (sdbusplus::message::object_path(controller).filename() != |
| controllerId) { |
| continue; |
| } |
| populateNVMeController(asyncResp, systemName, nvmeId, controllerId, |
| controller); |
| return; |
| } |
| |
| redfish::messages::internalError(asyncResp->res); |
| } |
| |
| inline void populateNVMeControllerCollection( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& nvme, const boost::system::error_code ec, |
| const nlohmann::json::json_pointer& jsonPtr, |
| const std::vector<std::string>& controllerList) { |
| if (ec == boost::system::errc::io_error || controllerList.empty()) { |
| auto controllers = nlohmann::json::object(); |
| controllers["Name"] = "Google NVMe Controller Collection"; |
| controllers["@odata.id"] = crow::utility::urlFromPieces( |
| "google", "v1", "NVMe", nvme, "Controllers"); |
| controllers["Members"] = nlohmann::json::array(); |
| controllers["Members@odata.count"] = 0; |
| asyncResp->res.jsonValue[jsonPtr] = std::move(controllers); |
| return; |
| } |
| |
| if (ec) { |
| BMCWEB_LOG_DEBUG << "DBUS response error " << ec.value(); |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| auto controllers = nlohmann::json::object(); |
| controllers["Name"] = "Google NVMe Controller Collection"; |
| controllers["@odata.id"] = |
| crow::utility::urlFromPieces("google", "v1", "NVMe", nvme, "Controllers"); |
| nlohmann::json members = nlohmann::json::array(); |
| for (const std::string& controller : controllerList) { |
| std::string name = sdbusplus::message::object_path(controller).filename(); |
| if (name.empty()) { |
| continue; |
| } |
| nlohmann::json::object_t member; |
| member["@odata.id"] = crow::utility::urlFromPieces( |
| "google", "v1", "NVMe", nvme, "Controllers", name); |
| members.push_back(std::move(member)); |
| } |
| controllers["Members@odata.count"] = members.size(); |
| controllers["Members"] = std::move(members); |
| asyncResp->res.jsonValue[jsonPtr] = std::move(controllers); |
| } |
| |
| inline void processDriveResource( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::optional<std::string>& nvme, |
| std::function<void(const std::string&)>&& cb) { |
| managedStore::ManagedObjectStoreContext requestContext(asyncResp); |
| constexpr std::array<std::string_view, 1> interfaces{ |
| "xyz.openbmc_project.Inventory.Item.Drive"}; |
| managedStore::GetManagedObjectStore()->getSubTree( |
| "/xyz/openbmc_project/inventory", 0, interfaces, requestContext, |
| [asyncResp, nvme, requestContext, |
| cb{std::forward<std::function<void(const std::string&)>>(cb)}]( |
| const boost::system::error_code ec, |
| const dbus::utility::MapperGetSubTreeResponse& subtree) { |
| if (ec) { |
| BMCWEB_LOG_INFO << "DBUS error: no matched iface for Drive: " |
| << ec.message(); |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| for (const auto& [path, services] : subtree) { |
| if (nvme.has_value() && |
| sdbusplus::message::object_path(path).filename() != *nvme) { |
| continue; |
| } |
| |
| for (const auto& [service, interfaces] : services) { |
| for (const std::string& interface : interfaces) { |
| if (interface != "xyz.openbmc_project.Inventory.Item.Drive") { |
| continue; |
| } |
| |
| redfish::dbus_utils::getProperty<std::string>( |
| service, path, interface, "Protocol", requestContext, |
| [path{path}, cb](const boost::system::error_code ec2, |
| const std::string& driveProtocol) { |
| if (ec2) { |
| return; |
| } |
| |
| if (driveProtocol != |
| "xyz.openbmc_project.Inventory.Item.Drive." |
| "DriveProtocol.NVMe") { |
| return; |
| } |
| |
| cb(path); |
| }); |
| |
| // If expecting valid NVMe, return after finding the first |
| // NVMe. |
| if (nvme.has_value()) { |
| return; |
| } |
| } |
| } |
| } |
| // Expecting valid NVMe |
| if (nvme.has_value()) { |
| redfish::messages::internalError(asyncResp->res); |
| } |
| }); |
| } |
| |
| inline void handleGoogleNvmeController( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& nvme, NVMeControllerHandlerCb&& cb) { |
| processDriveResource( |
| asyncResp, nvme, |
| [asyncResp, cb{std::forward<NVMeControllerHandlerCb>(cb)}]( |
| const std::string& path) mutable { |
| managedStore::ManagedObjectStoreContext requestContext(asyncResp); |
| redfish::dbus_utils::getProperty<std::vector<std::string>>( |
| "xyz.openbmc_project.ObjectMapper", path + "/storage_controller", |
| "xyz.openbmc_project.Association", "endpoints", requestContext, |
| [cb{std::move(cb)}, path]( |
| const boost::system::error_code ec, |
| const std::vector<std::string>& controllerList) { |
| cb(ec, path, controllerList); |
| }); |
| }); |
| } |
| |
| inline void populateNVMe(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& path, const std::string& nvmeId) { |
| asyncResp->res.jsonValue["@odata.type"] = "#NVMe.v1_0_0.NVMe"; |
| asyncResp->res.jsonValue["@odata.id"] = |
| crow::utility::urlFromPieces("google", "v1", "NVMe", nvmeId); |
| asyncResp->res.jsonValue["Name"] = nvmeId; |
| |
| managedStore::ManagedObjectStoreContext requestContext(asyncResp); |
| redfish::dbus_utils::getProperty<std::vector<std::string>>( |
| "xyz.openbmc_project.ObjectMapper", path + "/storage", |
| "xyz.openbmc_project.Association", "endpoints", requestContext, |
| [asyncResp, nvmeId, requestContext]( |
| const boost::system::error_code ec, |
| const std::vector<std::string>& storageList) { |
| if (ec || storageList.empty()) { |
| BMCWEB_LOG_DEBUG << "Failed to find storage that is associated with " |
| << nvmeId; |
| return; |
| } |
| if (storageList.size() > 1) { |
| BMCWEB_LOG_DEBUG << nvmeId << " is associated with mutliple storages"; |
| return; |
| } |
| |
| sdbusplus::message::object_path storagePath(storageList[0]); |
| std::string storageId = storagePath.filename(); |
| if (storageId.empty()) { |
| BMCWEB_LOG_ERROR << "filename() is empty in " << storagePath.str; |
| return; |
| } |
| redfish::storage_utils::getSystemPathFromStorage( |
| asyncResp, storagePath, |
| [asyncResp, storageId](std::optional<std::string_view> systemPath) { |
| std::string systemName = |
| systemPath ? std::filesystem::path(*systemPath).filename() |
| : "system"; |
| asyncResp->res.jsonValue["Links"]["Storage"]["@odata.id"] = |
| crow::utility::urlFromPieces("redfish", "v1", "Systems", |
| systemName, "Storage", |
| storageId); |
| }); |
| }); |
| |
| constexpr std::array<std::string_view, 1> interfaces = { |
| "xyz.openbmc_project.NVMe.NVMeAdmin"}; |
| managedStore::GetManagedObjectStore()->getAssociatedSubTreePaths( |
| path + "/storage_controller", |
| sdbusplus::message::object_path("/xyz/openbmc_project/inventory"), 0, |
| interfaces, requestContext, |
| [asyncResp, nvmeId]( |
| const boost::system::error_code& ec, |
| const dbus::utility::MapperGetSubTreePathsResponse& controllerList) { |
| populateNVMeControllerCollection( |
| asyncResp, nvmeId, ec, "/Controllers"_json_pointer, controllerList); |
| }); |
| } |
| |
| inline void handleGoogleNvme( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& nvme) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| processDriveResource(asyncResp, nvme, |
| [asyncResp, nvme](const std::string& path) { |
| populateNVMe(asyncResp, path, nvme); |
| }); |
| } |
| |
| inline void handleGoogleNvmeControllerCollection( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& nvme) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| processDriveResource( |
| asyncResp, nvme, [asyncResp, nvme](const std::string& path) { |
| constexpr std::array<std::string_view, 1> interfaces = { |
| "xyz.openbmc_project.NVMe.NVMeAdmin"}; |
| managedStore::ManagedObjectStoreContext requestContext(asyncResp); |
| managedStore::GetManagedObjectStore()->getAssociatedSubTreePaths( |
| path + "/storage_controller", |
| sdbusplus::message::object_path("/xyz/openbmc_project/inventory"), |
| 0, interfaces, requestContext, |
| [asyncResp, nvme]( |
| const boost::system::error_code& ec, |
| const dbus::utility::MapperGetSubTreePathsResponse& |
| controllerList) { |
| populateNVMeControllerCollection(asyncResp, nvme, ec, |
| ""_json_pointer, controllerList); |
| }); |
| }); |
| } |
| |
| inline void handleGoogleNvmeCollection( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| asyncResp->res.jsonValue["@odata.type"] = |
| "#NVMeCollection.v1_0_0.NVMeCollection"; |
| asyncResp->res.jsonValue["@odata.id"] = "/google/v1/NVMe"; |
| asyncResp->res.jsonValue["Name"] = "Google NVMe Collection"; |
| |
| asyncResp->res.jsonValue["Members"] = nlohmann::json::array(); |
| asyncResp->res.jsonValue["Members@odata.count"] = 0; |
| |
| processDriveResource( |
| asyncResp, std::nullopt, [asyncResp](const std::string& path) { |
| std::string id = sdbusplus::message::object_path(path).filename(); |
| if (id.empty()) { |
| return; |
| } |
| |
| nlohmann::json& members = asyncResp->res.jsonValue["Members"]; |
| nlohmann::json::object_t member; |
| member["@odata.id"] = |
| crow::utility::urlFromPieces("google", "v1", "NVMe", id); |
| members.push_back(std::move(member)); |
| asyncResp->res.jsonValue["Members@odata.count"] = members.size(); |
| }); |
| } |
| |
| inline void getIdentity( |
| uint8_t cns, uint16_t cntid, uint32_t nsid, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& controllerId, const boost::system::error_code ec, |
| const std::vector<std::string>& controllerList, |
| const std::string& adminInterface = "xyz.openbmc_project.NVMe.NVMeAdmin") { |
| if (ec || controllerList.empty()) { |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| std::string controllerPath; |
| for (const std::string& controller : controllerList) { |
| if (sdbusplus::message::object_path(controller).filename() == |
| controllerId) { |
| controllerPath = controller; |
| break; |
| } |
| } |
| |
| if (controllerPath.empty()) { |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| const std::string_view adminInterfaceView = adminInterface; |
| std::span<const std::string_view> interfaces(&adminInterfaceView, 1); |
| managedStore::GetManagedObjectStore()->getDbusObject( |
| controllerPath, interfaces, context, |
| [asyncResp, cns, cntid, nsid, controllerPath, adminInterface]( |
| const boost::system::error_code ec2, |
| const dbus::utility::MapperGetObject& objects) { |
| if (ec2) { |
| BMCWEB_LOG_ERROR << "GetObject for path " << controllerPath |
| << " failed with code " << ec2; |
| return; |
| } |
| |
| if (objects.size() != 1) { |
| redfish::messages::internalError(asyncResp->res); |
| BMCWEB_LOG_ERROR << "Service supporting " << controllerPath |
| << " is not equal to 1"; |
| return; |
| } |
| |
| managedStore::GetManagedObjectStore() |
| ->PostDbusCallToIoContextThreadSafe( |
| asyncResp->strand_, |
| [asyncResp, objects, controllerPath]( |
| const boost::system::error_code ec3, |
| const sdbusplus::message::unix_fd& fd) { |
| if (ec3) { |
| BMCWEB_LOG_ERROR << "Failed to call NVMe Identity: " |
| << ec3.message(); |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| int dupFd = dup(fd.fd); |
| fetchFile(asyncResp, std::make_shared<stream_descriptor>( |
| *fdIOContext, dupFd)); |
| }, |
| objects[0].first, controllerPath, adminInterface, "Identify", |
| cns, nsid, cntid); |
| }); |
| } |
| |
| inline void handleGoogleNvmeControllerCustomNVMeIdentifyAction( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& nvmeId, const std::string& controllerId) { |
| uint8_t cns = 0; // Controller or Namespace Structure |
| uint16_t cntid = 0; // Controller Identifier |
| uint32_t nsid = 0; // Namespace Identifier |
| |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| |
| if (!redfish::json_util::readJsonAction(req, asyncResp->res, "CNS", cns, |
| "CNTID", cntid, "NSID", nsid)) { |
| redfish::messages::actionParameterMissing( |
| asyncResp->res, "ControllerNamespace", "ControllerNamespaceId"); |
| return; |
| } |
| handleGoogleNvmeController( |
| asyncResp, nvmeId, |
| [cns, cntid, nsid, asyncResp, controllerId]( |
| const boost::system::error_code ec, |
| const std::string& /* storagePath */, |
| const std::vector<std::string>& controllerList) { |
| getIdentity( |
| cns, cntid, nsid, asyncResp, controllerId, ec, controllerList, |
| "xyz.openbmc_project.NVMe." + std::string(customNVMe) + "Admin"); |
| }); |
| } |
| |
| inline void handleGoogleNvmeControllerIdentifyAction( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& nvmeId, const std::string& controllerId) { |
| uint8_t cns = 0; // Controller or Namespace Structure |
| uint16_t cntid = 0; // Controller Identifier |
| uint32_t nsid = 0; // Namespace Identifier |
| |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| |
| if (!redfish::json_util::readJsonAction(req, asyncResp->res, "CNS", cns, |
| "CNTID", cntid, "NSID", nsid)) { |
| redfish::messages::actionParameterMissing( |
| asyncResp->res, "ControllerNamespace", "ControllerNamespaceId"); |
| return; |
| } |
| handleGoogleNvmeController( |
| asyncResp, nvmeId, |
| [cns, cntid, nsid, asyncResp, controllerId]( |
| const boost::system::error_code ec, |
| const std::string& /* storagePath */, |
| const std::vector<std::string>& controllerList) { |
| getIdentity(cns, cntid, nsid, asyncResp, controllerId, ec, |
| controllerList); |
| }); |
| } |
| |
| inline void adminNonDataCmd( |
| [[maybe_unused]] uint8_t opcode, [[maybe_unused]] uint32_t cdw1, |
| [[maybe_unused]] uint32_t cdw2, [[maybe_unused]] uint32_t cdw3, |
| [[maybe_unused]] uint32_t cdw10, [[maybe_unused]] uint32_t cdw11, |
| [[maybe_unused]] uint32_t cdw12, [[maybe_unused]] uint32_t cdw13, |
| [[maybe_unused]] uint32_t cdw14, [[maybe_unused]] uint32_t cdw15, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& controllerId, const boost::system::error_code ec, |
| const std::vector<std::string>& controllerList) { |
| if (ec || controllerList.empty()) { |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| std::string controllerPath; |
| for (const std::string& controller : controllerList) { |
| if (sdbusplus::message::object_path(controller).filename() == |
| controllerId) { |
| controllerPath = controller; |
| break; |
| } |
| } |
| |
| if (controllerPath.empty()) { |
| BMCWEB_LOG_ERROR << "failed to find DBus controller path for " |
| << controllerId; |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| // The PostDbusCallToIoContextThreadSafe is NOT unitestable. MOCK_METHOD dosent |
| // work with this many params. If we want to unit test this funciton, we |
| // probably will have to change dbus. |
| #ifndef UNIT_TEST_BUILD |
| |
| constexpr std::array<std::string_view, 1> interfaces = { |
| "xyz.openbmc_project.NVMe.Passthru"}; |
| |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| managedStore::GetManagedObjectStore()->getDbusObject( |
| controllerPath, interfaces, context, |
| [asyncResp, opcode, cdw1, cdw2, cdw3, cdw10, cdw11, cdw12, cdw13, cdw14, |
| cdw15, controllerPath](const boost::system::error_code ec2, |
| const dbus::utility::MapperGetObject& objects) { |
| if (ec2) { |
| BMCWEB_LOG_ERROR << "GetObject for path " << controllerPath |
| << " failed with code " << ec2; |
| return; |
| } |
| |
| if (objects.size() != 1) { |
| redfish::messages::internalError(asyncResp->res); |
| BMCWEB_LOG_ERROR << "Service supporting " << controllerPath |
| << " is not equal to 1"; |
| return; |
| } |
| |
| const std::string& service{objects[0].first}; |
| |
| managedStore::GetManagedObjectStore() |
| ->PostDbusCallToIoContextThreadSafe( |
| asyncResp->strand_, |
| [asyncResp]( |
| const boost::system::error_code ec3, |
| const sdbusplus::message_t& msg, |
| const std::tuple<uint32_t, uint32_t, uint32_t>& response) { |
| const ::sd_bus_error* sd_err = msg.get_error(); |
| if (sd_err != nullptr) { |
| redfish::messages::generalError(asyncResp->res); |
| if (sd_err->message != nullptr) { |
| BMCWEB_LOG_ERROR << "Error: " << sd_err->name |
| << " message " << sd_err->message; |
| asyncResp->res.jsonValue["error"]["message"] = |
| sd_err->message; |
| } |
| return; |
| } |
| |
| if (ec3) { |
| BMCWEB_LOG_ERROR << "AdminNonDataCmd dbus error " << ec3; |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| // Success |
| asyncResp->res.jsonValue["MIStatus"] = std::get<0>(response); |
| asyncResp->res.jsonValue["AdminStatus"] = |
| std::get<1>(response); |
| asyncResp->res.jsonValue["CompletionDW0"] = |
| std::get<2>(response); |
| }, |
| service, controllerPath, "xyz.openbmc_project.NVMe.Passthru", |
| "AdminNonDataCmd", opcode, cdw1, cdw2, cdw3, cdw10, cdw11, |
| cdw12, cdw13, cdw14, cdw15); |
| }); |
| #endif |
| } |
| |
| inline void lockdownInband(const uint8_t prohibit, |
| const std::vector<uint8_t>& adminCmds, |
| const std::vector<uint8_t>& features, |
| const std::vector<uint8_t>& logPages, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& controllerId, |
| const boost::system::error_code& ec, |
| const std::vector<std::string>& controllerList) { |
| if (ec || controllerList.empty()) { |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| std::string controllerPath; |
| for (const std::string& controller : controllerList) { |
| if (sdbusplus::message::object_path(controller).filename() == |
| controllerId) { |
| controllerPath = controller; |
| break; |
| } |
| } |
| |
| if (controllerPath.empty()) { |
| BMCWEB_LOG_ERROR << "failed to find DBus controller path for " |
| << controllerId; |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| constexpr std::array<std::string_view, 1> interfaces = { |
| "xyz.openbmc_project.NVMe.Lockdown"}; |
| |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| managedStore::GetManagedObjectStore()->getDbusObject( |
| controllerPath, interfaces, context, |
| [asyncResp, prohibit, adminCmds, features, logPages, controllerPath]( |
| const boost::system::error_code& ec2, |
| const dbus::utility::MapperGetObject& objects) { |
| if (ec2) { |
| BMCWEB_LOG_ERROR << "GetObject for path " << controllerPath |
| << " failed with code " << ec2; |
| return; |
| } |
| |
| if (objects.size() != 1) { |
| redfish::messages::internalError(asyncResp->res); |
| BMCWEB_LOG_ERROR << "Service supporting " << controllerPath |
| << " is not equal to 1"; |
| return; |
| } |
| |
| const std::string& service{objects[0].first}; |
| |
| managedStore::GetManagedObjectStore() |
| ->PostDbusCallToIoContextThreadSafe( |
| asyncResp->strand_, |
| absl::AnyInvocable<void( |
| const boost::system::error_code&, |
| const sdbusplus::message_t&, |
| const std::tuple<uint32_t, uint32_t, uint32_t, std::string, |
| uint32_t>&)>( |
| [asyncResp]( |
| const boost::system::error_code& ec3, |
| const sdbusplus::message_t& msg, |
| const std::tuple<uint32_t, uint32_t, uint32_t, |
| std::string, uint32_t>& response) { |
| const ::sd_bus_error* sdErr = msg.get_error(); |
| if (sdErr != nullptr) { |
| redfish::messages::generalError(asyncResp->res); |
| if (sdErr->message != nullptr) { |
| BMCWEB_LOG_ERROR << "Error: " << sdErr->name |
| << " message " << sdErr->message; |
| asyncResp->res.jsonValue["error"]["message"] = |
| sdErr->message; |
| } |
| return; |
| } |
| |
| if (ec3) { |
| BMCWEB_LOG_ERROR << "LockdownInband dbus error " << ec3; |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| // Success |
| uint32_t miStatus = std::get<0>(response); |
| uint32_t adminStatus = std::get<1>(response); |
| asyncResp->res.jsonValue["MIStatus"] = miStatus; |
| asyncResp->res.jsonValue["AdminStatus"] = adminStatus; |
| asyncResp->res.jsonValue["CompletionDW0"] = |
| std::get<2>(response); |
| if (miStatus != 0 || adminStatus != 0) { |
| asyncResp->res.jsonValue["FailureScope"] = |
| std::get<3>(response); |
| asyncResp->res.jsonValue["FailureId"] = |
| std::get<4>(response); |
| } |
| }), |
| service, controllerPath, "xyz.openbmc_project.NVMe.Lockdown", |
| "LockdownInband", prohibit, adminCmds, features, logPages); |
| }); |
| } |
| |
| inline void getLogPage( |
| uint8_t lid, // Log Page Identifier, Command Dword 10 bits[07:00] |
| uint32_t nsid, |
| uint8_t lsp, // Log Specific Field, Command Dword 10 bits[14:08] |
| uint16_t lsi, // Log Specific Identifier, Command Dword 11 bits[31:16] |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& controllerId, const boost::system::error_code ec, |
| const std::vector<std::string>& controllerList) { |
| if (ec || controllerList.empty()) { |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| std::string controllerPath; |
| for (const std::string& controller : controllerList) { |
| if (sdbusplus::message::object_path(controller).filename() == |
| controllerId) { |
| controllerPath = controller; |
| break; |
| } |
| } |
| |
| if (controllerPath.empty()) { |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| constexpr std::array<std::string_view, 1> interfaces = { |
| "xyz.openbmc_project.NVMe.NVMeAdmin"}; |
| managedStore::ManagedObjectStoreContext requestContext(asyncResp); |
| managedStore::GetManagedObjectStore()->getDbusObject( |
| controllerPath, interfaces, requestContext, |
| [asyncResp, lid, nsid, lsp, lsi, controllerPath]( |
| const boost::system::error_code ec2, |
| const dbus::utility::MapperGetObject& objects) { |
| if (ec2) { |
| BMCWEB_LOG_ERROR << "GetObject for path " << controllerPath |
| << " failed with code " << ec2; |
| return; |
| } |
| |
| if (objects.size() != 1) { |
| BMCWEB_LOG_ERROR << "Service supporting " << controllerPath |
| << " is not equal to 1"; |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| managedStore::GetManagedObjectStore() |
| ->PostDbusCallToIoContextThreadSafe( |
| asyncResp->strand_, |
| [asyncResp, objects, controllerPath]( |
| const boost::system::error_code ec3, |
| const sdbusplus::message::unix_fd& fd) { |
| if (ec3) { |
| BMCWEB_LOG_INFO << "Failed to call NVMe Log " |
| << ec3.message(); |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| int dupFd = dup(fd.fd); |
| fetchFile(asyncResp, std::make_shared<stream_descriptor>( |
| *fdIOContext, dupFd)); |
| }, |
| objects[0].first, controllerPath, |
| "xyz.openbmc_project.NVMe.NVMeAdmin", "GetLogPage", lid, nsid, |
| lsp, lsi); |
| }); |
| } |
| |
| inline void handleGoogleNvmeControllerLogAction( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& nvmeId, const std::string& controllerId) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| |
| uint8_t lid = 0; // Log Page Identifier, Command Dword 10 bits[07:00] |
| uint32_t nsid = 0; |
| uint8_t lsp = 0; // Log Specific Field, Command Dword 10 bits[14:08] |
| uint16_t lsi = 0; // Log Specific Identifier, Command Dword 11 bits[31:16] |
| |
| if (!redfish::json_util::readJsonAction(req, asyncResp->res, "LID", lid, |
| "NSID", nsid, "LSP", lsp, "LSI", |
| lsi)) { |
| redfish::messages::actionParameterMissing(asyncResp->res, "LogSpecificId", |
| "LogId"); |
| return; |
| } |
| |
| handleGoogleNvmeController( |
| asyncResp, nvmeId, |
| [lid, nsid, lsp, lsi, asyncResp, controllerId]( |
| const boost::system::error_code ec, |
| const std::string& /* storagePath */, |
| const std::vector<std::string>& controllerList) { |
| getLogPage(lid, nsid, lsp, lsi, asyncResp, controllerId, ec, |
| controllerList); |
| }); |
| } |
| |
| inline void handleGoogleNvmeControllerAdminNonDataAction( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& nvmeId, const std::string& controllerId) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| |
| // Only opcode is mandatory |
| uint8_t opcode = 0; |
| std::optional<uint32_t> cdw1; |
| std::optional<uint32_t> cdw2; |
| std::optional<uint32_t> cdw3; |
| std::optional<uint32_t> cdw10; |
| std::optional<uint32_t> cdw11; |
| std::optional<uint32_t> cdw12; |
| std::optional<uint32_t> cdw13; |
| std::optional<uint32_t> cdw14; |
| std::optional<uint32_t> cdw15; |
| |
| if (!redfish::json_util::readJsonAction( |
| req, asyncResp->res, "opcode", opcode, "cdw1", cdw1, "cdw2", cdw2, |
| "cdw3", cdw3, "cdw10", cdw10, "cdw11", cdw11, "cdw12", cdw12, "cdw13", |
| cdw13, "cdw14", cdw14, "cdw15", cdw15)) { |
| redfish::messages::actionParameterMissing( |
| asyncResp->res, "NVMeController.AdminNonDataCmd", "opcode"); |
| return; |
| } |
| |
| handleGoogleNvmeController( |
| asyncResp, nvmeId, |
| [opcode, cdw1{cdw1.value_or(0)}, cdw2{cdw2.value_or(0)}, |
| cdw3{cdw3.value_or(0)}, cdw10{cdw10.value_or(0)}, |
| cdw11{cdw11.value_or(0)}, cdw12{cdw12.value_or(0)}, |
| cdw13{cdw13.value_or(0)}, cdw14{cdw14.value_or(0)}, |
| cdw15{cdw15.value_or(0)}, asyncResp, |
| controllerId](const boost::system::error_code ec, |
| const std::string& /* storagePath */, |
| const std::vector<std::string>& controllerList) { |
| adminNonDataCmd(opcode, cdw1, cdw2, cdw3, cdw10, cdw11, cdw12, cdw13, |
| cdw14, cdw15, asyncResp, controllerId, ec, |
| controllerList); |
| }); |
| } |
| |
| inline void handleGoogleNvmeControllerLockdownInband( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& nvmeId, const std::string& controllerId) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| |
| bool prohibit = false; |
| std::optional<std::vector<uint8_t>> adminCmds; |
| std::optional<std::vector<uint8_t>> features; |
| std::optional<std::vector<uint8_t>> logPages; |
| |
| if (!redfish::json_util::readJsonAction( |
| req, asyncResp->res, "Prohibit", prohibit, "AdminCmds", adminCmds, |
| "Features", features, "LogPages", logPages)) { |
| redfish::messages::actionParameterMissing( |
| asyncResp->res, "NVMeController.LockdownInband", "Prohibit"); |
| return; |
| } |
| |
| handleGoogleNvmeController( |
| asyncResp, nvmeId, |
| [prohibit, adminCmds, features, logPages, asyncResp, controllerId]( |
| const boost::system::error_code& ec, |
| const std::string& /* storagePath */, |
| const std::vector<std::string>& controllerList) { |
| lockdownInband(prohibit ? 1 : 0, |
| adminCmds.value_or(std::vector<uint8_t>{}), |
| features.value_or(std::vector<uint8_t>{}), |
| logPages.value_or(std::vector<uint8_t>{}), asyncResp, |
| controllerId, ec, controllerList); |
| }); |
| } |
| inline void setupGoogleNVMeFdFetchIOContext( |
| const std::shared_ptr<boost::asio::io_context>& ioc) { |
| fdIOContext = ioc; |
| } |
| |
| inline void requestGoogleNVMeControllerActionCustomNVMeIdentify(App& app) { |
| BMCWEB_ROUTE( |
| app, "/google/v1/NVMe/<str>/Controllers/<str>/Actions/NVMeController." + |
| std::string(customNVMe) + "Identify") |
| .privileges({{"ConfigureManager"}}) |
| .methods(boost::beast::http::verb::post)(std::bind_front( |
| handleGoogleNvmeControllerCustomNVMeIdentifyAction, std::ref(app))); |
| } |
| |
| inline void requestGoogleNVMeControllerActionIdentify(App& app) { |
| BMCWEB_ROUTE( |
| app, |
| "/google/v1/NVMe/<str>/Controllers/<str>/Actions/NVMeController.Identify") |
| .privileges({{"ConfigureManager"}}) |
| .methods(boost::beast::http::verb::post)(std::bind_front( |
| handleGoogleNvmeControllerIdentifyAction, std::ref(app))); |
| } |
| |
| inline void requestGoogleNVMeControllerActionLog(App& app) { |
| BMCWEB_ROUTE(app, |
| "/google/v1/NVMe/<str>/Controllers/<str>/Actions/" |
| "NVMeController.GetLogPage") |
| .privileges({{"ConfigureManager"}}) |
| .methods(boost::beast::http::verb::post)( |
| std::bind_front(handleGoogleNvmeControllerLogAction, std::ref(app))); |
| } |
| |
| inline void requestGoogleNVMeControllerActionAdminNonData(App& app) { |
| BMCWEB_ROUTE(app, |
| "/google/v1/NVMe/<str>/Controllers/<str>/Actions/" |
| "NVMeController.AdminNonDataCmd") |
| .privileges({{"ConfigureManager"}}) |
| .methods(boost::beast::http::verb::post)(std::bind_front( |
| handleGoogleNvmeControllerAdminNonDataAction, std::ref(app))); |
| } |
| |
| inline void requestGoogleNVMeControllerActionLockdownInband(App& app) { |
| BMCWEB_ROUTE(app, |
| "/google/v1/NVMe/<str>/Controllers/<str>/Actions/" |
| "NVMeController.LockdownInband") |
| .privileges({{"ConfigureManager"}}) |
| .methods(boost::beast::http::verb::post)(std::bind_front( |
| handleGoogleNvmeControllerLockdownInband, std::ref(app))); |
| } |
| |
| inline void handleGoogleNVMeControllerGet( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& nvmeId, const std::string& controllerId) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| |
| handleGoogleNvmeController( |
| asyncResp, nvmeId, |
| [asyncResp, nvmeId, controllerId]( |
| const boost::system::error_code ec, const std::string& storagePath, |
| const std::vector<std::string>& controllerList) { |
| if (ec) { |
| redfish::messages::internalError(asyncResp->res); |
| return; |
| } |
| redfish::storage_utils::getSystemPathFromStorage( |
| asyncResp, storagePath, |
| [asyncResp, nvmeId, controllerId, |
| controllerList](std::optional<std::string_view> systemPath) { |
| std::string systemName = |
| systemPath ? std::filesystem::path(*systemPath).filename() |
| : "system"; |
| setupNVMeController(asyncResp, systemName, nvmeId, controllerId, |
| controllerList); |
| }); |
| }); |
| } |
| |
| inline void requestGoogleNVMeController(App& app) { |
| BMCWEB_ROUTE(app, "/google/v1/NVMe/<str>/Controllers/<str>") |
| .privileges({{"ConfigureManager"}}) |
| .methods(boost::beast::http::verb::get)( |
| std::bind_front(handleGoogleNVMeControllerGet, std::ref(app))); |
| } |
| |
| inline void requestGoogleNVMeControllerCollection(App& app) { |
| BMCWEB_ROUTE(app, "/google/v1/NVMe/<str>/Controllers") |
| .privileges({{"ConfigureManager"}}) |
| .methods(boost::beast::http::verb::get)( |
| std::bind_front(handleGoogleNvmeControllerCollection, std::ref(app))); |
| } |
| |
| inline void requestGoogleNVMe(App& app) { |
| BMCWEB_ROUTE(app, "/google/v1/NVMe/<str>") |
| .privileges({{"ConfigureManager"}}) |
| .methods(boost::beast::http::verb::get)( |
| std::bind_front(handleGoogleNvme, std::ref(app))); |
| } |
| |
| inline void requestGoogleNVMeCollection(App& app) { |
| BMCWEB_ROUTE(app, "/google/v1/NVMe") |
| .privileges({{"ConfigureManager"}}) |
| .methods(boost::beast::http::verb::get)( |
| std::bind_front(handleGoogleNvmeCollection, std::ref(app))); |
| } |
| |
| } // namespace google_api |
| } // namespace crow |
| |
| #endif // THIRD_PARTY_GBMCWEB_INCLUDE_GOOGLE_GOOGLE_SERVICE_NVME_H_ |
