blob: 13a3ae5c823464db99b55a9e1961a88cb7a07e7b [file] [log] [blame]
/**
* Copyright © 2019 IBM 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.
*/
#include "src.hpp"
#include "json_utils.hpp"
#include "paths.hpp"
#include "pel_values.hpp"
#include <phosphor-logging/log.hpp>
namespace openpower
{
namespace pels
{
namespace pv = openpower::pels::pel_values;
namespace rg = openpower::pels::message;
using namespace phosphor::logging;
constexpr size_t ccinSize = 4;
void SRC::unflatten(Stream& stream)
{
stream >> _header >> _version >> _flags >> _reserved1B >> _wordCount >>
_reserved2B >> _size;
for (auto& word : _hexData)
{
stream >> word;
}
_asciiString = std::make_unique<src::AsciiString>(stream);
if (hasAdditionalSections())
{
// The callouts section is currently the only extra subsection type
_callouts = std::make_unique<src::Callouts>(stream);
}
}
void SRC::flatten(Stream& stream) const
{
stream << _header << _version << _flags << _reserved1B << _wordCount
<< _reserved2B << _size;
for (auto& word : _hexData)
{
stream << word;
}
_asciiString->flatten(stream);
if (_callouts)
{
_callouts->flatten(stream);
}
}
SRC::SRC(Stream& pel)
{
try
{
unflatten(pel);
validate();
}
catch (const std::exception& e)
{
log<level::ERR>("Cannot unflatten SRC", entry("ERROR=%s", e.what()));
_valid = false;
}
}
SRC::SRC(const message::Entry& regEntry, const AdditionalData& additionalData,
const DataInterfaceBase& dataIface)
{
_header.id = static_cast<uint16_t>(SectionID::primarySRC);
_header.version = srcSectionVersion;
_header.subType = srcSectionSubtype;
_header.componentID = regEntry.componentID;
_version = srcVersion;
_flags = 0;
if (regEntry.src.powerFault.value_or(false))
{
_flags |= powerFaultEvent;
}
_reserved1B = 0;
_wordCount = numSRCHexDataWords + 1;
_reserved2B = 0;
// There are multiple fields encoded in the hex data words.
std::for_each(_hexData.begin(), _hexData.end(),
[](auto& word) { word = 0; });
setBMCFormat();
setBMCPosition();
setMotherboardCCIN(dataIface);
// Partition dump status and partition boot type always 0 for BMC errors.
//
// TODO: Fill in other fields that aren't available yet.
// Fill in the last 4 words from the AdditionalData property contents.
setUserDefinedHexWords(regEntry, additionalData);
_asciiString = std::make_unique<src::AsciiString>(regEntry);
addCallouts(regEntry, additionalData, dataIface);
_size = baseSRCSize;
_size += _callouts ? _callouts->flattenedSize() : 0;
_header.size = Section::flattenedSize() + _size;
_valid = true;
}
void SRC::setUserDefinedHexWords(const message::Entry& regEntry,
const AdditionalData& ad)
{
if (!regEntry.src.hexwordADFields)
{
return;
}
// Save the AdditionalData value corresponding to the
// adName key in _hexData[wordNum].
for (const auto& [wordNum, adName] : *regEntry.src.hexwordADFields)
{
// Can only set words 6 - 9
if (!isUserDefinedWord(wordNum))
{
log<level::WARNING>("SRC user data word out of range",
entry("WORD_NUM=%d", wordNum),
entry("ERROR_NAME=%s", regEntry.name.c_str()));
continue;
}
auto value = ad.getValue(adName);
if (value)
{
_hexData[getWordIndexFromWordNum(wordNum)] =
std::strtoul(value.value().c_str(), nullptr, 0);
}
else
{
log<level::WARNING>("Source for user data SRC word not found",
entry("ADDITIONALDATA_KEY=%s", adName.c_str()),
entry("ERROR_NAME=%s", regEntry.name.c_str()));
}
}
}
void SRC::setMotherboardCCIN(const DataInterfaceBase& dataIface)
{
uint32_t ccin = 0;
auto ccinString = dataIface.getMotherboardCCIN();
try
{
if (ccinString.size() == ccinSize)
{
ccin = std::stoi(ccinString, 0, 16);
}
}
catch (std::exception& e)
{
log<level::WARNING>("Could not convert motherboard CCIN to a number",
entry("CCIN=%s", ccinString.c_str()));
return;
}
// Set the first 2 bytes
_hexData[1] |= ccin << 16;
}
void SRC::validate()
{
bool failed = false;
if ((header().id != static_cast<uint16_t>(SectionID::primarySRC)) &&
(header().id != static_cast<uint16_t>(SectionID::secondarySRC)))
{
log<level::ERR>("Invalid SRC section ID",
entry("ID=0x%X", header().id));
failed = true;
}
// Check the version in the SRC, not in the header
if (_version != srcVersion)
{
log<level::ERR>("Invalid SRC version", entry("VERSION=0x%X", _version));
failed = true;
}
_valid = failed ? false : true;
}
bool SRC::isBMCSRC() const
{
auto as = asciiString();
if (as.length() >= 2)
{
uint8_t errorType = strtoul(as.substr(0, 2).c_str(), nullptr, 16);
return (errorType == static_cast<uint8_t>(SRCType::bmcError) ||
errorType == static_cast<uint8_t>(SRCType::powerError));
}
return false;
}
std::optional<std::string> SRC::getErrorDetails(message::Registry& registry,
DetailLevel type,
bool toCache) const
{
const std::string jsonIndent(indentLevel, 0x20);
std::string errorOut;
if (isBMCSRC())
{
auto entry = registry.lookup("0x" + asciiString().substr(4, 4),
rg::LookupType::reasonCode, toCache);
if (entry)
{
errorOut.append(jsonIndent + "\"Error Details\": {\n");
auto errorMsg = getErrorMessage(*entry);
if (errorMsg)
{
if (type == DetailLevel::message)
{
return errorMsg.value();
}
else
{
jsonInsert(errorOut, "Message", errorMsg.value(), 2);
}
}
if (entry->src.hexwordADFields)
{
std::map<size_t, std::string> adFields =
entry->src.hexwordADFields.value();
for (const auto& hexwordMap : adFields)
{
jsonInsert(errorOut, hexwordMap.second,
getNumberString("0x%X",
_hexData[getWordIndexFromWordNum(
hexwordMap.first)]),
2);
}
}
errorOut.erase(errorOut.size() - 2);
errorOut.append("\n");
errorOut.append(jsonIndent + "},\n");
return errorOut;
}
}
return std::nullopt;
}
std::optional<std::string>
SRC::getErrorMessage(const message::Entry& regEntry) const
{
try
{
if (regEntry.doc.messageArgSources)
{
size_t msgLen = regEntry.doc.message.length();
char msg[msgLen + 1];
strcpy(msg, regEntry.doc.message.c_str());
std::vector<uint32_t> argSourceVals;
std::string message;
const auto& argValues = regEntry.doc.messageArgSources.value();
for (size_t i = 0; i < argValues.size(); ++i)
{
argSourceVals.push_back(_hexData[getWordIndexFromWordNum(
argValues[i].back() - '0')]);
}
const char* msgPointer = msg;
while (*msgPointer)
{
if (*msgPointer == '%')
{
msgPointer++;
size_t wordIndex = *msgPointer - '0';
if (isdigit(*msgPointer) && wordIndex >= 1 &&
static_cast<uint16_t>(wordIndex) <=
argSourceVals.size())
{
message.append(getNumberString(
"0x%X", argSourceVals[wordIndex - 1]));
}
else
{
message.append("%" + std::string(1, *msgPointer));
}
}
else
{
message.push_back(*msgPointer);
}
msgPointer++;
}
return message;
}
else
{
return regEntry.doc.message;
}
}
catch (const std::exception& e)
{
log<level::ERR>("Cannot get error message from registry entry",
entry("ERROR=%s", e.what()));
}
return std::nullopt;
}
std::optional<std::string> SRC::getCallouts() const
{
if (!_callouts)
{
return std::nullopt;
}
std::string printOut;
const std::string jsonIndent(indentLevel, 0x20);
const auto& callout = _callouts->callouts();
const auto& compDescrp = pv::failingComponentType;
printOut.append(jsonIndent + "\"Callout Section\": {\n");
jsonInsert(printOut, "Callout Count", std::to_string(callout.size()), 2);
printOut.append(jsonIndent + jsonIndent + "\"Callouts\": [");
for (auto& entry : callout)
{
printOut.append("{\n");
if (entry->fruIdentity())
{
jsonInsert(
printOut, "FRU Type",
compDescrp.at(entry->fruIdentity()->failingComponentType()), 3);
jsonInsert(printOut, "Priority",
pv::getValue(entry->priority(),
pel_values::calloutPriorityValues),
3);
if (!entry->locationCode().empty())
{
jsonInsert(printOut, "Location Code", entry->locationCode(), 3);
}
if (entry->fruIdentity()->getPN().has_value())
{
jsonInsert(printOut, "Part Number",
entry->fruIdentity()->getPN().value(), 3);
}
if (entry->fruIdentity()->getMaintProc().has_value())
{
jsonInsert(printOut, "Procedure Number",
entry->fruIdentity()->getMaintProc().value(), 3);
if (pv::procedureDesc.find(
entry->fruIdentity()->getMaintProc().value()) !=
pv::procedureDesc.end())
{
jsonInsert(
printOut, "Description",
pv::procedureDesc.at(
entry->fruIdentity()->getMaintProc().value()),
3);
}
}
if (entry->fruIdentity()->getCCIN().has_value())
{
jsonInsert(printOut, "CCIN",
entry->fruIdentity()->getCCIN().value(), 3);
}
if (entry->fruIdentity()->getSN().has_value())
{
jsonInsert(printOut, "Serial Number",
entry->fruIdentity()->getSN().value(), 3);
}
}
if (entry->pceIdentity())
{
const auto& pceIdentMtms = entry->pceIdentity()->mtms();
if (!pceIdentMtms.machineTypeAndModel().empty())
{
jsonInsert(printOut, "PCE MTMS",
pceIdentMtms.machineTypeAndModel() + "_" +
pceIdentMtms.machineSerialNumber(),
3);
}
if (!entry->pceIdentity()->enclosureName().empty())
{
jsonInsert(printOut, "PCE Name",
entry->pceIdentity()->enclosureName(), 3);
}
}
if (entry->mru())
{
const auto& mruCallouts = entry->mru()->mrus();
std::string mruId;
for (auto& element : mruCallouts)
{
if (!mruId.empty())
{
mruId.append(", " + getNumberString("%08X", element.id));
}
else
{
mruId.append(getNumberString("%08X", element.id));
}
}
jsonInsert(printOut, "MRU Id", mruId, 3);
}
printOut.erase(printOut.size() - 2);
printOut.append("\n" + jsonIndent + jsonIndent + "}, ");
};
printOut.erase(printOut.size() - 2);
printOut.append("]\n" + jsonIndent + "}");
return printOut;
}
std::optional<std::string> SRC::getJSON(message::Registry& registry) const
{
std::string ps;
jsonInsert(ps, pv::sectionVer, getNumberString("%d", _header.version), 1);
jsonInsert(ps, pv::subSection, getNumberString("%d", _header.subType), 1);
jsonInsert(ps, pv::createdBy, getNumberString("0x%X", _header.componentID),
1);
jsonInsert(ps, "SRC Version", getNumberString("0x%02X", _version), 1);
jsonInsert(ps, "SRC Format", getNumberString("0x%02X", _hexData[0] & 0xFF),
1);
jsonInsert(ps, "Virtual Progress SRC",
pv::boolString.at(_flags & virtualProgressSRC), 1);
jsonInsert(ps, "I5/OS Service Event Bit",
pv::boolString.at(_flags & i5OSServiceEventBit), 1);
jsonInsert(ps, "Hypervisor Dump Initiated",
pv::boolString.at(_flags & hypDumpInit), 1);
jsonInsert(ps, "Power Control Net Fault",
pv::boolString.at(isPowerFaultEvent()), 1);
if (isBMCSRC())
{
std::string ccinString;
uint32_t ccin = _hexData[1] >> 16;
if (ccin)
{
ccinString = getNumberString("%04X", ccin);
}
// The PEL spec calls it a backplane, so call it that here.
jsonInsert(ps, "Backplane CCIN", ccinString, 1);
}
auto errorDetails = getErrorDetails(registry, DetailLevel::json, true);
if (errorDetails)
{
ps.append(errorDetails.value());
}
jsonInsert(ps, "Valid Word Count", getNumberString("0x%02X", _wordCount),
1);
std::string refcode = asciiString();
std::string extRefcode;
size_t pos = refcode.find(0x20);
if (pos != std::string::npos)
{
size_t nextPos = refcode.find_first_not_of(0x20, pos);
if (nextPos != std::string::npos)
{
extRefcode = trimEnd(refcode.substr(nextPos));
}
refcode.erase(pos);
}
jsonInsert(ps, "Reference Code", refcode, 1);
if (!extRefcode.empty())
{
jsonInsert(ps, "Extended Reference Code", extRefcode, 1);
}
for (size_t i = 2; i <= _wordCount; i++)
{
jsonInsert(
ps, "Hex Word " + std::to_string(i),
getNumberString("%08X", _hexData[getWordIndexFromWordNum(i)]), 1);
}
auto calloutJson = getCallouts();
if (calloutJson)
{
ps.append(calloutJson.value());
}
else
{
ps.erase(ps.size() - 2);
}
return ps;
}
void SRC::addCallouts(const message::Entry& regEntry,
const AdditionalData& additionalData,
const DataInterfaceBase& dataIface)
{
auto item = additionalData.getValue("CALLOUT_INVENTORY_PATH");
if (item)
{
addInventoryCallout(*item, dataIface);
}
// TODO: CALLOUT_DEVICE_PATH
if (regEntry.callouts)
{
addRegistryCallouts(regEntry, additionalData, dataIface);
}
}
void SRC::addInventoryCallout(const std::string& inventoryPath,
const DataInterfaceBase& dataIface)
{
std::string locCode;
std::string fn;
std::string ccin;
std::string sn;
std::unique_ptr<src::Callout> callout;
try
{
locCode = dataIface.getLocationCode(inventoryPath);
try
{
dataIface.getHWCalloutFields(inventoryPath, fn, ccin, sn);
callout = std::make_unique<src::Callout>(CalloutPriority::high,
locCode, fn, ccin, sn);
}
catch (const SdBusError& e)
{
std::string msg = "No VPD found for " + inventoryPath;
log<level::WARNING>(msg.c_str(), entry("ERROR=%s", e.what()));
// Just create the callout with empty FRU fields
callout = std::make_unique<src::Callout>(CalloutPriority::high,
locCode, fn, ccin, sn);
}
}
catch (const SdBusError& e)
{
std::string msg = "Could not get location code for " + inventoryPath;
log<level::WARNING>(msg.c_str(), entry("ERROR=%s", e.what()));
// If this were to happen, people would have to look in the UserData
// section that contains CALLOUT_INVENTORY_PATH to see what failed.
callout = std::make_unique<src::Callout>(CalloutPriority::high,
"no_vpd_for_fru");
}
createCalloutsObject();
_callouts->addCallout(std::move(callout));
}
void SRC::addRegistryCallouts(const message::Entry& regEntry,
const AdditionalData& additionalData,
const DataInterfaceBase& dataIface)
{
try
{
auto systemNames = dataIface.getSystemNames();
auto regCallouts = message::Registry::getCallouts(
regEntry.callouts.value(), systemNames, additionalData);
for (const auto& regCallout : regCallouts)
{
addRegistryCallout(regCallout, dataIface);
}
}
catch (std::exception& e)
{
log<level::ERR>("Error parsing PEL message registry callout JSON",
entry("ERROR=%s", e.what()));
}
}
void SRC::addRegistryCallout(const message::RegistryCallout& regCallout,
const DataInterfaceBase& dataIface)
{
std::unique_ptr<src::Callout> callout;
// TODO: expand this location code.
auto locCode = regCallout.locCode;
// Via the PEL values table, get the priority enum.
// The schema will have validated the priority was a valid value.
auto priorityIt =
pv::findByName(regCallout.priority, pv::calloutPriorityValues);
assert(priorityIt != pv::calloutPriorityValues.end());
auto priority =
static_cast<CalloutPriority>(std::get<pv::fieldValuePos>(*priorityIt));
if (!regCallout.procedure.empty())
{
// Procedure callout
callout =
std::make_unique<src::Callout>(priority, regCallout.procedure);
}
else if (!regCallout.symbolicFRU.empty())
{
// Symbolic FRU callout
callout = std::make_unique<src::Callout>(
priority, regCallout.symbolicFRU, locCode, false);
}
else if (!regCallout.symbolicFRUTrusted.empty())
{
// Symbolic FRU with trusted location code callout
// The registry wants it to be trusted, but that requires a valid
// location code for it to actually be.
callout = std::make_unique<src::Callout>(
priority, regCallout.symbolicFRUTrusted, locCode, !locCode.empty());
}
else
{
// TODO: HW callouts
}
if (callout)
{
createCalloutsObject();
_callouts->addCallout(std::move(callout));
}
}
} // namespace pels
} // namespace openpower