Matt Spinler | 711d51d | 2019-11-06 09:36:51 -0600 | [diff] [blame] | 1 | /** |
| 2 | * Copyright © 2019 IBM Corporation |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
Matt Spinler | d3335df | 2019-07-10 11:04:21 -0500 | [diff] [blame] | 16 | #include "private_header.hpp" |
| 17 | |
Harisuddin Mohamed Isa | 2ecb465 | 2020-01-10 10:51:02 +0800 | [diff] [blame] | 18 | #include "json_utils.hpp" |
Matt Spinler | 289aa47 | 2019-09-20 12:33:29 -0500 | [diff] [blame] | 19 | #include "log_id.hpp" |
Matt Spinler | 1a94cc3 | 2019-09-11 13:32:12 -0500 | [diff] [blame] | 20 | #include "pel_types.hpp" |
Aatir | c92b4eb | 2019-11-18 13:44:51 -0600 | [diff] [blame] | 21 | #include "pel_values.hpp" |
Matt Spinler | 2ea96f6 | 2022-02-23 16:31:01 -0600 | [diff] [blame^] | 22 | #include "trace.hpp" |
Matt Spinler | 1a94cc3 | 2019-09-11 13:32:12 -0500 | [diff] [blame] | 23 | |
Matt Spinler | 2ea96f6 | 2022-02-23 16:31:01 -0600 | [diff] [blame^] | 24 | #include <fmt/format.h> |
Matt Spinler | d3335df | 2019-07-10 11:04:21 -0500 | [diff] [blame] | 25 | |
| 26 | namespace openpower |
| 27 | { |
| 28 | namespace pels |
| 29 | { |
| 30 | |
Aatir | c92b4eb | 2019-11-18 13:44:51 -0600 | [diff] [blame] | 31 | namespace pv = openpower::pels::pel_values; |
Matt Spinler | d3335df | 2019-07-10 11:04:21 -0500 | [diff] [blame] | 32 | |
Matt Spinler | 289aa47 | 2019-09-20 12:33:29 -0500 | [diff] [blame] | 33 | PrivateHeader::PrivateHeader(uint16_t componentID, uint32_t obmcLogID, |
| 34 | uint64_t timestamp) |
| 35 | { |
| 36 | _header.id = static_cast<uint16_t>(SectionID::privateHeader); |
| 37 | _header.size = PrivateHeader::flattenedSize(); |
| 38 | _header.version = privateHeaderVersion; |
| 39 | _header.subType = 0; |
| 40 | _header.componentID = componentID; |
| 41 | |
| 42 | _createTimestamp = getBCDTime(timestamp); |
| 43 | |
| 44 | auto now = std::chrono::system_clock::now(); |
| 45 | _commitTimestamp = getBCDTime(now); |
| 46 | |
| 47 | _creatorID = static_cast<uint8_t>(CreatorID::openBMC); |
| 48 | |
| 49 | // Add support for reminder and telemetry log types here if |
| 50 | // ever necessary. |
| 51 | _logType = 0; |
| 52 | |
| 53 | _reservedByte = 0; |
| 54 | |
| 55 | // the final section count will be updated later |
| 56 | _sectionCount = 1; |
| 57 | |
| 58 | _obmcLogID = obmcLogID; |
| 59 | |
| 60 | _id = generatePELID(); |
| 61 | |
| 62 | _plid = _id; |
| 63 | |
| 64 | // Leave _creatorVersion at 0 |
| 65 | |
| 66 | _valid = true; |
| 67 | } |
| 68 | |
Matt Spinler | 31eed99 | 2019-10-09 14:07:52 -0500 | [diff] [blame] | 69 | PrivateHeader::PrivateHeader(Stream& pel) : |
| 70 | _creatorID(0), _logType(0), _reservedByte(0), _sectionCount(0), |
| 71 | _obmcLogID(0), _plid(0), _id(0) |
Matt Spinler | d3335df | 2019-07-10 11:04:21 -0500 | [diff] [blame] | 72 | { |
| 73 | try |
| 74 | { |
Matt Spinler | cf5a8d0 | 2019-09-05 12:58:53 -0500 | [diff] [blame] | 75 | unflatten(pel); |
Matt Spinler | d3335df | 2019-07-10 11:04:21 -0500 | [diff] [blame] | 76 | validate(); |
| 77 | } |
| 78 | catch (const std::exception& e) |
| 79 | { |
Matt Spinler | 2ea96f6 | 2022-02-23 16:31:01 -0600 | [diff] [blame^] | 80 | trace::error( |
| 81 | fmt::format("Cannot unflatten private header: {}", e.what())); |
Matt Spinler | d3335df | 2019-07-10 11:04:21 -0500 | [diff] [blame] | 82 | _valid = false; |
| 83 | } |
| 84 | } |
Aatir | c92b4eb | 2019-11-18 13:44:51 -0600 | [diff] [blame] | 85 | std::optional<std::string> PrivateHeader::getJSON() const |
| 86 | { |
| 87 | char tmpPhVal[50]; |
Harisuddin Mohamed Isa | 160c51c | 2020-02-13 23:42:20 +0800 | [diff] [blame] | 88 | sprintf(tmpPhVal, "%02X/%02X/%02X%02X %02X:%02X:%02X", |
Aatir | c92b4eb | 2019-11-18 13:44:51 -0600 | [diff] [blame] | 89 | _createTimestamp.month, _createTimestamp.day, |
| 90 | _createTimestamp.yearMSB, _createTimestamp.yearLSB, |
| 91 | _createTimestamp.hour, _createTimestamp.minutes, |
| 92 | _createTimestamp.seconds); |
| 93 | std::string phCreateTStr(tmpPhVal); |
Harisuddin Mohamed Isa | 160c51c | 2020-02-13 23:42:20 +0800 | [diff] [blame] | 94 | sprintf(tmpPhVal, "%02X/%02X/%02X%02X %02X:%02X:%02X", |
Aatir | c92b4eb | 2019-11-18 13:44:51 -0600 | [diff] [blame] | 95 | _commitTimestamp.month, _commitTimestamp.day, |
Sumit Kumar | 74348c6 | 2021-10-26 05:48:28 -0500 | [diff] [blame] | 96 | _commitTimestamp.yearMSB, _commitTimestamp.yearLSB, |
Aatir | c92b4eb | 2019-11-18 13:44:51 -0600 | [diff] [blame] | 97 | _commitTimestamp.hour, _commitTimestamp.minutes, |
| 98 | _commitTimestamp.seconds); |
| 99 | std::string phCommitTStr(tmpPhVal); |
Harisuddin Mohamed Isa | bebeb94 | 2020-03-12 17:12:24 +0800 | [diff] [blame] | 100 | std::string creator = getNumberString("%c", _creatorID); |
Aatir | c92b4eb | 2019-11-18 13:44:51 -0600 | [diff] [blame] | 101 | creator = pv::creatorIDs.count(creator) ? pv::creatorIDs.at(creator) |
| 102 | : "Unknown CreatorID"; |
| 103 | std::string phCreatorVersionStr = |
| 104 | std::string(reinterpret_cast<const char*>(_creatorVersion.version)); |
Matt Spinler | d3335df | 2019-07-10 11:04:21 -0500 | [diff] [blame] | 105 | |
Harisuddin Mohamed Isa | 2ecb465 | 2020-01-10 10:51:02 +0800 | [diff] [blame] | 106 | std::string ph; |
Harisuddin Mohamed Isa | bebeb94 | 2020-03-12 17:12:24 +0800 | [diff] [blame] | 107 | jsonInsert(ph, pv::sectionVer, getNumberString("%d", privateHeaderVersion), |
| 108 | 1); |
| 109 | jsonInsert(ph, pv::subSection, getNumberString("%d", _header.subType), 1); |
| 110 | jsonInsert(ph, pv::createdBy, getNumberString("0x%X", _header.componentID), |
| 111 | 1); |
Harisuddin Mohamed Isa | 2ecb465 | 2020-01-10 10:51:02 +0800 | [diff] [blame] | 112 | jsonInsert(ph, "Created at", phCreateTStr, 1); |
| 113 | jsonInsert(ph, "Committed at", phCommitTStr, 1); |
| 114 | jsonInsert(ph, "Creator Subsystem", creator, 1); |
| 115 | jsonInsert(ph, "CSSVER", phCreatorVersionStr, 1); |
Harisuddin Mohamed Isa | bebeb94 | 2020-03-12 17:12:24 +0800 | [diff] [blame] | 116 | jsonInsert(ph, "Platform Log Id", getNumberString("0x%X", _plid), 1); |
| 117 | jsonInsert(ph, "Entry Id", getNumberString("0x%X", _id), 1); |
| 118 | jsonInsert(ph, "BMC Event Log Id", std::to_string(_obmcLogID), 1); |
Harisuddin Mohamed Isa | 2ecb465 | 2020-01-10 10:51:02 +0800 | [diff] [blame] | 119 | ph.erase(ph.size() - 2); |
Aatir | c92b4eb | 2019-11-18 13:44:51 -0600 | [diff] [blame] | 120 | |
| 121 | return ph; |
| 122 | } |
Matt Spinler | d3335df | 2019-07-10 11:04:21 -0500 | [diff] [blame] | 123 | void PrivateHeader::validate() |
| 124 | { |
| 125 | bool failed = false; |
| 126 | |
Matt Spinler | 1a94cc3 | 2019-09-11 13:32:12 -0500 | [diff] [blame] | 127 | if (header().id != static_cast<uint16_t>(SectionID::privateHeader)) |
Matt Spinler | d3335df | 2019-07-10 11:04:21 -0500 | [diff] [blame] | 128 | { |
Matt Spinler | 2ea96f6 | 2022-02-23 16:31:01 -0600 | [diff] [blame^] | 129 | trace::error(fmt::format("Invalid private header section ID: {:#X}", |
| 130 | header().id)); |
Matt Spinler | d3335df | 2019-07-10 11:04:21 -0500 | [diff] [blame] | 131 | failed = true; |
| 132 | } |
| 133 | |
| 134 | if (header().version != privateHeaderVersion) |
| 135 | { |
Matt Spinler | 2ea96f6 | 2022-02-23 16:31:01 -0600 | [diff] [blame^] | 136 | trace::error(fmt::format("Invalid private header version: {}", |
| 137 | header().version)); |
Matt Spinler | d3335df | 2019-07-10 11:04:21 -0500 | [diff] [blame] | 138 | failed = true; |
| 139 | } |
| 140 | |
| 141 | if (_sectionCount < minSectionCount) |
| 142 | { |
Matt Spinler | 2ea96f6 | 2022-02-23 16:31:01 -0600 | [diff] [blame^] | 143 | trace::error(fmt::format("Invalid section count in private header: {}", |
| 144 | _sectionCount)); |
Matt Spinler | d3335df | 2019-07-10 11:04:21 -0500 | [diff] [blame] | 145 | failed = true; |
| 146 | } |
| 147 | |
| 148 | _valid = (failed) ? false : true; |
| 149 | } |
| 150 | |
Matt Spinler | cf5a8d0 | 2019-09-05 12:58:53 -0500 | [diff] [blame] | 151 | void PrivateHeader::unflatten(Stream& stream) |
Matt Spinler | d3335df | 2019-07-10 11:04:21 -0500 | [diff] [blame] | 152 | { |
Matt Spinler | cf5a8d0 | 2019-09-05 12:58:53 -0500 | [diff] [blame] | 153 | stream >> _header >> _createTimestamp >> _commitTimestamp >> _creatorID >> |
| 154 | _logType >> _reservedByte >> _sectionCount >> _obmcLogID >> |
| 155 | _creatorVersion >> _plid >> _id; |
Matt Spinler | d3335df | 2019-07-10 11:04:21 -0500 | [diff] [blame] | 156 | } |
| 157 | |
Matt Spinler | 0688545 | 2019-11-06 10:35:42 -0600 | [diff] [blame] | 158 | void PrivateHeader::flatten(Stream& stream) const |
Matt Spinler | d3335df | 2019-07-10 11:04:21 -0500 | [diff] [blame] | 159 | { |
Matt Spinler | cf5a8d0 | 2019-09-05 12:58:53 -0500 | [diff] [blame] | 160 | stream << _header << _createTimestamp << _commitTimestamp << _creatorID |
| 161 | << _logType << _reservedByte << _sectionCount << _obmcLogID |
| 162 | << _creatorVersion << _plid << _id; |
Matt Spinler | d3335df | 2019-07-10 11:04:21 -0500 | [diff] [blame] | 163 | } |
| 164 | |
| 165 | Stream& operator>>(Stream& s, CreatorVersion& cv) |
| 166 | { |
| 167 | for (size_t i = 0; i < sizeof(CreatorVersion); i++) |
| 168 | { |
| 169 | s >> cv.version[i]; |
| 170 | } |
| 171 | return s; |
| 172 | } |
| 173 | |
Matt Spinler | 0688545 | 2019-11-06 10:35:42 -0600 | [diff] [blame] | 174 | Stream& operator<<(Stream& s, const CreatorVersion& cv) |
Matt Spinler | d3335df | 2019-07-10 11:04:21 -0500 | [diff] [blame] | 175 | { |
| 176 | for (size_t i = 0; i < sizeof(CreatorVersion); i++) |
| 177 | { |
| 178 | s << cv.version[i]; |
| 179 | } |
| 180 | return s; |
| 181 | } |
| 182 | |
| 183 | } // namespace pels |
| 184 | } // namespace openpower |