blob: 51ded24b412b3b3dd4f4bdeed6f38be92d44a4f1 [file] [log] [blame]
#pragma once
#include "additional_data.hpp"
#include "ascii_string.hpp"
#include "callouts.hpp"
#include "data_interface.hpp"
#include "pel_types.hpp"
#include "registry.hpp"
#include "section.hpp"
#include "stream.hpp"
namespace openpower
{
namespace pels
{
constexpr uint8_t srcSectionVersion = 0x01;
constexpr uint8_t srcSectionSubtype = 0x01;
constexpr size_t numSRCHexDataWords = 8;
constexpr uint8_t srcVersion = 0x02;
constexpr uint8_t bmcSRCFormat = 0x55;
constexpr uint8_t primaryBMCPosition = 0x10;
constexpr size_t baseSRCSize = 72;
enum class DetailLevel
{
message = 0x01,
json = 0x02
};
/**
* @class SRC
*
* SRC stands for System Reference Code.
*
* This class represents the SRC sections in the PEL, of which there are 2:
* primary SRC and secondary SRC. These are the same structurally, the
* difference is that the primary SRC must be the 3rd section in the PEL if
* present and there is only one of them, and the secondary SRC sections are
* optional and there can be more than one (by definition, for there to be a
* secondary SRC, a primary SRC must also exist).
*
* This section consists of:
* - An 8B header (Has the version, flags, hexdata word count, and size fields)
* - 8 4B words of hex data
* - An ASCII character string
* - An optional subsection for Callouts
*/
class SRC : public Section
{
public:
enum HeaderFlags
{
additionalSections = 0x01,
powerFaultEvent = 0x02,
hypDumpInit = 0x04,
i5OSServiceEventBit = 0x10,
virtualProgressSRC = 0x80
};
SRC() = delete;
~SRC() = default;
SRC(const SRC&) = delete;
SRC& operator=(const SRC&) = delete;
SRC(SRC&&) = delete;
SRC& operator=(SRC&&) = delete;
/**
* @brief Constructor
*
* Fills in this class's data fields from the stream.
*
* @param[in] pel - the PEL data stream
*/
explicit SRC(Stream& pel);
/**
* @brief Constructor
*
* Creates the section with data from the PEL message registry entry for
* this error, along with the AdditionalData property contents from the
* corresponding event log.
*
* @param[in] regEntry - The message registry entry for this event log
* @param[in] additionalData - The AdditionalData properties in this event
* log
* @param[in] dataIface - The DataInterface object
*/
SRC(const message::Entry& regEntry, const AdditionalData& additionalData,
const DataInterfaceBase& dataIface);
/**
* @brief Flatten the section into the stream
*
* @param[in] stream - The stream to write to
*/
void flatten(Stream& stream) const override;
/**
* @brief Returns the SRC version, which is a different field
* than the version byte in the section header.
*
* @return uint8_t
*/
uint8_t version() const
{
return _version;
}
/**
* @brief Returns the flags byte
*
* @return uint8_t
*/
uint8_t flags() const
{
return _flags;
}
/**
* @brief Returns the hex data word count.
*
* Even though there always 8 words, this returns 9 due to previous
* SRC version formats.
*
* @return uint8_t
*/
uint8_t hexWordCount() const
{
return _wordCount;
}
/**
* @brief Returns the size of the SRC section, not including the header.
*
* @return uint16_t
*/
uint16_t size() const
{
return _size;
}
/**
* @brief Returns the 8 hex data words.
*
* @return const std::array<uint32_t, numSRCHexDataWords>&
*/
const std::array<uint32_t, numSRCHexDataWords>& hexwordData() const
{
return _hexData;
}
/**
* @brief Returns the ASCII string
*
* @return std::string
*/
std::string asciiString() const
{
return _asciiString->get();
}
/**
* @brief Returns the callouts subsection
*
* If no callouts, this unique_ptr will be empty
*
* @return const std::unique_ptr<src::Callouts>&
*/
const std::unique_ptr<src::Callouts>& callouts() const
{
return _callouts;
}
/**
* @brief Returns the size of this section when flattened into a PEL
*
* @return size_t - the size of the section
*/
size_t flattenedSize() const
{
return _header.size;
}
/**
* @brief Says if this SRC has additional subsections in it
*
* Note: The callouts section is the only possible subsection.
*
* @return bool
*/
inline bool hasAdditionalSections() const
{
return _flags & additionalSections;
}
/**
* @brief Indicates if this event log is for a power fault.
*
* This comes from a field in the message registry for BMC
* generated PELs.
*
* @return bool
*/
inline bool isPowerFaultEvent() const
{
return _flags & powerFaultEvent;
}
/**
* @brief Get the _hexData[] index to use based on the corresponding
* SRC word number.
*
* Converts the specification nomenclature to this data structure.
* See the _hexData documentation below for more information.
*
* @param[in] wordNum - The SRC word number, as defined by the spec.
*
* @return size_t The corresponding index into _hexData.
*/
inline size_t getWordIndexFromWordNum(size_t wordNum) const
{
assert(wordNum >= 2 && wordNum <= 9);
return wordNum - 2;
}
/**
* @brief Get section in JSON.
* @param[in] registry - Registry object reference
* @return std::optional<std::string> - SRC section's JSON
*/
std::optional<std::string>
getJSON(message::Registry& registry) const override;
/**
* @brief Get error details based on refcode and hexwords
* @param[in] registry - Registry object
* @param[in] type - detail level enum value : single message or full json
* @param[in] toCache - boolean to cache registry in memory, default=false
* @return std::optional<std::string> - Error details
*/
std::optional<std::string> getErrorDetails(message::Registry& registry,
DetailLevel type,
bool toCache = false) const;
/**
* @brief Says if this SRC was created by the BMC (i.e. this code).
*
* @return bool - If created by the BMC or not
*/
bool isBMCSRC() const;
private:
/**
* @brief Fills in the user defined hex words from the
* AdditionalData fields.
*
* When creating this section from a message registry entry,
* that entry has a field that says which AdditionalData property
* fields to use to fill in the user defined hex data words 6-9
* (which correspond to hexData words 4-7).
*
* For example, given that AdditionalData is a map of string keys
* to string values, find the AdditionalData value for AdditionalData
* key X, convert it to a uint32_t, and save it in user data word Y.
*
* @param[in] regEntry - The message registry entry for the error
* @param[in] additionalData - The AdditionalData map
*/
void setUserDefinedHexWords(const message::Entry& regEntry,
const AdditionalData& additionalData);
/**
* @brief Fills in the object from the stream data
*
* @param[in] stream - The stream to read from
*/
void unflatten(Stream& stream);
/**
* @brief Says if the word number is in the range of user defined words.
*
* This is only used for BMC generated SRCs, where words 6 - 9 are the
* user defined ones, meaning that setUserDefinedHexWords() will be
* used to fill them in based on the contents of the OpenBMC event log.
*
* @param[in] wordNum - The SRC word number, as defined by the spec.
*
* @return bool - If this word number can be filled in by the creator.
*/
inline bool isUserDefinedWord(size_t wordNum) const
{
return (wordNum >= 6) && (wordNum <= 9);
}
/**
* @brief Sets the SRC format byte in the hex word data.
*/
inline void setBMCFormat()
{
_hexData[0] |= bmcSRCFormat;
}
/**
* @brief Sets the hex word field that specifies which BMC
* (primary vs backup) created the error.
*
* Can be hardcoded until there are systems with redundant BMCs.
*/
inline void setBMCPosition()
{
_hexData[1] |= primaryBMCPosition;
}
/**
* @brief Sets the motherboard CCIN hex word field
*
* @param[in] dataIface - The DataInterface object
*/
void setMotherboardCCIN(const DataInterfaceBase& dataIface);
/**
* @brief Validates the section contents
*
* Updates _valid (in Section) with the results.
*/
void validate() override;
/**
* @brief Get error description from message registry
* @param[in] regEntry - The message registry entry for the error
* @return std::optional<std::string> - Error message
*/
std::optional<std::string>
getErrorMessage(const message::Entry& regEntry) const;
/**
* @brief Get Callout info in JSON
* @return std::optional<std::string> - Callout details
*/
std::optional<std::string> getCallouts() const;
/**
* @brief The SRC version field
*/
uint8_t _version;
/**
* @brief The SRC flags field
*/
uint8_t _flags;
/**
* @brief A byte of reserved data after the flags field
*/
uint8_t _reserved1B;
/**
* @brief The hex data word count.
*
* To be compatible with previous versions of SRCs, this is
* number of hex words (8) + 1 = 9.
*/
uint8_t _wordCount;
/**
* @brief Two bytes of reserved data after the hex word count
*/
uint16_t _reserved2B;
/**
* @brief The total size of the SRC section, not including the section
* header.
*/
uint16_t _size;
/**
* @brief The SRC 'hex words'.
*
* In the spec these are referred to as SRC words 2 - 9 as words 0 and 1
* are filled by the 8 bytes of fields from above.
*/
std::array<uint32_t, numSRCHexDataWords> _hexData;
/**
* @brief The 32 byte ASCII character string of the SRC
*
* It is padded with spaces to fill the 32 bytes.
* An example is:
* "BD8D1234 "
*
* That first word is what is commonly referred to as the refcode, and
* sometimes also called an SRC.
*/
std::unique_ptr<src::AsciiString> _asciiString;
/**
* @brief The callouts subsection.
*
* Optional and only created if there are callouts.
*/
std::unique_ptr<src::Callouts> _callouts;
};
} // namespace pels
} // namespace openpower