blob: b963a534e2d1b7ac0c9e81618b85633deac52863 [file] [log] [blame]
/*
// Copyright (c) 2018 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
*/
#pragma once
#include "node.hpp"
#include <boost/system/linux_error.hpp>
namespace redfish
{
static constexpr char const *pcieService = "xyz.openbmc_project.PCIe";
static constexpr char const *pciePath = "/xyz/openbmc_project/PCIe";
static constexpr char const *pcieDeviceInterface =
"xyz.openbmc_project.PCIe.Device";
static inline void getPCIeDeviceList(std::shared_ptr<AsyncResp> asyncResp,
const std::string &name)
{
auto getPCIeMapCallback = [asyncResp, name](
const boost::system::error_code ec,
std::vector<std::string> &pcieDevicePaths) {
if (ec)
{
BMCWEB_LOG_DEBUG << "no PCIe device paths found ec: "
<< ec.message();
// Not an error, system just doesn't have PCIe info
return;
}
nlohmann::json &pcieDeviceList = asyncResp->res.jsonValue[name];
pcieDeviceList = nlohmann::json::array();
for (const std::string &pcieDevicePath : pcieDevicePaths)
{
size_t devStart = pcieDevicePath.rfind("/");
if (devStart == std::string::npos)
{
continue;
}
std::string devName = pcieDevicePath.substr(devStart + 1);
if (devName.empty())
{
continue;
}
pcieDeviceList.push_back(
{{"@odata.id",
"/redfish/v1/Systems/system/PCIeDevices/" + devName}});
}
asyncResp->res.jsonValue[name + "@odata.count"] = pcieDeviceList.size();
};
crow::connections::systemBus->async_method_call(
std::move(getPCIeMapCallback), "xyz.openbmc_project.ObjectMapper",
"/xyz/openbmc_project/object_mapper",
"xyz.openbmc_project.ObjectMapper", "GetSubTreePaths",
std::string(pciePath) + "/", 1, std::array<std::string, 0>());
}
class SystemPCIeDeviceCollection : public Node
{
public:
template <typename CrowApp>
SystemPCIeDeviceCollection(CrowApp &app) :
Node(app, "/redfish/v1/Systems/system/PCIeDevices/")
{
entityPrivileges = {
{boost::beast::http::verb::get, {{"Login"}}},
{boost::beast::http::verb::head, {{"Login"}}},
{boost::beast::http::verb::patch, {{"ConfigureManager"}}},
{boost::beast::http::verb::put, {{"ConfigureManager"}}},
{boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
{boost::beast::http::verb::post, {{"ConfigureManager"}}}};
}
private:
/**
* Functions triggers appropriate requests on DBus
*/
void doGet(crow::Response &res, const crow::Request &req,
const std::vector<std::string> &params) override
{
std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
asyncResp->res.jsonValue = {
{"@odata.type", "#PCIeDeviceCollection.PCIeDeviceCollection"},
{"@odata.id", "/redfish/v1/Systems/system/PCIeDevices"},
{"Name", "PCIe Device Collection"},
{"Description", "Collection of PCIe Devices"},
{"Members", nlohmann::json::array()},
{"Members@odata.count", 0}};
getPCIeDeviceList(asyncResp, "Members");
}
};
class SystemPCIeDevice : public Node
{
public:
SystemPCIeDevice(CrowApp &app) :
Node(app, "/redfish/v1/Systems/system/PCIeDevices/<str>/",
std::string())
{
entityPrivileges = {
{boost::beast::http::verb::get, {{"Login"}}},
{boost::beast::http::verb::head, {{"Login"}}},
{boost::beast::http::verb::patch, {{"ConfigureManager"}}},
{boost::beast::http::verb::put, {{"ConfigureManager"}}},
{boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
{boost::beast::http::verb::post, {{"ConfigureManager"}}}};
}
private:
void doGet(crow::Response &res, const crow::Request &req,
const std::vector<std::string> &params) override
{
std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
if (params.size() != 1)
{
messages::internalError(asyncResp->res);
return;
}
const std::string &device = params[0];
auto getPCIeDeviceCallback =
[asyncResp,
device](const boost::system::error_code ec,
boost::container::flat_map<
std::string, sdbusplus::message::variant<std::string>>
&pcieDevProperties) {
if (ec)
{
BMCWEB_LOG_DEBUG
<< "failed to get PCIe Device properties ec: "
<< ec.value() << ": " << ec.message();
if (ec.value() ==
boost::system::linux_error::bad_request_descriptor)
{
messages::resourceNotFound(asyncResp->res, "PCIeDevice",
device);
}
else
{
messages::internalError(asyncResp->res);
}
return;
}
asyncResp->res.jsonValue = {
{"@odata.type", "#PCIeDevice.v1_4_0.PCIeDevice"},
{"@odata.id",
"/redfish/v1/Systems/system/PCIeDevices/" + device},
{"Name", "PCIe Device"},
{"Id", device}};
if (std::string *property =
sdbusplus::message::variant_ns::get_if<std::string>(
&pcieDevProperties["Manufacturer"]);
property)
{
asyncResp->res.jsonValue["Manufacturer"] = *property;
}
if (std::string *property =
sdbusplus::message::variant_ns::get_if<std::string>(
&pcieDevProperties["DeviceType"]);
property)
{
asyncResp->res.jsonValue["DeviceType"] = *property;
}
asyncResp->res.jsonValue["PCIeFunctions"] = {
{"@odata.id", "/redfish/v1/Systems/system/PCIeDevices/" +
device + "/PCIeFunctions"}};
};
std::string escapedPath = std::string(pciePath) + "/" + device;
dbus::utility::escapePathForDbus(escapedPath);
crow::connections::systemBus->async_method_call(
std::move(getPCIeDeviceCallback), pcieService, escapedPath,
"org.freedesktop.DBus.Properties", "GetAll", pcieDeviceInterface);
}
};
class SystemPCIeFunctionCollection : public Node
{
public:
template <typename CrowApp>
SystemPCIeFunctionCollection(CrowApp &app) :
Node(app, "/redfish/v1/Systems/system/PCIeDevices/<str>/PCIeFunctions/",
std::string())
{
entityPrivileges = {
{boost::beast::http::verb::get, {{"Login"}}},
{boost::beast::http::verb::head, {{"Login"}}},
{boost::beast::http::verb::patch, {{"ConfigureManager"}}},
{boost::beast::http::verb::put, {{"ConfigureManager"}}},
{boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
{boost::beast::http::verb::post, {{"ConfigureManager"}}}};
}
private:
/**
* Functions triggers appropriate requests on DBus
*/
void doGet(crow::Response &res, const crow::Request &req,
const std::vector<std::string> &params) override
{
std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
if (params.size() != 1)
{
messages::internalError(asyncResp->res);
return;
}
const std::string &device = params[0];
asyncResp->res.jsonValue = {
{"@odata.type", "#PCIeFunctionCollection.PCIeFunctionCollection"},
{"@odata.id", "/redfish/v1/Systems/system/PCIeDevices/" + device +
"/PCIeFunctions"},
{"Name", "PCIe Function Collection"},
{"Description",
"Collection of PCIe Functions for PCIe Device " + device}};
auto getPCIeDeviceCallback =
[asyncResp,
device](const boost::system::error_code ec,
boost::container::flat_map<
std::string, sdbusplus::message::variant<std::string>>
&pcieDevProperties) {
if (ec)
{
BMCWEB_LOG_DEBUG
<< "failed to get PCIe Device properties ec: "
<< ec.value() << ": " << ec.message();
if (ec.value() ==
boost::system::linux_error::bad_request_descriptor)
{
messages::resourceNotFound(asyncResp->res, "PCIeDevice",
device);
}
else
{
messages::internalError(asyncResp->res);
}
return;
}
nlohmann::json &pcieFunctionList =
asyncResp->res.jsonValue["Members"];
pcieFunctionList = nlohmann::json::array();
static constexpr const int maxPciFunctionNum = 8;
for (int functionNum = 0; functionNum < maxPciFunctionNum;
functionNum++)
{
// Check if this function exists by looking for a device ID
std::string devIDProperty =
"Function" + std::to_string(functionNum) + "DeviceId";
std::string *property =
sdbusplus::message::variant_ns::get_if<std::string>(
&pcieDevProperties[devIDProperty]);
if (property && !property->empty())
{
pcieFunctionList.push_back(
{{"@odata.id",
"/redfish/v1/Systems/system/PCIeDevices/" +
device + "/PCIeFunctions/" +
std::to_string(functionNum)}});
}
}
asyncResp->res.jsonValue["PCIeFunctions@odata.count"] =
pcieFunctionList.size();
};
std::string escapedPath = std::string(pciePath) + "/" + device;
dbus::utility::escapePathForDbus(escapedPath);
crow::connections::systemBus->async_method_call(
std::move(getPCIeDeviceCallback), pcieService, escapedPath,
"org.freedesktop.DBus.Properties", "GetAll", pcieDeviceInterface);
}
};
class SystemPCIeFunction : public Node
{
public:
SystemPCIeFunction(CrowApp &app) :
Node(
app,
"/redfish/v1/Systems/system/PCIeDevices/<str>/PCIeFunctions/<str>/",
std::string(), std::string())
{
entityPrivileges = {
{boost::beast::http::verb::get, {{"Login"}}},
{boost::beast::http::verb::head, {{"Login"}}},
{boost::beast::http::verb::patch, {{"ConfigureManager"}}},
{boost::beast::http::verb::put, {{"ConfigureManager"}}},
{boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
{boost::beast::http::verb::post, {{"ConfigureManager"}}}};
}
private:
void doGet(crow::Response &res, const crow::Request &req,
const std::vector<std::string> &params) override
{
std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
if (params.size() != 2)
{
messages::internalError(asyncResp->res);
return;
}
const std::string &device = params[0];
const std::string &function = params[1];
auto getPCIeDeviceCallback =
[asyncResp, device, function](
const boost::system::error_code ec,
boost::container::flat_map<
std::string, sdbusplus::message::variant<std::string>>
&pcieDevProperties) {
if (ec)
{
BMCWEB_LOG_DEBUG
<< "failed to get PCIe Device properties ec: "
<< ec.value() << ": " << ec.message();
if (ec.value() ==
boost::system::linux_error::bad_request_descriptor)
{
messages::resourceNotFound(asyncResp->res, "PCIeDevice",
device);
}
else
{
messages::internalError(asyncResp->res);
}
return;
}
// Check if this function exists by looking for a device ID
std::string devIDProperty = "Function" + function + "DeviceId";
if (std::string *property =
sdbusplus::message::variant_ns::get_if<std::string>(
&pcieDevProperties[devIDProperty]);
property && property->empty())
{
messages::resourceNotFound(asyncResp->res, "PCIeFunction",
function);
return;
}
asyncResp->res.jsonValue = {
{"@odata.type", "#PCIeFunction.v1_2_0.PCIeFunction"},
{"@odata.id", "/redfish/v1/Systems/system/PCIeDevices/" +
device + "/PCIeFunctions/" + function},
{"Name", "PCIe Function"},
{"Id", function},
{"FunctionId", std::stoi(function)},
{"Links",
{{"PCIeDevice",
{{"@odata.id",
"/redfish/v1/Systems/system/PCIeDevices/" +
device}}}}}};
if (std::string *property =
sdbusplus::message::variant_ns::get_if<std::string>(
&pcieDevProperties["Function" + function +
"DeviceId"]);
property)
{
asyncResp->res.jsonValue["DeviceId"] = *property;
}
if (std::string *property =
sdbusplus::message::variant_ns::get_if<std::string>(
&pcieDevProperties["Function" + function +
"VendorId"]);
property)
{
asyncResp->res.jsonValue["VendorId"] = *property;
}
if (std::string *property =
sdbusplus::message::variant_ns::get_if<std::string>(
&pcieDevProperties["Function" + function +
"FunctionType"]);
property)
{
asyncResp->res.jsonValue["FunctionType"] = *property;
}
if (std::string *property =
sdbusplus::message::variant_ns::get_if<std::string>(
&pcieDevProperties["Function" + function +
"DeviceClass"]);
property)
{
asyncResp->res.jsonValue["DeviceClass"] = *property;
}
if (std::string *property =
sdbusplus::message::variant_ns::get_if<std::string>(
&pcieDevProperties["Function" + function +
"ClassCode"]);
property)
{
asyncResp->res.jsonValue["ClassCode"] = *property;
}
if (std::string *property =
sdbusplus::message::variant_ns::get_if<std::string>(
&pcieDevProperties["Function" + function +
"RevisionId"]);
property)
{
asyncResp->res.jsonValue["RevisionId"] = *property;
}
if (std::string *property =
sdbusplus::message::variant_ns::get_if<std::string>(
&pcieDevProperties["Function" + function +
"SubsystemId"]);
property)
{
asyncResp->res.jsonValue["SubsystemId"] = *property;
}
if (std::string *property =
sdbusplus::message::variant_ns::get_if<std::string>(
&pcieDevProperties["Function" + function +
"SubsystemVendorId"]);
property)
{
asyncResp->res.jsonValue["SubsystemVendorId"] = *property;
}
};
std::string escapedPath = std::string(pciePath) + "/" + device;
dbus::utility::escapePathForDbus(escapedPath);
crow::connections::systemBus->async_method_call(
std::move(getPCIeDeviceCallback), pcieService, escapedPath,
"org.freedesktop.DBus.Properties", "GetAll", pcieDeviceInterface);
}
};
} // namespace redfish