PEL: Validate the Action Flags field

According to the PEL spec, the Action Flags and Event Type fields in the
User Header section must be in agreement with the Severity field. So,
when a PEL is being created from an OpenBMC event log, check those
values for correctness and fix them up if required.

In addition, as those fields are optional in the message registry, this
code will also just set these two fields to valid values if they were
left out.

The rules being followed are documented in the PEL readme.

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

9 files changed, 228 insertions, 3 deletions

diff --git a/extensions/openpower-pels/README.md b/extensions/openpower-pels/README.md
index 14fade2..eac30be 100644
--- a/extensions/openpower-pels/README.md
+++ b/extensions/openpower-pels/README.md
@@ -55,4 +55,32 @@ PEL:
 The PEL message registry is used to create PELs from OpenBMC event logs.
 Documentation can be found [here](registry/README.md).
 
+## `Action Flags` and `Event Type` Rules
+
+The `Action Flags` and `Event Type` PEL fields are optional in the message
+registry, and if not present the code will set them based on certain rules
+layed out in the PEL spec.  In fact, even if they were specified, the checks
+are still done to ensure consistency across all the logs.
+
+These rules are:
+1. Always set the `Report` flag, unless the `Do Not Report` flag is already on.
+2. Always clear the `SP Call Home` flag, as that feature isn't supported.
+3. If the severity is `Non-error Event`:
+    - Clear the `Service Action` flag.
+    - Clear the `Call Home` flag.
+    - If the `Event Type` field is `Not Applicable`, change it to `Information
+      Only`.
+    - If the `Event Type` field is `Information Only` or `Tracing`, set the
+      `Hidden` flag.
+4. If the severity is `Recovered`:
+    - Set the `Hidden` flag.
+    - Clear the `Service Action` flag.
+    - Clear the `Call Home` flag.
+5. For all other severities:
+    - Clear the `Hidden` flag.
+    - Set the `Service Action` flag.
+    - Set the `Call Home` flag.
+
+Additional rules may be added in the future if necessary.
+
 ## D-Bus Interfaces
diff --git a/extensions/openpower-pels/openpower-pels.mk b/extensions/openpower-pels/openpower-pels.mk
index 7690af4..dee798e 100644
--- a/extensions/openpower-pels/openpower-pels.mk
+++ b/extensions/openpower-pels/openpower-pels.mk
@@ -16,6 +16,7 @@ phosphor_log_manager_SOURCES += \
 	extensions/openpower-pels/paths.cpp \
 	extensions/openpower-pels/pce_identity.cpp \
 	extensions/openpower-pels/pel.cpp \
+	extensions/openpower-pels/pel_rules.cpp \
 	extensions/openpower-pels/pel_values.cpp \
 	extensions/openpower-pels/private_header.cpp \
 	extensions/openpower-pels/registry.cpp \
@@ -48,6 +49,7 @@ peltool_LDADD = \
         extensions/openpower-pels/paths.o \
         extensions/openpower-pels/pce_identity.o \
         extensions/openpower-pels/pel.o \
+        extensions/openpower-pels/pel_rules.o \
         extensions/openpower-pels/pel_values.o \
         extensions/openpower-pels/private_header.o \
         extensions/openpower-pels/registry.o \
diff --git a/extensions/openpower-pels/pel.cpp b/extensions/openpower-pels/pel.cpp
index 1ba5c97..885caed 100644
--- a/extensions/openpower-pels/pel.cpp
+++ b/extensions/openpower-pels/pel.cpp
@@ -19,6 +19,7 @@
 #include "failing_mtms.hpp"
 #include "hexdump.hpp"
 #include "log_id.hpp"
+#include "pel_rules.hpp"
 #include "pel_values.hpp"
 #include "section_factory.hpp"
 #include "src.hpp"
@@ -57,6 +58,8 @@ PEL::PEL(const message::Entry& entry, uint32_t obmcLogID, uint64_t timestamp,
     }
 
     _ph->setSectionCount(2 + _optionalSections.size());
+
+    checkRulesAndFix();
 }
 
 PEL::PEL(std::vector<uint8_t>& data) : PEL(data, 0)
@@ -160,6 +163,15 @@ std::optional<SRC*> PEL::primarySRC() const
     return std::nullopt;
 }
 
+void PEL::checkRulesAndFix()
+{
+    auto [actionFlags, eventType] =
+        pel_rules::check(_uh->actionFlags(), _uh->eventType(), _uh->severity());
+
+    _uh->setActionFlags(actionFlags);
+    _uh->setEventType(eventType);
+}
+
 namespace util
 {
 
diff --git a/extensions/openpower-pels/pel.hpp b/extensions/openpower-pels/pel.hpp
index 3498ae6..4cdbd1d 100644
--- a/extensions/openpower-pels/pel.hpp
+++ b/extensions/openpower-pels/pel.hpp
@@ -240,6 +240,12 @@ class PEL
     void flatten(std::vector<uint8_t>& pelBuffer);
 
     /**
+     * @brief Check that the PEL fields that need to be in agreement
+     *        with each other are, and fix them up if necessary.
+     */
+    void checkRulesAndFix();
+
+    /**
      * @brief The PEL Private Header section
      */
     std::unique_ptr<PrivateHeader> _ph;
diff --git a/extensions/openpower-pels/pel_rules.cpp b/extensions/openpower-pels/pel_rules.cpp
new file mode 100644
index 0000000..be5e5a2
--- /dev/null
+++ b/extensions/openpower-pels/pel_rules.cpp
@@ -0,0 +1,90 @@
+#include "pel_rules.hpp"
+
+#include "pel_types.hpp"
+
+#include <bitset>
+
+namespace openpower
+{
+namespace pels
+{
+namespace pel_rules
+{
+
+std::tuple<uint16_t, uint8_t> check(uint16_t actionFlags, uint8_t eventType,
+                                    uint8_t severity)
+{
+    std::bitset<16> newActionFlags{actionFlags};
+    uint8_t newEventType = eventType;
+    auto sevType = static_cast<SeverityType>(severity & 0xF0);
+
+    // TODO: This code covers the most common cases.  The final tweaking
+    // will be done with ibm-openbmc/dev#1333.
+
+    // Always report, unless specifically told not to
+    if (!newActionFlags.test(dontReportToHostFlagBit))
+    {
+        newActionFlags.set(reportFlagBit);
+    }
+    else
+    {
+        newActionFlags.reset(reportFlagBit);
+    }
+
+    // Call home by BMC not supported
+    newActionFlags.reset(spCallHomeFlagBit);
+
+    switch (sevType)
+    {
+        case SeverityType::nonError:
+        {
+            // Informational errors never need service actions or call home.
+            newActionFlags.reset(serviceActionFlagBit);
+            newActionFlags.reset(callHomeFlagBit);
+
+            // Ensure event type isn't 'not applicable'
+            if (newEventType == static_cast<uint8_t>(EventType::notApplicable))
+            {
+                newEventType =
+                    static_cast<uint8_t>(EventType::miscInformational);
+            }
+
+            // The misc info and tracing event types are always hidden.
+            // For other event types, it's up to the creator.
+            if ((newEventType ==
+                 static_cast<uint8_t>(EventType::miscInformational)) ||
+                (newEventType == static_cast<uint8_t>(EventType::tracing)))
+            {
+                newActionFlags.set(hiddenFlagBit);
+            }
+            break;
+        }
+        case SeverityType::recovered:
+        {
+            // Recovered errors are hidden, and by definition need no
+            // service action or call home.
+            newActionFlags.set(hiddenFlagBit);
+            newActionFlags.reset(serviceActionFlagBit);
+            newActionFlags.reset(callHomeFlagBit);
+            break;
+        }
+        case SeverityType::predictive:
+        case SeverityType::unrecoverable:
+        case SeverityType::critical:
+        case SeverityType::diagnostic:
+        case SeverityType::symptom:
+        {
+            // Report these others as normal errors.
+            newActionFlags.reset(hiddenFlagBit);
+            newActionFlags.set(serviceActionFlagBit);
+            newActionFlags.set(callHomeFlagBit);
+            break;
+        }
+    }
+
+    return {static_cast<uint16_t>(newActionFlags.to_ulong()), newEventType};
+}
+
+} // namespace pel_rules
+} // namespace pels
+} // namespace openpower
diff --git a/extensions/openpower-pels/pel_rules.hpp b/extensions/openpower-pels/pel_rules.hpp
new file mode 100644
index 0000000..ca05875
--- /dev/null
+++ b/extensions/openpower-pels/pel_rules.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <cstdint>
+#include <tuple>
+
+namespace openpower
+{
+namespace pels
+{
+namespace pel_rules
+{
+
+/**
+ * @brief Ensure certain PEL fields are in agreement, and fix them if they
+ *        aren't.  These rules are documented in the README.md in this
+ *        directory.
+ *
+ * Note: The message registry schema enforces that there are no undefined
+ *       bits set in these fields.
+ *
+ * @param[in] actionFlags - The current Action Flags value
+ * @param[in] eventType - The current Event Type value
+ * @param[in] severity - The current Severity value
+ *
+ * @return std::tuple<actionFlags, eventType> - The corrected values.
+ */
+std::tuple<uint16_t, uint8_t> check(uint16_t actionFlags, uint8_t eventType,
+                                    uint8_t severity);
+
+} // namespace pel_rules
+} // namespace pels
+} // namespace openpower
diff --git a/extensions/openpower-pels/pel_types.hpp b/extensions/openpower-pels/pel_types.hpp
index d19c875..ae886eb 100644
--- a/extensions/openpower-pels/pel_types.hpp
+++ b/extensions/openpower-pels/pel_types.hpp
@@ -79,7 +79,9 @@ enum class EventScope
  */
 enum class EventType
 {
-    notApplicable = 0x00
+    notApplicable = 0x00,
+    miscInformational = 0x01,
+    tracing = 0x02
 };
 
 /**
@@ -97,5 +99,25 @@ enum class SeverityType
     symptom = 0x70
 };
 
+/**
+ * @brief The Action Flags values with the bit
+ *        numbering needed by std::bitset.
+ *
+ * Not an enum class so that casting isn't needed
+ * by the bitset operations.
+ */
+enum ActionFlagsBits
+{
+    serviceActionFlagBit = 15,       // 0x8000
+    hiddenFlagBit = 14,              // 0x4000
+    reportFlagBit = 13,              // 0x2000
+    dontReportToHostFlagBit = 12,    // 0x1000
+    callHomeFlagBit = 11,            // 0x0800
+    isolationIncompleteFlagBit = 10, // 0x0400
+    spCallHomeFlagBit = 8,           // 0x0100
+    osSWErrorBit = 7,                // 0x0080
+    osHWErrorBit = 6                 // 0x0040
+};
+
 } // namespace pels
 } // namespace openpower
diff --git a/extensions/openpower-pels/user_header.cpp b/extensions/openpower-pels/user_header.cpp
index 432ae67..8092e38 100644
--- a/extensions/openpower-pels/user_header.cpp
+++ b/extensions/openpower-pels/user_header.cpp
@@ -62,8 +62,20 @@ UserHeader::UserHeader(const message::Entry& entry,
 
     // TODO: ibm-dev/dev/#1144 Handle manufacturing sev & action flags
 
-    _eventType = entry.eventType.value_or(
-        static_cast<uint8_t>(EventType::notApplicable));
+    if (entry.eventType)
+    {
+        _eventType = *entry.eventType;
+    }
+    else
+    {
+        // There are different default event types for info errors
+        // vs non info ones.
+        auto sevType = static_cast<SeverityType>(_eventSeverity & 0xF0);
+
+        _eventType = (sevType == SeverityType::nonError)
+                         ? static_cast<uint8_t>(EventType::miscInformational)
+                         : static_cast<uint8_t>(EventType::notApplicable);
+    }
 
     _reserved4Byte1 = 0;
 
@@ -71,6 +83,7 @@ UserHeader::UserHeader(const message::Entry& entry,
     _problemDomain = 0;
     _problemVector = 0;
 
+    // These will be cleaned up later in pel_rules::check()
     _actionFlags = entry.actionFlags.value_or(0);
 
     _reserved4Byte2 = 0;
diff --git a/extensions/openpower-pels/user_header.hpp b/extensions/openpower-pels/user_header.hpp
index 459952b..b382a84 100644
--- a/extensions/openpower-pels/user_header.hpp
+++ b/extensions/openpower-pels/user_header.hpp
@@ -102,6 +102,16 @@ class UserHeader : public Section
     }
 
     /**
+     * @brief Set the event type field
+     *
+     * @param[in] type - the new event type
+     */
+    void setEventType(uint8_t type)
+    {
+        _eventType = type;
+    }
+
+    /**
      * @brief Returns the problem domain field.
      *
      * @return uint8_t - the problem domain
@@ -132,6 +142,16 @@ class UserHeader : public Section
     }
 
     /**
+     * @brief Sets the action flags field
+     *
+     * @param[in] flags - the new action flags
+     */
+    void setActionFlags(uint16_t flags)
+    {
+        _actionFlags = flags;
+    }
+
+    /**
      * @brief Returns the size of this section when flattened into a PEL
      *
      * @return size_t - the size of the section