blob: f9f3a554743a923c55adb8c5618993d68379593b [file] [log] [blame]
#include "bios.hpp"
#include "utils.hpp"
#include "xyz/openbmc_project/Common/error.hpp"
#include <time.h>
#include <array>
#include <boost/crc.hpp>
#include <chrono>
#include <ctime>
#include <filesystem>
#include <iostream>
#include <memory>
#include <numeric>
#include <stdexcept>
#include <string>
#include <variant>
#include <vector>
namespace fs = std::filesystem;
using namespace pldm::responder::bios;
using namespace bios_parser;
using namespace pldm::utils;
constexpr auto stringTableFile = "stringTable";
constexpr auto attrTableFile = "attributeTable";
constexpr auto attrValTableFile = "attributeValueTable";
namespace pldm
{
using namespace sdbusplus::xyz::openbmc_project::Common::Error;
using EpochTimeUS = uint64_t;
using BIOSTableRow = std::vector<uint8_t>;
using BIOSJsonName = std::string;
constexpr auto dbusProperties = "org.freedesktop.DBus.Properties";
constexpr auto padChksumMax = 7;
namespace responder
{
namespace utils
{
void epochToBCDTime(uint64_t timeSec, uint8_t& seconds, uint8_t& minutes,
uint8_t& hours, uint8_t& day, uint8_t& month,
uint16_t& year)
{
auto t = time_t(timeSec);
auto time = localtime(&t);
seconds = pldm::utils::decimalToBcd(time->tm_sec);
minutes = pldm::utils::decimalToBcd(time->tm_min);
hours = pldm::utils::decimalToBcd(time->tm_hour);
day = pldm::utils::decimalToBcd(time->tm_mday);
month = pldm::utils::decimalToBcd(time->tm_mon +
1); // The number of months in the range
// 0 to 11.PLDM expects range 1 to 12
year = pldm::utils::decimalToBcd(time->tm_year +
1900); // The number of years since 1900
}
std::time_t timeToEpoch(uint8_t seconds, uint8_t minutes, uint8_t hours,
uint8_t day, uint8_t month, uint16_t year)
{
struct std::tm stm;
stm.tm_year = year - 1900;
stm.tm_mon = month - 1;
stm.tm_mday = day;
stm.tm_hour = hours;
stm.tm_min = minutes;
stm.tm_sec = seconds;
stm.tm_isdst = -1;
// It will get the time in seconds since
// Epoch, 1970.1.1 00:00:00 +0000,UTC.
return timegm(&stm);
}
size_t getTableTotalsize(size_t sizeWithoutPad)
{
return sizeWithoutPad + pldm_bios_table_pad_checksum_size(sizeWithoutPad);
}
void padAndChecksum(Table& table)
{
auto sizeWithoutPad = table.size();
auto padAndChecksumSize = pldm_bios_table_pad_checksum_size(sizeWithoutPad);
table.resize(table.size() + padAndChecksumSize);
pldm_bios_table_append_pad_checksum(table.data(), table.size(),
sizeWithoutPad);
}
} // namespace utils
namespace bios
{
Handler::Handler()
{
try
{
fs::remove(
fs::path(std::string(BIOS_TABLES_DIR) + "/" + stringTableFile));
fs::remove(
fs::path(std::string(BIOS_TABLES_DIR) + "/" + attrTableFile));
fs::remove(
fs::path(std::string(BIOS_TABLES_DIR) + "/" + attrValTableFile));
}
catch (const std::exception& e)
{
}
handlers.emplace(PLDM_SET_DATE_TIME,
[this](const pldm_msg* request, size_t payloadLength) {
return this->setDateTime(request, payloadLength);
});
handlers.emplace(PLDM_GET_DATE_TIME,
[this](const pldm_msg* request, size_t payloadLength) {
return this->getDateTime(request, payloadLength);
});
handlers.emplace(PLDM_GET_BIOS_TABLE,
[this](const pldm_msg* request, size_t payloadLength) {
return this->getBIOSTable(request, payloadLength);
});
handlers.emplace(PLDM_GET_BIOS_ATTRIBUTE_CURRENT_VALUE_BY_HANDLE,
[this](const pldm_msg* request, size_t payloadLength) {
return this->getBIOSAttributeCurrentValueByHandle(
request, payloadLength);
});
handlers.emplace(PLDM_SET_BIOS_ATTRIBUTE_CURRENT_VALUE,
[this](const pldm_msg* request, size_t payloadLength) {
return this->setBIOSAttributeCurrentValue(
request, payloadLength);
});
}
Response Handler::getDateTime(const pldm_msg* request, size_t /*payloadLength*/)
{
uint8_t seconds = 0;
uint8_t minutes = 0;
uint8_t hours = 0;
uint8_t day = 0;
uint8_t month = 0;
uint16_t year = 0;
constexpr auto timeInterface = "xyz.openbmc_project.Time.EpochTime";
constexpr auto hostTimePath = "/xyz/openbmc_project/time/host";
Response response(sizeof(pldm_msg_hdr) + PLDM_GET_DATE_TIME_RESP_BYTES, 0);
auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
EpochTimeUS timeUsec;
try
{
timeUsec = pldm::utils::DBusHandler().getDbusProperty<EpochTimeUS>(
hostTimePath, "Elapsed", timeInterface);
}
catch (const sdbusplus::exception::SdBusError& e)
{
std::cerr << "Error getting time, PATH=" << hostTimePath
<< " TIME INTERACE=" << timeInterface << "\n";
return CmdHandler::ccOnlyResponse(request, PLDM_ERROR);
}
uint64_t timeSec = std::chrono::duration_cast<std::chrono::seconds>(
std::chrono::microseconds(timeUsec))
.count();
pldm::responder::utils::epochToBCDTime(timeSec, seconds, minutes, hours,
day, month, year);
auto rc = encode_get_date_time_resp(request->hdr.instance_id, PLDM_SUCCESS,
seconds, minutes, hours, day, month,
year, responsePtr);
if (rc != PLDM_SUCCESS)
{
return ccOnlyResponse(request, rc);
}
return response;
}
Response Handler::setDateTime(const pldm_msg* request, size_t payloadLength)
{
uint8_t seconds = 0;
uint8_t minutes = 0;
uint8_t hours = 0;
uint8_t day = 0;
uint8_t month = 0;
uint16_t year = 0;
std::time_t timeSec;
constexpr auto setTimeInterface = "xyz.openbmc_project.Time.EpochTime";
constexpr auto setTimePath = "/xyz/openbmc_project/time/host";
constexpr auto timeSetPro = "Elapsed";
auto rc = decode_set_date_time_req(request, payloadLength, &seconds,
&minutes, &hours, &day, &month, &year);
if (rc != PLDM_SUCCESS)
{
return ccOnlyResponse(request, rc);
}
timeSec = pldm::responder::utils::timeToEpoch(seconds, minutes, hours, day,
month, year);
uint64_t timeUsec = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::seconds(timeSec))
.count();
PropertyValue value{timeUsec};
try
{
DBusMapping dbusMapping{setTimePath, setTimeInterface, timeSetPro,
"uint64_t"};
pldm::utils::DBusHandler().setDbusProperty(dbusMapping, value);
}
catch (std::exception& e)
{
std::cerr << "Error Setting time,PATH=" << setTimePath
<< "TIME INTERFACE=" << setTimeInterface
<< "ERROR=" << e.what() << "\n";
return ccOnlyResponse(request, PLDM_ERROR);
}
return ccOnlyResponse(request, PLDM_SUCCESS);
}
/** @brief Construct the BIOS string table
*
* @param[in,out] biosStringTable - the string table
* @param[in] request - Request message
*/
Response getBIOSStringTable(BIOSTable& biosStringTable, const pldm_msg* request)
{
Response response(sizeof(pldm_msg_hdr) + PLDM_GET_BIOS_TABLE_MIN_RESP_BYTES,
0);
auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
if (!biosStringTable.isEmpty())
{
auto rc = encode_get_bios_table_resp(
request->hdr.instance_id, PLDM_SUCCESS,
0, /* next transfer handle */
PLDM_START_AND_END, nullptr, response.size(),
responsePtr); // filling up the header here
if (rc != PLDM_SUCCESS)
{
return CmdHandler::ccOnlyResponse(request, rc);
}
biosStringTable.load(response);
return response;
}
auto biosStrings = bios_parser::getStrings();
std::sort(biosStrings.begin(), biosStrings.end());
// remove all duplicate strings received from bios json
biosStrings.erase(std::unique(biosStrings.begin(), biosStrings.end()),
biosStrings.end());
size_t sizeWithoutPad = std::accumulate(
biosStrings.begin(), biosStrings.end(), 0,
[](size_t sum, const std::string& elem) {
return sum +
pldm_bios_table_string_entry_encode_length(elem.length());
});
Table stringTable;
stringTable.reserve(
pldm::responder::utils::getTableTotalsize(sizeWithoutPad));
stringTable.resize(sizeWithoutPad);
auto tablePtr = stringTable.data();
for (const auto& elem : biosStrings)
{
auto entry_length =
pldm_bios_table_string_entry_encode_length(elem.length());
pldm_bios_table_string_entry_encode(tablePtr, sizeWithoutPad,
elem.c_str(), elem.length());
tablePtr += entry_length;
sizeWithoutPad -= entry_length;
}
pldm::responder::utils::padAndChecksum(stringTable);
biosStringTable.store(stringTable);
response.resize(sizeof(pldm_msg_hdr) + PLDM_GET_BIOS_TABLE_MIN_RESP_BYTES +
stringTable.size(),
0);
responsePtr = reinterpret_cast<pldm_msg*>(response.data());
auto rc = encode_get_bios_table_resp(
request->hdr.instance_id, PLDM_SUCCESS, 0 /* nxtTransferHandle */,
PLDM_START_AND_END, stringTable.data(), response.size(), responsePtr);
if (rc != PLDM_SUCCESS)
{
return CmdHandler::ccOnlyResponse(request, rc);
}
return response;
}
namespace bios_type_enum
{
using namespace bios_parser::bios_enum;
/** @brief Find the indices into the array of the possible values of string
* handles for the current values.This is used in attribute value table
*
* @param[in] possiVals - vector of string handles comprising all the possible
* values for an attribute
* @param[in] currVals - vector of strings comprising all current values
* for an attribute
* @param[in] biosStringTable - the string table
*
* @return - std::vector<uint8_t> - indices into the array of the possible
* values of string handles
*/
std::vector<uint8_t> findStrIndices(PossibleValuesByHandle possiVals,
CurrentValues currVals,
const BIOSStringTable& biosStringTable)
{
std::vector<uint8_t> stringIndices;
for (const auto& currVal : currVals)
{
StringHandle curHdl;
try
{
curHdl = biosStringTable.findHandle(currVal);
}
catch (const std::exception& e)
{
std::cerr << "Exception fetching handle for the string, STRING="
<< currVal.c_str() << "\n";
continue;
}
uint8_t i = 0;
for (auto possiHdl : possiVals)
{
if (possiHdl == curHdl)
{
stringIndices.push_back(i);
break;
}
i++;
}
}
return stringIndices;
}
/** @brief Find the indices into the array of the possible values of string
* handles for the default values. This is used in attribute table
*
* @param[in] possiVals - vector of strings comprising all the possible values
* for an attribute
* @param[in] defVals - vector of strings comprising all the default values
* for an attribute
* @return - std::vector<uint8_t> - indices into the array of the possible
* values of string
*/
std::vector<uint8_t> findDefaultValHandle(const PossibleValues& possiVals,
const DefaultValues& defVals)
{
std::vector<uint8_t> defHdls;
for (const auto& defs : defVals)
{
auto index = std::find_if(possiVals.begin(), possiVals.end(),
[&defs](const auto& v) { return defs == v; });
if (index != possiVals.end())
{
defHdls.push_back(index - possiVals.begin());
}
}
return defHdls;
}
/** @brief Construct the attibute table for BIOS type Enumeration and
* Enumeration ReadOnly
* @param[in] biosStringTable - the string table
* @param[in] biosJsonDir - path where the BIOS json files are present
* @param[in,out] attributeTable - the attribute table
*
*/
void constructAttrTable(const BIOSStringTable& biosStringTable,
Table& attributeTable)
{
const auto& attributeMap = getValues();
StringHandle strHandle;
for (const auto& [key, value] : attributeMap)
{
try
{
strHandle = biosStringTable.findHandle(key);
}
catch (const std::exception& e)
{
std::cerr << "Could not find handle for BIOS string, ATTRIBUTE="
<< key.c_str() << "\n";
continue;
}
bool readOnly = (std::get<0>(value));
const PossibleValues& possiVals = std::get<1>(value);
const DefaultValues& defVals = std::get<2>(value);
std::vector<StringHandle> possiValsByHdl;
for (const auto& elem : possiVals)
{
try
{
auto hdl = biosStringTable.findHandle(elem);
possiValsByHdl.push_back(std::move(hdl));
}
catch (const std::exception& e)
{
std::cerr << "Could not find handle for BIOS string, STRING="
<< elem.c_str() << "\n";
continue;
}
}
auto defValsByHdl = findDefaultValHandle(possiVals, defVals);
auto entryLength = pldm_bios_table_attr_entry_enum_encode_length(
possiValsByHdl.size(), defValsByHdl.size());
auto attrTableSize = attributeTable.size();
attributeTable.resize(attrTableSize + entryLength, 0);
struct pldm_bios_table_attr_entry_enum_info info = {
strHandle,
readOnly,
(uint8_t)possiValsByHdl.size(),
possiValsByHdl.data(),
(uint8_t)defValsByHdl.size(),
defValsByHdl.data(),
};
pldm_bios_table_attr_entry_enum_encode(
attributeTable.data() + attrTableSize, entryLength, &info);
}
}
void constructAttrValueEntry(
const struct pldm_bios_attr_table_entry* attrTableEntry,
const std::string& attrName, const BIOSStringTable& biosStringTable,
Table& attrValueTable)
{
CurrentValues currVals;
try
{
currVals = getAttrValue(attrName);
}
catch (const std::exception& e)
{
std::cerr << "getAttrValue returned error for attribute, NAME="
<< attrName.c_str() << " ERROR=" << e.what() << "\n";
return;
}
uint8_t pv_num =
pldm_bios_table_attr_entry_enum_decode_pv_num(attrTableEntry);
PossibleValuesByHandle pvHdls(pv_num, 0);
pldm_bios_table_attr_entry_enum_decode_pv_hdls(attrTableEntry,
pvHdls.data(), pv_num);
std::sort(currVals.begin(), currVals.end());
auto currValStrIndices = findStrIndices(pvHdls, currVals, biosStringTable);
auto entryLength = pldm_bios_table_attr_value_entry_encode_enum_length(
currValStrIndices.size());
auto tableSize = attrValueTable.size();
attrValueTable.resize(tableSize + entryLength);
pldm_bios_table_attr_value_entry_encode_enum(
attrValueTable.data() + tableSize, entryLength,
attrTableEntry->attr_handle, attrTableEntry->attr_type,
currValStrIndices.size(), currValStrIndices.data());
}
} // end namespace bios_type_enum
namespace bios_type_string
{
using namespace bios_parser::bios_string;
/** @brief Construct the attibute table for BIOS type String and
* String ReadOnly
* @param[in] biosStringTable - the string table
* @param[in] biosJsonDir - path where the BIOS json files are present
* @param[in,out] attributeTable - the attribute table
*
*/
void constructAttrTable(const BIOSStringTable& biosStringTable,
Table& attributeTable)
{
const auto& attributeMap = getValues();
StringHandle strHandle;
for (const auto& [key, value] : attributeMap)
{
try
{
strHandle = biosStringTable.findHandle(key);
}
catch (const std::exception& e)
{
std::cerr << "Could not find handle for BIOS string, ATTRIBUTE="
<< key.c_str() << "\n";
continue;
}
const auto& [readOnly, strType, minStrLen, maxStrLen, defaultStrLen,
defaultStr] = value;
auto entryLength =
pldm_bios_table_attr_entry_string_encode_length(defaultStrLen);
struct pldm_bios_table_attr_entry_string_info info = {
strHandle, readOnly, strType, minStrLen,
maxStrLen, defaultStrLen, defaultStr.data(),
};
auto attrTableSize = attributeTable.size();
attributeTable.resize(attrTableSize + entryLength, 0);
pldm_bios_table_attr_entry_string_encode(
attributeTable.data() + attrTableSize, entryLength, &info);
}
}
void constructAttrValueEntry(const pldm_bios_attr_table_entry* attrTableEntry,
const std::string& attrName,
const BIOSStringTable& biosStringTable,
Table& attrValueTable)
{
std::ignore = biosStringTable;
std::string currStr;
uint16_t currStrLen = 0;
try
{
currStr = getAttrValue(attrName);
currStrLen = currStr.size();
}
catch (const std::exception& e)
{
std::cerr << "getAttrValue returned error for attribute, NAME="
<< attrName.c_str() << " ERROR=" << e.what() << "\n";
return;
}
auto entryLength =
pldm_bios_table_attr_value_entry_encode_string_length(currStrLen);
auto tableSize = attrValueTable.size();
attrValueTable.resize(tableSize + entryLength);
pldm_bios_table_attr_value_entry_encode_string(
attrValueTable.data() + tableSize, entryLength,
attrTableEntry->attr_handle, attrTableEntry->attr_type, currStrLen,
currStr.c_str());
}
} // end namespace bios_type_string
namespace bios_type_integer
{
using namespace bios_parser::bios_integer;
/** @brief Construct the attibute table for BIOS type Integer and
* Integer ReadOnly
* @param[in] biosStringTable - the string table
* @param[in,out] attributeTable - the attribute table
*
*/
void constructAttrTable(const BIOSStringTable& biosStringTable,
Table& attributeTable)
{
const auto& attributeMap = getValues();
StringHandle strHandle;
for (const auto& [key, value] : attributeMap)
{
try
{
strHandle = biosStringTable.findHandle(key);
}
catch (const std::exception& e)
{
std::cerr << "Could not find handle for BIOS string, ATTRIBUTE="
<< key.c_str() << "\n";
continue;
}
const auto& [readOnly, lowerBound, upperBound, scalarIncrement,
defaultValue] = value;
auto entryLength = pldm_bios_table_attr_entry_integer_encode_length();
struct pldm_bios_table_attr_entry_integer_info info = {
strHandle, readOnly, lowerBound,
upperBound, scalarIncrement, defaultValue,
};
auto attrTableSize = attributeTable.size();
attributeTable.resize(attrTableSize + entryLength, 0);
pldm_bios_table_attr_entry_integer_encode(
attributeTable.data() + attrTableSize, entryLength, &info);
}
}
void constructAttrValueEntry(const pldm_bios_attr_table_entry* attrTableEntry,
const std::string& attrName,
const BIOSStringTable& biosStringTable,
Table& attrValueTable)
{
std::ignore = biosStringTable;
uint64_t currentValue;
try
{
currentValue = getAttrValue(attrName);
}
catch (const std::exception& e)
{
std::cerr << "Failed to get attribute value, NAME=" << attrName.c_str()
<< " ERROR=" << e.what() << "\n";
return;
}
auto entryLength = pldm_bios_table_attr_value_entry_encode_integer_length();
auto tableSize = attrValueTable.size();
attrValueTable.resize(tableSize + entryLength);
pldm_bios_table_attr_value_entry_encode_integer(
attrValueTable.data() + tableSize, entryLength,
attrTableEntry->attr_handle, attrTableEntry->attr_type, currentValue);
}
} // namespace bios_type_integer
void traverseBIOSAttrTable(const Table& biosAttrTable,
AttrTableEntryHandler handler)
{
std::unique_ptr<pldm_bios_table_iter, decltype(&pldm_bios_table_iter_free)>
iter(pldm_bios_table_iter_create(biosAttrTable.data(),
biosAttrTable.size(),
PLDM_BIOS_ATTR_TABLE),
pldm_bios_table_iter_free);
while (!pldm_bios_table_iter_is_end(iter.get()))
{
auto table_entry = pldm_bios_table_iter_attr_entry_value(iter.get());
try
{
handler(table_entry);
}
catch (const std::exception& e)
{
std::cerr << "handler fails when traversing BIOSAttrTable, ERROR="
<< e.what() << "\n";
}
pldm_bios_table_iter_next(iter.get());
}
}
using typeHandler = std::function<void(const BIOSStringTable& biosStringTable,
Table& attributeTable)>;
std::map<BIOSJsonName, typeHandler> attrTypeHandlers{
{bios_parser::bIOSEnumJson, bios_type_enum::constructAttrTable},
{bios_parser::bIOSStrJson, bios_type_string::constructAttrTable},
{bios_parser::bIOSIntegerJson, bios_type_integer::constructAttrTable},
};
/** @brief Construct the BIOS attribute table
*
* @param[in,out] biosAttributeTable - the attribute table
* @param[in] biosStringTable - the string table
* @param[in] biosJsonDir - path where the BIOS json files are present
* @param[in] request - Request message
*/
Response getBIOSAttributeTable(BIOSTable& biosAttributeTable,
const BIOSStringTable& biosStringTable,
const char* biosJsonDir, const pldm_msg* request)
{
Response response(sizeof(pldm_msg_hdr) + PLDM_GET_BIOS_TABLE_MIN_RESP_BYTES,
0);
auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
uint32_t nxtTransferHandle = 0;
uint8_t transferFlag = PLDM_START_AND_END;
if (biosAttributeTable.isEmpty())
{ // no persisted table, constructing fresh table and response
Table attributeTable;
fs::path dir(biosJsonDir);
for (auto it = attrTypeHandlers.begin(); it != attrTypeHandlers.end();
it++)
{
fs::path file = dir / it->first;
if (fs::exists(file))
{
it->second(biosStringTable, attributeTable);
}
}
if (attributeTable.empty())
{ // no available json file is found
return CmdHandler::ccOnlyResponse(request,
PLDM_BIOS_TABLE_UNAVAILABLE);
}
pldm::responder::utils::padAndChecksum(attributeTable);
biosAttributeTable.store(attributeTable);
response.resize(sizeof(pldm_msg_hdr) +
PLDM_GET_BIOS_TABLE_MIN_RESP_BYTES +
attributeTable.size());
responsePtr = reinterpret_cast<pldm_msg*>(response.data());
auto rc = encode_get_bios_table_resp(
request->hdr.instance_id, PLDM_SUCCESS, nxtTransferHandle,
transferFlag, attributeTable.data(), response.size(), responsePtr);
if (rc != PLDM_SUCCESS)
{
return CmdHandler::ccOnlyResponse(request, rc);
}
}
else
{ // persisted table present, constructing response
auto rc = encode_get_bios_table_resp(
request->hdr.instance_id, PLDM_SUCCESS, nxtTransferHandle,
transferFlag, nullptr, response.size(),
responsePtr); // filling up the header here
if (rc != PLDM_SUCCESS)
{
return CmdHandler::ccOnlyResponse(request, rc);
}
biosAttributeTable.load(response);
}
return response;
}
using AttrValTableEntryConstructHandler =
std::function<void(const struct pldm_bios_attr_table_entry* tableEntry,
const std::string& attrName,
const BIOSStringTable& biosStringTable, Table& table)>;
using AttrType = uint8_t;
const std::map<AttrType, AttrValTableEntryConstructHandler>
AttrValTableConstructMap{
{PLDM_BIOS_STRING, bios_type_string::constructAttrValueEntry},
{PLDM_BIOS_STRING_READ_ONLY, bios_type_string::constructAttrValueEntry},
{PLDM_BIOS_ENUMERATION, bios_type_enum::constructAttrValueEntry},
{PLDM_BIOS_ENUMERATION_READ_ONLY,
bios_type_enum::constructAttrValueEntry},
{PLDM_BIOS_INTEGER, bios_type_integer::constructAttrValueEntry},
{PLDM_BIOS_INTEGER_READ_ONLY,
bios_type_integer::constructAttrValueEntry},
};
void constructAttrValueTableEntry(
const struct pldm_bios_attr_table_entry* attrEntry,
const BIOSStringTable& biosStringTable, Table& attributeValueTable)
{
auto stringHandle =
pldm_bios_table_attr_entry_decode_string_handle(attrEntry);
try
{
auto attrName = biosStringTable.findString(stringHandle);
AttrValTableConstructMap.at(attrEntry->attr_type)(
attrEntry, attrName, biosStringTable, attributeValueTable);
}
catch (const std::exception& e)
{
std::cerr << "constructAttrValueTableEntry Error: " << e.what()
<< std::endl;
}
}
/** @brief Construct the BIOS attribute value table
*
* @param[in,out] biosAttributeValueTable - the attribute value table
* @param[in] biosAttributeTable - the attribute table
* @param[in] biosStringTable - the string table
* @param[in] request - Request message
*/
Response getBIOSAttributeValueTable(BIOSTable& biosAttributeValueTable,
const BIOSTable& biosAttributeTable,
const BIOSStringTable& biosStringTable,
const pldm_msg* request)
{
Response response(sizeof(pldm_msg_hdr) + PLDM_GET_BIOS_TABLE_MIN_RESP_BYTES,
0);
auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
uint32_t nxtTransferHandle = 0;
uint8_t transferFlag = PLDM_START_AND_END;
if (!biosAttributeValueTable.isEmpty())
{
auto rc = encode_get_bios_table_resp(
request->hdr.instance_id, PLDM_SUCCESS, nxtTransferHandle,
transferFlag, nullptr, response.size(),
responsePtr); // filling up the header here
if (rc != PLDM_SUCCESS)
{
return CmdHandler::ccOnlyResponse(request, rc);
}
biosAttributeValueTable.load(response);
return response;
}
Table attributeValueTable;
Table attributeTable;
biosAttributeTable.load(attributeTable);
traverseBIOSAttrTable(
attributeTable,
[&biosStringTable, &attributeValueTable](
const struct pldm_bios_attr_table_entry* tableEntry) {
constructAttrValueTableEntry(tableEntry, biosStringTable,
attributeValueTable);
});
if (attributeValueTable.empty())
{
return CmdHandler::ccOnlyResponse(request, PLDM_BIOS_TABLE_UNAVAILABLE);
}
pldm::responder::utils::padAndChecksum(attributeValueTable);
biosAttributeValueTable.store(attributeValueTable);
response.resize(sizeof(pldm_msg_hdr) + PLDM_GET_BIOS_TABLE_MIN_RESP_BYTES +
attributeValueTable.size());
responsePtr = reinterpret_cast<pldm_msg*>(response.data());
auto rc = encode_get_bios_table_resp(
request->hdr.instance_id, PLDM_SUCCESS, nxtTransferHandle, transferFlag,
attributeValueTable.data(), response.size(), responsePtr);
if (rc != PLDM_SUCCESS)
{
return CmdHandler::ccOnlyResponse(request, rc);
}
return response;
}
Response Handler::getBIOSTable(const pldm_msg* request, size_t payloadLength)
{
fs::create_directory(BIOS_TABLES_DIR);
auto response = internal::buildBIOSTables(request, payloadLength,
BIOS_JSONS_DIR, BIOS_TABLES_DIR);
return response;
}
Response Handler::getBIOSAttributeCurrentValueByHandle(const pldm_msg* request,
size_t payloadLength)
{
uint32_t transferHandle;
uint8_t transferOpFlag;
uint16_t attributeHandle;
auto rc = decode_get_bios_attribute_current_value_by_handle_req(
request, payloadLength, &transferHandle, &transferOpFlag,
&attributeHandle);
if (rc != PLDM_SUCCESS)
{
return ccOnlyResponse(request, rc);
}
fs::path tablesPath(BIOS_TABLES_DIR);
auto stringTablePath = tablesPath / stringTableFile;
BIOSTable biosStringTable(stringTablePath.c_str());
auto attrTablePath = tablesPath / attrTableFile;
BIOSTable biosAttributeTable(attrTablePath.c_str());
if (biosAttributeTable.isEmpty() || biosStringTable.isEmpty())
{
return ccOnlyResponse(request, PLDM_BIOS_TABLE_UNAVAILABLE);
}
auto attrValueTablePath = tablesPath / attrValTableFile;
BIOSTable biosAttributeValueTable(attrValueTablePath.c_str());
if (biosAttributeValueTable.isEmpty())
{
Table attributeValueTable;
Table attributeTable;
biosAttributeTable.load(attributeTable);
traverseBIOSAttrTable(
attributeTable,
[&biosStringTable, &attributeValueTable](
const struct pldm_bios_attr_table_entry* tableEntry) {
constructAttrValueTableEntry(tableEntry, biosStringTable,
attributeValueTable);
});
if (attributeValueTable.empty())
{
return ccOnlyResponse(request, PLDM_BIOS_TABLE_UNAVAILABLE);
}
pldm::responder::utils::padAndChecksum(attributeValueTable);
biosAttributeValueTable.store(attributeValueTable);
}
Response table;
biosAttributeValueTable.load(table);
auto entry = pldm_bios_table_attr_value_find_by_handle(
table.data(), table.size(), attributeHandle);
if (entry == nullptr)
{
return ccOnlyResponse(request, PLDM_INVALID_BIOS_ATTR_HANDLE);
}
auto entryLength = pldm_bios_table_attr_value_entry_length(entry);
Response response(sizeof(pldm_msg_hdr) +
PLDM_GET_BIOS_ATTR_CURR_VAL_BY_HANDLE_MIN_RESP_BYTES +
entryLength,
0);
auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
rc = encode_get_bios_current_value_by_handle_resp(
request->hdr.instance_id, PLDM_SUCCESS, 0, PLDM_START_AND_END,
reinterpret_cast<const uint8_t*>(entry), entryLength, responsePtr);
if (rc != PLDM_SUCCESS)
{
return ccOnlyResponse(request, rc);
}
return response;
}
Response Handler::setBIOSAttributeCurrentValue(const pldm_msg* request,
size_t payloadLength)
{
uint32_t transferHandle;
uint8_t transferOpFlag;
variable_field attributeField;
auto rc = decode_set_bios_attribute_current_value_req(
request, payloadLength, &transferHandle, &transferOpFlag,
&attributeField);
if (rc != PLDM_SUCCESS)
{
return ccOnlyResponse(request, rc);
}
fs::path tablesPath(BIOS_TABLES_DIR);
auto stringTablePath = tablesPath / stringTableFile;
BIOSStringTable biosStringTable(stringTablePath.c_str());
auto attrTablePath = tablesPath / attrTableFile;
BIOSTable biosAttributeTable(attrTablePath.c_str());
auto attrValueTablePath = tablesPath / attrValTableFile;
BIOSTable biosAttributeValueTable(attrValueTablePath.c_str());
// TODO: Construct attribute value table if it's empty. (another commit)
Response srcTable;
biosAttributeValueTable.load(srcTable);
// Replace the old attribute with the new attribute, the size of table will
// change:
// sizeof(newTableBuffer) = srcTableSize + sizeof(newAttribute) -
// sizeof(oldAttribute) + pad(4-byte alignment, max =
// 3)
// For simplicity, we use
// sizeof(newTableBuffer) = srcTableSize + sizeof(newAttribute) + 3
size_t destBufferLength = srcTable.size() + attributeField.length + 3;
Response destTable(destBufferLength);
size_t destTableLen = destTable.size();
rc = pldm_bios_table_attr_value_copy_and_update(
srcTable.data(), srcTable.size(), destTable.data(), &destTableLen,
attributeField.ptr, attributeField.length);
destTable.resize(destTableLen);
if (rc != PLDM_SUCCESS)
{
return ccOnlyResponse(request, rc);
}
rc = setAttributeValueOnDbus(&attributeField, biosAttributeTable,
biosStringTable);
if (rc != PLDM_SUCCESS)
{
return ccOnlyResponse(request, rc);
}
biosAttributeValueTable.store(destTable);
return ccOnlyResponse(request, PLDM_SUCCESS);
}
namespace internal
{
Response buildBIOSTables(const pldm_msg* request, size_t payloadLength,
const char* biosJsonDir, const char* biosTablePath)
{
Response response(sizeof(pldm_msg_hdr) + PLDM_GET_BIOS_TABLE_MIN_RESP_BYTES,
0);
if (setupConfig(biosJsonDir) != 0)
{
return CmdHandler::ccOnlyResponse(request, PLDM_BIOS_TABLE_UNAVAILABLE);
}
uint32_t transferHandle{};
uint8_t transferOpFlag{};
uint8_t tableType{};
auto rc = decode_get_bios_table_req(request, payloadLength, &transferHandle,
&transferOpFlag, &tableType);
if (rc != PLDM_SUCCESS)
{
return CmdHandler::ccOnlyResponse(request, rc);
}
BIOSTable biosStringTable(
(std::string(biosTablePath) + "/" + stringTableFile).c_str());
BIOSTable biosAttributeTable(
(std::string(biosTablePath) + "/" + attrTableFile).c_str());
BIOSTable biosAttributeValueTable(
(std::string(biosTablePath) + "/" + attrValTableFile).c_str());
switch (tableType)
{
case PLDM_BIOS_STRING_TABLE:
{
try
{
fs::remove(fs::path(std::string(BIOS_TABLES_DIR) + "/" +
stringTableFile));
fs::remove(fs::path(std::string(BIOS_TABLES_DIR) + "/" +
attrTableFile));
fs::remove(fs::path(std::string(BIOS_TABLES_DIR) + "/" +
attrValTableFile));
}
catch (const std::exception& e)
{
}
response = getBIOSStringTable(biosStringTable, request);
}
break;
case PLDM_BIOS_ATTR_TABLE:
if (biosStringTable.isEmpty())
{
rc = PLDM_BIOS_TABLE_UNAVAILABLE;
}
else
{
response = getBIOSAttributeTable(
biosAttributeTable, biosStringTable, biosJsonDir, request);
}
break;
case PLDM_BIOS_ATTR_VAL_TABLE:
if (biosAttributeTable.isEmpty() || biosStringTable.isEmpty())
{
rc = PLDM_BIOS_TABLE_UNAVAILABLE;
}
else
{
response = getBIOSAttributeValueTable(biosAttributeValueTable,
biosAttributeTable,
biosStringTable, request);
}
break;
default:
rc = PLDM_INVALID_BIOS_TABLE_TYPE;
break;
}
if (rc != PLDM_SUCCESS)
{
return CmdHandler::ccOnlyResponse(request, rc);
}
return response;
}
} // namespace internal
} // namespace bios
} // namespace responder
} // namespace pldm