PEL: Find an entry in the message registry JSON

The message registry is a JSON file that holds data required to create a
PEL out of an OpenBMC event log. It includes fields like 'subsystem',
'event type', 'action flags', 'SRC reason code', etc.

Many fields in the message registry are optional, and a very minimal
entry make look like:

{
    "Name": "xyz.openbmc_project.Power.Error.Fault",
    "Subsystem": "power_supply",
    "ActionFlags": ["service_action", "report"],

    "SRC":
    {
        "ReasonCode": "0x2030"
    }
}

This commit adds support to look up a message registry entry based on an
OpenBMC event log's 'Message' property (i.e.
xyz.openbmc_project.Power.Error.Fault) and then fill in a structure with
the fields found.  Future commits will fill in the SRC related fields,
as well as actually create the PEL.

The message registry file can be found on the BMC at:
/usr/share/phosphor-logging/pels/message_registry.json.

For testing, users can put their own message_registry.json in
/etc/phosphor-logging, and that will take precedence.

Signed-off-by: Matt Spinler <spinler@us.ibm.com>
Change-Id: Ie4195ed7e58ab6a231271f6b295e63b1d0a4cd78

1 files changed, 179 insertions, 0 deletions

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