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 */ 16 #include "user_header.hpp" 17 18 #include "pel_types.hpp" 19 #include "severity.hpp" 20 21 #include <phosphor-logging/log.hpp> 22 23 namespace openpower 24 { 25 namespace pels 26 { 27 28 using namespace phosphor::logging; 29 30 void UserHeader::unflatten(Stream& stream) 31 { 32 stream >> _header >> _eventSubsystem >> _eventScope >> _eventSeverity >> 33 _eventType >> _reserved4Byte1 >> _problemDomain >> _problemVector >> 34 _actionFlags >> _reserved4Byte2; 35 } 36 37 void UserHeader::flatten(Stream& stream) 38 { 39 stream << _header << _eventSubsystem << _eventScope << _eventSeverity 40 << _eventType << _reserved4Byte1 << _problemDomain << _problemVector 41 << _actionFlags << _reserved4Byte2; 42 } 43 44 UserHeader::UserHeader(const message::Entry& entry, 45 phosphor::logging::Entry::Level severity) 46 { 47 _header.id = static_cast<uint16_t>(SectionID::userHeader); 48 _header.size = UserHeader::flattenedSize(); 49 _header.version = userHeaderVersion; 50 _header.subType = 0; 51 _header.componentID = static_cast<uint16_t>(ComponentID::phosphorLogging); 52 53 _eventSubsystem = entry.subsystem; 54 55 _eventScope = entry.eventScope.value_or( 56 static_cast<uint8_t>(EventScope::entirePlatform)); 57 58 // Get the severity from the registry if it's there, otherwise get it 59 // from the OpenBMC event log severity value. 60 _eventSeverity = 61 entry.severity.value_or(convertOBMCSeverityToPEL(severity)); 62 63 // TODO: ibm-dev/dev/#1144 Handle manufacturing sev & action flags 64 65 if (entry.eventType) 66 { 67 _eventType = *entry.eventType; 68 } 69 else 70 { 71 // There are different default event types for info errors 72 // vs non info ones. 73 auto sevType = static_cast<SeverityType>(_eventSeverity & 0xF0); 74 75 _eventType = (sevType == SeverityType::nonError) 76 ? static_cast<uint8_t>(EventType::miscInformational) 77 : static_cast<uint8_t>(EventType::notApplicable); 78 } 79 80 _reserved4Byte1 = 0; 81 82 // No uses for problem domain or vector 83 _problemDomain = 0; 84 _problemVector = 0; 85 86 // These will be cleaned up later in pel_rules::check() 87 _actionFlags = entry.actionFlags.value_or(0); 88 89 _reserved4Byte2 = 0; 90 91 _valid = true; 92 } 93 94 UserHeader::UserHeader(Stream& pel) 95 { 96 try 97 { 98 unflatten(pel); 99 validate(); 100 } 101 catch (const std::exception& e) 102 { 103 log<level::ERR>("Cannot unflatten user header", 104 entry("ERROR=%s", e.what())); 105 _valid = false; 106 } 107 } 108 109 void UserHeader::validate() 110 { 111 bool failed = false; 112 if (header().id != static_cast<uint16_t>(SectionID::userHeader)) 113 { 114 log<level::ERR>("Invalid user header section ID", 115 entry("ID=0x%X", header().id)); 116 failed = true; 117 } 118 119 if (header().version != userHeaderVersion) 120 { 121 log<level::ERR>("Invalid user header version", 122 entry("VERSION=0x%X", header().version)); 123 failed = true; 124 } 125 126 _valid = (failed) ? false : true; 127 } 128 129 } // namespace pels 130 } // namespace openpower 131