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