PEL: Create PrivateHeader from parameters

Add a constructor to the PrivateHeader class so it can be built from the
creator's component ID, the OpenBMC log ID, and the creation timestamp.

This will be used when creating PELs from OpenBMC event logs.

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

4 files changed, 138 insertions, 7 deletions

diff --git a/extensions/openpower-pels/pel_types.hpp b/extensions/openpower-pels/pel_types.hpp
index b836942..3d9e457 100644
--- a/extensions/openpower-pels/pel_types.hpp
+++ b/extensions/openpower-pels/pel_types.hpp
@@ -5,6 +5,9 @@ namespace openpower
 namespace pels
 {
 
+/**
+ * @brief Useful component IDs
+ */
 enum class ComponentID
 {
     phosphorLogging = 0x2000
@@ -35,11 +38,33 @@ enum class SectionID
     extUserData = 0x4544         // 'ED'
 };
 
+/**
+ * @brief Useful SRC types
+ */
 enum class SRCType
 {
     bmcError = 0xBD,
     powerError = 0x11
 };
 
+/**
+ * @brief Creator IDs
+ */
+enum class CreatorID
+{
+    fsp = 'E',
+    hmc = 'C',
+    hostboot = 'B',
+    ioDrawer = 'M',
+    occ = 'T',
+    openBMC = 'O',
+    partFW = 'L',
+    phyp = 'H',
+    powerControl = 'W',
+    powerNV = 'P',
+    sapphire = 'K',
+    slic = 'S',
+};
+
 } // namespace pels
 } // namespace openpower
diff --git a/extensions/openpower-pels/private_header.cpp b/extensions/openpower-pels/private_header.cpp
index fc62df1..2265497 100644
--- a/extensions/openpower-pels/private_header.cpp
+++ b/extensions/openpower-pels/private_header.cpp
@@ -1,5 +1,6 @@
 #include "private_header.hpp"
 
+#include "log_id.hpp"
 #include "pel_types.hpp"
 
 #include <phosphor-logging/log.hpp>
@@ -11,6 +12,42 @@ namespace pels
 
 using namespace phosphor::logging;
 
+PrivateHeader::PrivateHeader(uint16_t componentID, uint32_t obmcLogID,
+                             uint64_t timestamp)
+{
+    _header.id = static_cast<uint16_t>(SectionID::privateHeader);
+    _header.size = PrivateHeader::flattenedSize();
+    _header.version = privateHeaderVersion;
+    _header.subType = 0;
+    _header.componentID = componentID;
+
+    _createTimestamp = getBCDTime(timestamp);
+
+    auto now = std::chrono::system_clock::now();
+    _commitTimestamp = getBCDTime(now);
+
+    _creatorID = static_cast<uint8_t>(CreatorID::openBMC);
+
+    // Add support for reminder and telemetry log types here if
+    // ever necessary.
+    _logType = 0;
+
+    _reservedByte = 0;
+
+    // the final section count will be updated later
+    _sectionCount = 1;
+
+    _obmcLogID = obmcLogID;
+
+    _id = generatePELID();
+
+    _plid = _id;
+
+    // Leave _creatorVersion at 0
+
+    _valid = true;
+}
+
 PrivateHeader::PrivateHeader(Stream& pel)
 {
     try
diff --git a/extensions/openpower-pels/private_header.hpp b/extensions/openpower-pels/private_header.hpp
index 66126a0..9c522a2 100644
--- a/extensions/openpower-pels/private_header.hpp
+++ b/extensions/openpower-pels/private_header.hpp
@@ -12,6 +12,11 @@ namespace pels
 struct CreatorVersion
 {
     uint8_t version[8];
+
+    CreatorVersion()
+    {
+        memset(version, '\0', sizeof(version));
+    }
 };
 
 static constexpr uint8_t privateHeaderVersion = 0x01;
@@ -42,6 +47,17 @@ class PrivateHeader : public Section
     /**
      * @brief Constructor
      *
+     * Creates a valid PrivateHeader with the passed in data
+     *
+     * @param[in] componentID - the creator's component ID
+     * @param[in] obmcLogID - the corresponding OpenBMC event log ID
+     * @param[in] timestamp - the creation timestamp, in epoch milliseconds
+     */
+    PrivateHeader(uint16_t componentID, uint32_t obmcLogID, uint64_t timestamp);
+
+    /**
+     * @brief Constructor
+     *
      * Fills in this class's data fields from the stream.
      *
      * @param[in] pel - the PEL data stream
diff --git a/test/openpower-pels/private_header_test.cpp b/test/openpower-pels/private_header_test.cpp
index de16ac6..ebb515c 100644
--- a/test/openpower-pels/private_header_test.cpp
+++ b/test/openpower-pels/private_header_test.cpp
@@ -5,12 +5,16 @@
 
 using namespace openpower::pels;
 
-TEST(PrivateHeaderTest, SizeTest)
+class PrivateHeaderTest : public CleanLogID
+{
+};
+
+TEST_F(PrivateHeaderTest, SizeTest)
 {
     EXPECT_EQ(PrivateHeader::flattenedSize(), 48);
 }
 
-TEST(PrivateHeaderTest, UnflattenFlattenTest)
+TEST_F(PrivateHeaderTest, UnflattenFlattenTest)
 {
     auto data = pelDataFactory(TestPelType::privateHeaderSimple);
 
@@ -29,7 +33,7 @@ TEST(PrivateHeaderTest, UnflattenFlattenTest)
     EXPECT_EQ(ct.yearLSB, 0x30);
     EXPECT_EQ(ct.month, 0x05);
     EXPECT_EQ(ct.day, 0x09);
-    EXPECT_EQ(ct.hour, 0x011);
+    EXPECT_EQ(ct.hour, 0x11);
     EXPECT_EQ(ct.minutes, 0x1E);
     EXPECT_EQ(ct.seconds, 0x01);
     EXPECT_EQ(ct.hundredths, 0x63);
@@ -78,7 +82,7 @@ TEST(PrivateHeaderTest, UnflattenFlattenTest)
     EXPECT_EQ(newPH.creatorID(), 0x55);
 }
 
-TEST(PrivateHeaderTest, ShortDataTest)
+TEST_F(PrivateHeaderTest, ShortDataTest)
 {
     auto data = pelDataFactory(TestPelType::privateHeaderSimple);
     data->resize(PrivateHeader::flattenedSize() - 1);
@@ -89,7 +93,7 @@ TEST(PrivateHeaderTest, ShortDataTest)
     EXPECT_EQ(ph.valid(), false);
 }
 
-TEST(PrivateHeaderTest, CorruptDataTest1)
+TEST_F(PrivateHeaderTest, CorruptDataTest1)
 {
     auto data = pelDataFactory(TestPelType::privateHeaderSimple);
     Stream stream(*data);
@@ -101,7 +105,7 @@ TEST(PrivateHeaderTest, CorruptDataTest1)
     EXPECT_EQ(ph.valid(), false);
 }
 
-TEST(PrivateHeaderTest, CorruptDataTest2)
+TEST_F(PrivateHeaderTest, CorruptDataTest2)
 {
     auto data = pelDataFactory(TestPelType::privateHeaderSimple);
     Stream stream(*data);
@@ -113,7 +117,7 @@ TEST(PrivateHeaderTest, CorruptDataTest2)
     EXPECT_EQ(ph.valid(), false);
 }
 
-TEST(PrivateHeaderTest, CorruptDataTest3)
+TEST_F(PrivateHeaderTest, CorruptDataTest3)
 {
     auto data = pelDataFactory(TestPelType::privateHeaderSimple);
     Stream stream(*data);
@@ -124,3 +128,52 @@ TEST(PrivateHeaderTest, CorruptDataTest3)
 
     EXPECT_EQ(ph.valid(), false);
 }
+
+// Construct a PrivateHeader from scratch
+TEST_F(PrivateHeaderTest, ConstructionTest)
+{
+    tm time_tm;
+    time_tm.tm_year = 125;
+    time_tm.tm_mon = 11;
+    time_tm.tm_mday = 31;
+    time_tm.tm_hour = 15;
+    time_tm.tm_min = 23;
+    time_tm.tm_sec = 42;
+    time_tm.tm_isdst = 0;
+
+    // Convert the above time into a uint64_t in ms since the epoch time
+    auto timepoint = std::chrono::system_clock::from_time_t(mktime(&time_tm));
+    auto timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(
+                         timepoint.time_since_epoch())
+                         .count();
+
+    PrivateHeader ph(0x3300, 42, timestamp);
+
+    EXPECT_TRUE(ph.valid());
+    EXPECT_EQ(ph.header().id, 0x5048);
+    EXPECT_EQ(ph.header().size, PrivateHeader::flattenedSize());
+    EXPECT_EQ(ph.header().version, 0x01);
+    EXPECT_EQ(ph.header().subType, 0x00);
+    EXPECT_EQ(ph.header().componentID, 0x3300);
+
+    auto& ct = ph.createTimestamp();
+    EXPECT_EQ(ct.yearMSB, 0x20);
+    EXPECT_EQ(ct.yearLSB, 0x25);
+    EXPECT_EQ(ct.month, 0x12);
+    EXPECT_EQ(ct.day, 0x31);
+    EXPECT_EQ(ct.hour, 0x15);
+    EXPECT_EQ(ct.minutes, 0x23);
+    EXPECT_EQ(ct.seconds, 0x42);
+    EXPECT_EQ(ct.hundredths, 0x00);
+
+    EXPECT_EQ(ph.creatorID(), 'O');
+    EXPECT_EQ(ph.logType(), 0x00);
+    EXPECT_EQ(ph.sectionCount(), 0x01);
+    EXPECT_EQ(ph.obmcLogID(), 42);
+
+    char expected[] = {0, 0, 0, 0, 0, 0, 0, 0};
+    EXPECT_TRUE(memcmp(ph.creatorVersion().version, expected, 8) == 0);
+
+    EXPECT_EQ(ph.id(), 0x50000001);
+    EXPECT_EQ(ph.id(), ph.plid());
+}