diff options
Diffstat (limited to 'extensions/openpower-pels')
-rw-r--r-- | extensions/openpower-pels/manager.cpp | 1 | ||||
-rw-r--r-- | extensions/openpower-pels/manager.hpp | 18 | ||||
-rw-r--r-- | extensions/openpower-pels/openpower-pels.mk | 1 | ||||
-rw-r--r-- | extensions/openpower-pels/paths.cpp | 6 | ||||
-rw-r--r-- | extensions/openpower-pels/paths.hpp | 4 | ||||
-rw-r--r-- | extensions/openpower-pels/registry.cpp | 195 | ||||
-rw-r--r-- | extensions/openpower-pels/registry.hpp | 179 |
7 files changed, 397 insertions, 7 deletions
diff --git a/extensions/openpower-pels/manager.cpp b/extensions/openpower-pels/manager.cpp index ef071bd..fd3670c 100644 --- a/extensions/openpower-pels/manager.cpp +++ b/extensions/openpower-pels/manager.cpp @@ -110,6 +110,7 @@ void Manager::createPEL(const std::string& message, uint32_t obmcLogID, const std::vector<std::string>& additionalData, const std::vector<std::string>& associations) { + // TODO: look up the error in _registry and create a PEL } } // namespace pels diff --git a/extensions/openpower-pels/manager.hpp b/extensions/openpower-pels/manager.hpp index 49ac8bf..5f092f4 100644 --- a/extensions/openpower-pels/manager.hpp +++ b/extensions/openpower-pels/manager.hpp @@ -3,6 +3,7 @@ #include "data_interface.hpp" #include "log_manager.hpp" #include "paths.hpp" +#include "registry.hpp" #include "repository.hpp" namespace openpower @@ -10,8 +11,6 @@ namespace openpower namespace pels { -using namespace phosphor::logging; - /** * @brief PEL manager object */ @@ -33,7 +32,9 @@ class Manager explicit Manager(phosphor::logging::internal::Manager& logManager, std::unique_ptr<DataInterfaceBase>&& dataIface) : _logManager(logManager), - _repo(getPELRepoPath()), _dataIface(std::move(dataIface)) + _repo(getPELRepoPath()), + _registry(getMessageRegistryPath() / message::registryFileName), + _dataIface(std::move(dataIface)) { } @@ -50,7 +51,7 @@ class Manager * @param[in] associations - the Associations property */ void create(const std::string& message, uint32_t obmcLogID, - uint64_t timestamp, Entry::Level severity, + uint64_t timestamp, phosphor::logging::Entry::Level severity, const std::vector<std::string>& additionalData, const std::vector<std::string>& associations); @@ -93,14 +94,14 @@ class Manager * @param[in] associations - The associations property */ void createPEL(const std::string& message, uint32_t obmcLogID, - uint64_t timestamp, Entry::Level severity, + uint64_t timestamp, phosphor::logging::Entry::Level severity, const std::vector<std::string>& additionalData, const std::vector<std::string>& associations); /** * @brief Reference to phosphor-logging's Manager class */ - internal::Manager& _logManager; + phosphor::logging::internal::Manager& _logManager; /** * @brief The PEL repository object @@ -108,6 +109,11 @@ class Manager Repository _repo; /** + * @brief The PEL message registry object + */ + message::Registry _registry; + + /** * @brief The API the PEL sections use to gather data */ std::unique_ptr<DataInterfaceBase> _dataIface; diff --git a/extensions/openpower-pels/openpower-pels.mk b/extensions/openpower-pels/openpower-pels.mk index 14e1966..aa69a2e 100644 --- a/extensions/openpower-pels/openpower-pels.mk +++ b/extensions/openpower-pels/openpower-pels.mk @@ -10,5 +10,6 @@ phosphor_log_manager_SOURCES += \ extensions/openpower-pels/pel.cpp \ extensions/openpower-pels/pel_values.cpp \ extensions/openpower-pels/private_header.cpp \ + extensions/openpower-pels/registry.cpp \ extensions/openpower-pels/repository.cpp \ extensions/openpower-pels/user_header.cpp diff --git a/extensions/openpower-pels/paths.cpp b/extensions/openpower-pels/paths.cpp index 27e7373..b8ccfe8 100644 --- a/extensions/openpower-pels/paths.cpp +++ b/extensions/openpower-pels/paths.cpp @@ -25,6 +25,10 @@ fs::path getPELRepoPath() return repoPath; } -} // namespace pels +fs::path getMessageRegistryPath() +{ + return std::filesystem::path{"/usr/share/phosphor-logging/pels"}; +} +} // namespace pels } // namespace openpower diff --git a/extensions/openpower-pels/paths.hpp b/extensions/openpower-pels/paths.hpp index 64566d2..91d8c5f 100644 --- a/extensions/openpower-pels/paths.hpp +++ b/extensions/openpower-pels/paths.hpp @@ -16,5 +16,9 @@ std::filesystem::path getPELIDFile(); */ std::filesystem::path getPELRepoPath(); +/** + * @brief Returns the path to the message registry JSON file + */ +std::filesystem::path getMessageRegistryPath(); } // namespace pels } // namespace openpower diff --git a/extensions/openpower-pels/registry.cpp b/extensions/openpower-pels/registry.cpp new file mode 100644 index 0000000..42ced0c --- /dev/null +++ b/extensions/openpower-pels/registry.cpp @@ -0,0 +1,195 @@ +#include "registry.hpp" + +#include "pel_types.hpp" +#include "pel_values.hpp" + +#include <fstream> +#include <phosphor-logging/log.hpp> + +namespace openpower +{ +namespace pels +{ +namespace message +{ + +namespace pv = pel_values; +namespace fs = std::filesystem; +using namespace phosphor::logging; + +constexpr auto debugFilePath = "/etc/phosphor-logging/"; + +namespace helper +{ + +uint8_t getSubsystem(const std::string& subsystemName) +{ + // Get the actual value to use in the PEL for the string name + auto ss = pv::findByName(subsystemName, pv::subsystemValues); + if (ss == pv::subsystemValues.end()) + { + // Schema validation should be catching this. + log<level::ERR>("Invalid subsystem name used in message registry", + entry("SUBSYSTEM=%s", subsystemName.c_str())); + + throw std::runtime_error("Invalid subsystem used in message registry"); + } + + return std::get<pv::fieldValuePos>(*ss); +} + +uint8_t getSeverity(const std::string& severityName) +{ + auto s = pv::findByName(severityName, pv::severityValues); + if (s == pv::severityValues.end()) + { + // Schema validation should be catching this. + log<level::ERR>("Invalid severity name used in message registry", + entry("SEVERITY=%s", severityName.c_str())); + + throw std::runtime_error("Invalid severity used in message registry"); + } + + return std::get<pv::fieldValuePos>(*s); +} + +uint16_t getActionFlags(const std::vector<std::string>& flags) +{ + uint16_t actionFlags = 0; + + // Make the bitmask based on the array of flag names + for (const auto& flag : flags) + { + auto s = pv::findByName(flag, pv::actionFlagsValues); + if (s == pv::actionFlagsValues.end()) + { + // Schema validation should be catching this. + log<level::ERR>("Invalid action flag name used in message registry", + entry("FLAG=%s", flag.c_str())); + + throw std::runtime_error( + "Invalid action flag used in message registry"); + } + + actionFlags |= std::get<pv::fieldValuePos>(*s); + } + + return actionFlags; +} + +uint8_t getEventType(const std::string& eventTypeName) +{ + auto t = pv::findByName(eventTypeName, pv::eventTypeValues); + if (t == pv::eventTypeValues.end()) + { + log<level::ERR>("Invalid event type used in message registry", + entry("EVENT_TYPE=%s", eventTypeName.c_str())); + + throw std::runtime_error("Invalid event type used in message registry"); + } + return std::get<pv::fieldValuePos>(*t); +} + +uint8_t getEventScope(const std::string& eventScopeName) +{ + auto s = pv::findByName(eventScopeName, pv::eventScopeValues); + if (s == pv::eventScopeValues.end()) + { + log<level::ERR>("Invalid event scope used in registry", + entry("EVENT_SCOPE=%s", eventScopeName.c_str())); + + throw std::runtime_error( + "Invalid event scope used in message registry"); + } + return std::get<pv::fieldValuePos>(*s); +} + +} // namespace helper + +std::optional<Entry> Registry::lookup(const std::string& name) +{ + // Look in /etc first in case someone put a test file there + fs::path debugFile{fs::path{debugFilePath} / registryFileName}; + nlohmann::json registry; + std::ifstream file; + + if (fs::exists(debugFile)) + { + log<level::INFO>("Using debug PEL message registry"); + file.open(debugFile); + } + else + { + file.open(_registryFile); + } + + try + { + registry = nlohmann::json::parse(file); + } + catch (std::exception& e) + { + log<level::ERR>("Error parsing message registry JSON", + entry("JSON_ERROR=%s", e.what())); + return std::nullopt; + } + + // Find an entry with this name in the PEL array. + auto e = std::find_if(registry["PELs"].begin(), registry["PELs"].end(), + [&name](const auto& j) { return name == j["Name"]; }); + + if (e != registry["PELs"].end()) + { + // Fill in the Entry structure from the JSON. Most, but not all, fields + // are optional. + + try + { + Entry entry; + entry.name = (*e)["Name"]; + entry.subsystem = helper::getSubsystem((*e)["Subsystem"]); + entry.actionFlags = helper::getActionFlags((*e)["ActionFlags"]); + + if (e->find("MfgActionFlags") != e->end()) + { + entry.mfgActionFlags = + helper::getActionFlags((*e)["MfgActionFlags"]); + } + + if (e->find("Severity") != e->end()) + { + entry.severity = helper::getSeverity((*e)["Severity"]); + } + + if (e->find("MfgSeverity") != e->end()) + { + entry.mfgSeverity = helper::getSeverity((*e)["MfgSeverity"]); + } + + if (e->find("EventType") != e->end()) + { + entry.eventType = helper::getEventType((*e)["EventType"]); + } + + if (e->find("EventScope") != e->end()) + { + entry.eventScope = helper::getEventScope((*e)["EventScope"]); + } + + // TODO: SRC fields + + return entry; + } + catch (std::exception& e) + { + log<level::ERR>("Found invalid message registry field", + entry("ERROR=%s", e.what())); + } + } + + return std::nullopt; +} + +} // namespace message +} // namespace pels +} // namespace openpower diff --git a/extensions/openpower-pels/registry.hpp b/extensions/openpower-pels/registry.hpp new file mode 100644 index 0000000..e56bd42 --- /dev/null +++ b/extensions/openpower-pels/registry.hpp @@ -0,0 +1,179 @@ +#pragma once +#include <filesystem> +#include <nlohmann/json.hpp> +#include <optional> +#include <string> +#include <vector> + +namespace openpower +{ +namespace pels +{ +namespace message +{ + +constexpr auto registryFileName = "message_registry.json"; + +/** + * @brief Represents a message registry entry, which is used for creating a + * PEL from an OpenBMC event log. + */ +struct Entry +{ + /** + * @brief The error name, like "xyz.openbmc_project.Error.Foo". + */ + std::string name; + + /** + * @brief The PEL subsystem field. + */ + uint8_t subsystem; + + /** + * @brief The optional PEL severity field. If not specified, the PEL + * will use the severity of the OpenBMC event log. + */ + std::optional<uint8_t> severity; + + /** + * @brief The optional severity field to use when in manufacturing tolerance + * mode. + */ + std::optional<uint8_t> mfgSeverity; + + /** + * @brief The PEL action flags field. + */ + uint16_t actionFlags; + + /** + * @brief The optional action flags to use instead when in manufacturing + * tolerance mode. + */ + std::optional<uint16_t> mfgActionFlags; + + /** + * @brief The PEL event type field. If not specified, higher level code + * will decide the value. + */ + std::optional<uint8_t> eventType; + + /** + * @brief The PEL event scope field. If not specified, higher level code + * will decide the value. + */ + std::optional<uint8_t> eventScope; + + // TODO: SRC related fields +}; + +/** + * @class Registry + * + * This class wraps the message registry JSON data and allows one to find + * the message registry entry pertaining to the error name. + * + * So that new registry files can easily be tested, the code will look for + * /etc/phosphor-logging/message_registry.json before looking for the real + * path. + */ +class Registry +{ + public: + Registry() = delete; + ~Registry() = default; + Registry(const Registry&) = default; + Registry& operator=(const Registry&) = default; + Registry(Registry&&) = default; + Registry& operator=(Registry&&) = default; + + /** + * @brief Constructor + * @param[in] registryFile - The path to the file. + */ + explicit Registry(const std::filesystem::path& registryFile) : + _registryFile(registryFile) + { + } + + /** + * @brief Find a registry entry based on its error name. + * + * This function does do some basic sanity checking on the JSON contents, + * but there is also an external program that enforces a schema on the + * registry JSON that should catch all of these problems ahead of time. + * + * @param[in] name - The error name, like xyz.openbmc_project.Error.Foo + * + * @return optional<Entry> A filled in message registry structure if + * found, otherwise an empty optional object. + */ + std::optional<Entry> lookup(const std::string& name); + + private: + /** + * @brief The path to the registry JSON file. + */ + std::filesystem::path _registryFile; +}; + +namespace helper +{ + +/** + * @brief A helper function to get the PEL subsystem value based on + * the registry subsystem name. + * + * @param[in] subsystemName - The registry name for the subsystem + * + * @return uint8_t The PEL subsystem value + */ +uint8_t getSubsystem(const std::string& subsystemName); + +/** + * @brief A helper function to get the PEL severity value based on + * the registry severity name. + * + * @param[in] severityName - The registry name for the severity + * + * @return uint8_t The PEL severity value + */ +uint8_t getSeverity(const std::string& severityName); + +/** + * @brief A helper function to get the action flags value based on + * the action flag names used in the registry. + * + * @param[in] flags - The list of flag names from the registry. + * + * @return uint16_t - The bitfield of flags used in the PEL. + */ +uint16_t getActionFlags(const std::vector<std::string>& flags); + +/** + * @brief A helper function to get the PEL event type value based on + * the registry event type name. + * + * @param[in] eventTypeName - The registry name for the event type + * + * @return uint8_t The PEL event type value + */ +uint8_t getEventType(const std::string& eventTypeName); + +/** + * @brief A helper function to get the PEL event scope value based on + * the registry event scope name. + * + * @param[in] eventScopeName - The registry name for the event scope + * + * @return uint8_t The PEL event scope value + */ +uint8_t getEventScope(const std::string& eventScopeName); + +} // namespace helper + +} // namespace message + +} // namespace pels +} // namespace openpower |