blob: 338c3231df228fd35471f4fd19449ee9d23ef5d9 [file] [log] [blame]
Matt Spinler711d51d2019-11-06 09:36:51 -06001/**
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 Spinlerf9bae182019-10-09 13:37:38 -050016#include "src.hpp"
17
Matt Spinler717de422020-06-04 13:10:14 -050018#include "device_callouts.hpp"
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +080019#include "json_utils.hpp"
20#include "paths.hpp"
21#include "pel_values.hpp"
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +080022#ifdef PELTOOL
23#include <Python.h>
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +080024
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +080025#include <nlohmann/json.hpp>
Patrick Williams2544b412022-10-04 08:41:06 -050026
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +080027#include <sstream>
28#endif
Matt Spinler5a90a952020-08-27 09:39:03 -050029#include <fmt/format.h>
30
Matt Spinlerf9bae182019-10-09 13:37:38 -050031#include <phosphor-logging/log.hpp>
32
33namespace openpower
34{
35namespace pels
36{
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +080037namespace pv = openpower::pels::pel_values;
38namespace rg = openpower::pels::message;
Matt Spinlerf9bae182019-10-09 13:37:38 -050039using namespace phosphor::logging;
Matt Spinler85f61a62020-06-03 16:28:55 -050040using namespace std::string_literals;
Matt Spinlerf9bae182019-10-09 13:37:38 -050041
Matt Spinler075e5ba2020-02-21 15:46:00 -060042constexpr size_t ccinSize = 4;
43
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +080044#ifdef PELTOOL
Sumit Kumar516935a2021-04-14 13:00:54 -050045using orderedJSON = nlohmann::ordered_json;
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +080046
47void pyDecRef(PyObject* pyObj)
48{
49 Py_XDECREF(pyObj);
50}
51
52/**
53 * @brief Returns a JSON string to append to SRC section.
54 *
55 * The returning string will contain a JSON object, but without
56 * the outer {}. If the input JSON isn't a JSON object (dict), then
57 * one will be created with the input added to a 'SRC Details' key.
58 *
59 * @param[in] json - The JSON to convert to a string
60 *
61 * @return std::string - The JSON string
62 */
Sumit Kumar516935a2021-04-14 13:00:54 -050063std::string prettyJSON(const orderedJSON& json)
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +080064{
Sumit Kumar516935a2021-04-14 13:00:54 -050065 orderedJSON output;
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +080066 if (!json.is_object())
67 {
68 output["SRC Details"] = json;
69 }
70 else
71 {
72 for (const auto& [key, value] : json.items())
73 {
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +080074 output["SRC Details"][key] = value;
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +080075 }
76 }
77
78 // Let nlohmann do the pretty printing.
79 std::stringstream stream;
80 stream << std::setw(4) << output;
81
82 auto jsonString = stream.str();
83
84 // Now it looks like:
85 // {
86 // "Key": "Value",
87 // ...
88 // }
89
90 // Replace the { and the following newline, and the } and its
91 // preceeding newline.
92 jsonString.erase(0, 2);
93
94 auto pos = jsonString.find_last_of('}');
95 jsonString.erase(pos - 1);
96
97 return jsonString;
98}
99
100/**
101 * @brief Call Python modules to parse the data into a JSON string
102 *
103 * The module to call is based on the Creator Subsystem ID under the namespace
104 * "srcparsers". For example: "srcparsers.xsrc.xsrc" where "x" is the Creator
105 * Subsystem ID in ASCII lowercase.
106 *
107 * All modules must provide the following:
108 * Function: parseSRCToJson
109 * Argument list:
110 * 1. (str) ASCII string (Hex Word 1)
111 * 2. (str) Hex Word 2
112 * 3. (str) Hex Word 3
113 * 4. (str) Hex Word 4
114 * 5. (str) Hex Word 5
115 * 6. (str) Hex Word 6
116 * 7. (str) Hex Word 7
117 * 8. (str) Hex Word 8
118 * 9. (str) Hex Word 9
119 *-Return data:
120 * 1. (str) JSON string
121 *
122 * @param[in] hexwords - Vector of strings of Hexwords 1-9
123 * @param[in] creatorID - The creatorID from the Private Header section
124 * @return std::optional<std::string> - The JSON string if it could be created,
125 * else std::nullopt
126 */
127std::optional<std::string> getPythonJSON(std::vector<std::string>& hexwords,
128 uint8_t creatorID)
129{
Matt Spinlerbe952d22022-07-01 11:30:11 -0500130 PyObject *pName, *pModule, *eType, *eValue, *eTraceback;
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800131 std::string pErrStr;
132 std::string module = getNumberString("%c", tolower(creatorID)) + "src";
133 pName = PyUnicode_FromString(
134 std::string("srcparsers." + module + "." + module).c_str());
135 std::unique_ptr<PyObject, decltype(&pyDecRef)> modNamePtr(pName, &pyDecRef);
136 pModule = PyImport_Import(pName);
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800137 if (pModule == NULL)
138 {
139 pErrStr = "No error string found";
140 PyErr_Fetch(&eType, &eValue, &eTraceback);
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +0800141 if (eType)
142 {
143 Py_XDECREF(eType);
144 }
145 if (eTraceback)
146 {
147 Py_XDECREF(eTraceback);
148 }
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800149 if (eValue)
150 {
151 PyObject* pStr = PyObject_Str(eValue);
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +0800152 Py_XDECREF(eValue);
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800153 if (pStr)
154 {
155 pErrStr = PyUnicode_AsUTF8(pStr);
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +0800156 Py_XDECREF(pStr);
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800157 }
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800158 }
159 }
160 else
161 {
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +0800162 std::unique_ptr<PyObject, decltype(&pyDecRef)> modPtr(pModule,
163 &pyDecRef);
164 std::string funcToCall = "parseSRCToJson";
Matt Spinlerbe952d22022-07-01 11:30:11 -0500165 PyObject* pKey = PyUnicode_FromString(funcToCall.c_str());
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +0800166 std::unique_ptr<PyObject, decltype(&pyDecRef)> keyPtr(pKey, &pyDecRef);
Matt Spinlerbe952d22022-07-01 11:30:11 -0500167 PyObject* pDict = PyModule_GetDict(pModule);
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +0800168 Py_INCREF(pDict);
169 if (!PyDict_Contains(pDict, pKey))
170 {
171 Py_DECREF(pDict);
172 log<level::ERR>(
173 "Python module error",
174 entry("ERROR=%s",
175 std::string(funcToCall + " function missing").c_str()),
176 entry("SRC=%s", hexwords.front().c_str()),
177 entry("PARSER_MODULE=%s", module.c_str()));
178 return std::nullopt;
179 }
Matt Spinlerbe952d22022-07-01 11:30:11 -0500180 PyObject* pFunc = PyDict_GetItemString(pDict, funcToCall.c_str());
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +0800181 Py_DECREF(pDict);
182 Py_INCREF(pFunc);
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800183 if (PyCallable_Check(pFunc))
184 {
Matt Spinlerbe952d22022-07-01 11:30:11 -0500185 PyObject* pArgs = PyTuple_New(9);
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800186 std::unique_ptr<PyObject, decltype(&pyDecRef)> argPtr(pArgs,
187 &pyDecRef);
188 for (size_t i = 0; i < 9; i++)
189 {
Matt Spinlerc1984032023-01-05 10:09:59 -0600190 std::string arg{"00000000"};
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800191 if (i < hexwords.size())
192 {
Matt Spinlerc1984032023-01-05 10:09:59 -0600193 arg = hexwords[i];
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800194 }
Matt Spinlerc1984032023-01-05 10:09:59 -0600195 PyTuple_SetItem(pArgs, i, Py_BuildValue("s", arg.c_str()));
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800196 }
Matt Spinlerbe952d22022-07-01 11:30:11 -0500197 PyObject* pResult = PyObject_CallObject(pFunc, pArgs);
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +0800198 Py_DECREF(pFunc);
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800199 if (pResult)
200 {
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +0800201 std::unique_ptr<PyObject, decltype(&pyDecRef)> resPtr(
202 pResult, &pyDecRef);
Patrick Williams2544b412022-10-04 08:41:06 -0500203 PyObject* pBytes = PyUnicode_AsEncodedString(pResult, "utf-8",
204 "~E~");
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800205 std::unique_ptr<PyObject, decltype(&pyDecRef)> pyBytePtr(
206 pBytes, &pyDecRef);
207 const char* output = PyBytes_AS_STRING(pBytes);
208 try
209 {
Matt Spinlerbb1c1d52021-06-03 13:18:48 -0600210 orderedJSON json = orderedJSON::parse(output);
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +0800211 if ((json.is_object() && !json.empty()) ||
212 (json.is_array() && json.size() > 0) ||
213 (json.is_string() && json != ""))
214 {
215 return prettyJSON(json);
216 }
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800217 }
Patrick Williams66491c62021-10-06 12:23:37 -0500218 catch (const std::exception& e)
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800219 {
220 log<level::ERR>("Bad JSON from parser",
221 entry("ERROR=%s", e.what()),
222 entry("SRC=%s", hexwords.front().c_str()),
223 entry("PARSER_MODULE=%s", module.c_str()));
224 return std::nullopt;
225 }
226 }
227 else
228 {
229 pErrStr = "No error string found";
230 PyErr_Fetch(&eType, &eValue, &eTraceback);
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +0800231 if (eType)
232 {
233 Py_XDECREF(eType);
234 }
235 if (eTraceback)
236 {
237 Py_XDECREF(eTraceback);
238 }
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800239 if (eValue)
240 {
241 PyObject* pStr = PyObject_Str(eValue);
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +0800242 Py_XDECREF(eValue);
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800243 if (pStr)
244 {
245 pErrStr = PyUnicode_AsUTF8(pStr);
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +0800246 Py_XDECREF(pStr);
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800247 }
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800248 }
249 }
250 }
251 }
252 if (!pErrStr.empty())
253 {
Matt Spinler3279cc52022-02-15 11:02:00 -0600254 log<level::DEBUG>("Python exception thrown by parser",
255 entry("ERROR=%s", pErrStr.c_str()),
256 entry("SRC=%s", hexwords.front().c_str()),
257 entry("PARSER_MODULE=%s", module.c_str()));
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800258 }
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800259 return std::nullopt;
260}
261#endif
262
Matt Spinlerf9bae182019-10-09 13:37:38 -0500263void SRC::unflatten(Stream& stream)
264{
265 stream >> _header >> _version >> _flags >> _reserved1B >> _wordCount >>
266 _reserved2B >> _size;
267
268 for (auto& word : _hexData)
269 {
270 stream >> word;
271 }
272
273 _asciiString = std::make_unique<src::AsciiString>(stream);
274
275 if (hasAdditionalSections())
276 {
277 // The callouts section is currently the only extra subsection type
278 _callouts = std::make_unique<src::Callouts>(stream);
279 }
280}
281
Matt Spinler06885452019-11-06 10:35:42 -0600282void SRC::flatten(Stream& stream) const
Matt Spinlerf9bae182019-10-09 13:37:38 -0500283{
284 stream << _header << _version << _flags << _reserved1B << _wordCount
285 << _reserved2B << _size;
286
287 for (auto& word : _hexData)
288 {
289 stream << word;
290 }
291
292 _asciiString->flatten(stream);
293
294 if (_callouts)
295 {
296 _callouts->flatten(stream);
297 }
298}
299
300SRC::SRC(Stream& pel)
301{
302 try
303 {
304 unflatten(pel);
305 validate();
306 }
307 catch (const std::exception& e)
308 {
Matt Spinler8ac20502023-01-04 11:03:58 -0600309 log<level::ERR>(
310 fmt::format("Cannot unflatten SRC: {}", e.what()).c_str());
Matt Spinlerf9bae182019-10-09 13:37:38 -0500311 _valid = false;
312 }
313}
314
Matt Spinler075e5ba2020-02-21 15:46:00 -0600315SRC::SRC(const message::Entry& regEntry, const AdditionalData& additionalData,
Matt Spinler5a90a952020-08-27 09:39:03 -0500316 const nlohmann::json& jsonCallouts, const DataInterfaceBase& dataIface)
Matt Spinlerbd716f02019-10-15 10:54:11 -0500317{
318 _header.id = static_cast<uint16_t>(SectionID::primarySRC);
319 _header.version = srcSectionVersion;
320 _header.subType = srcSectionSubtype;
321 _header.componentID = regEntry.componentID;
322
323 _version = srcVersion;
324
325 _flags = 0;
Vijay Lobof3702bb2021-04-09 15:10:19 -0500326
Matt Spinlerbd716f02019-10-15 10:54:11 -0500327 _reserved1B = 0;
328
329 _wordCount = numSRCHexDataWords + 1;
330
331 _reserved2B = 0;
332
333 // There are multiple fields encoded in the hex data words.
334 std::for_each(_hexData.begin(), _hexData.end(),
335 [](auto& word) { word = 0; });
Matt Spinler7c619182020-07-27 15:15:11 -0500336
337 // Hex Word 2 Nibbles:
338 // MIGVEPFF
339 // M: Partition dump status = 0
340 // I: System boot state = TODO
341 // G: Partition Boot type = 0
Sumit Kumar9d43a722021-08-24 09:46:19 -0500342 // V: BMC dump status
Matt Spinler7c619182020-07-27 15:15:11 -0500343 // E: Platform boot mode = 0 (side = temporary, speed = fast)
Sumit Kumar9d43a722021-08-24 09:46:19 -0500344 // P: Platform dump status
Matt Spinler7c619182020-07-27 15:15:11 -0500345 // FF: SRC format, set below
346
Vijay Lobo875b6c72021-10-20 17:38:56 -0500347 setProgressCode(dataIface);
Sumit Kumar9d43a722021-08-24 09:46:19 -0500348 setDumpStatus(dataIface);
Matt Spinlerbd716f02019-10-15 10:54:11 -0500349 setBMCFormat();
350 setBMCPosition();
Matt Spinler075e5ba2020-02-21 15:46:00 -0600351 setMotherboardCCIN(dataIface);
352
Matt Spinler3fe93e92023-04-14 14:06:59 -0500353 if (regEntry.src.deconfigFlag)
354 {
355 setErrorStatusFlag(ErrorStatusFlags::deconfigured);
356 }
357
Matt Spinlerbd716f02019-10-15 10:54:11 -0500358 // Fill in the last 4 words from the AdditionalData property contents.
359 setUserDefinedHexWords(regEntry, additionalData);
360
361 _asciiString = std::make_unique<src::AsciiString>(regEntry);
362
Sumit Kumar50bfa692022-01-06 06:48:26 -0600363 // Check for additional data - PEL_SUBSYSTEM
364 auto ss = additionalData.getValue("PEL_SUBSYSTEM");
365 if (ss)
366 {
367 auto eventSubsystem = std::stoul(*ss, NULL, 16);
Patrick Williams2544b412022-10-04 08:41:06 -0500368 std::string subsystem = pv::getValue(eventSubsystem,
369 pel_values::subsystemValues);
Sumit Kumar50bfa692022-01-06 06:48:26 -0600370 if (subsystem == "invalid")
371 {
372 log<level::WARNING>(
373 fmt::format("SRC: Invalid SubSystem value:{:#X}",
374 eventSubsystem)
375 .c_str());
376 }
377 else
378 {
379 _asciiString->setByte(2, eventSubsystem);
380 }
381 }
382
Matt Spinler5a90a952020-08-27 09:39:03 -0500383 addCallouts(regEntry, additionalData, jsonCallouts, dataIface);
Matt Spinlerbd716f02019-10-15 10:54:11 -0500384
385 _size = baseSRCSize;
386 _size += _callouts ? _callouts->flattenedSize() : 0;
387 _header.size = Section::flattenedSize() + _size;
388
389 _valid = true;
390}
391
392void SRC::setUserDefinedHexWords(const message::Entry& regEntry,
393 const AdditionalData& ad)
394{
395 if (!regEntry.src.hexwordADFields)
396 {
397 return;
398 }
399
Harisuddin Mohamed Isa1a1b0df2020-11-23 16:34:36 +0800400 // Save the AdditionalData value corresponding to the first element of
401 // adName tuple into _hexData[wordNum].
Matt Spinlerbd716f02019-10-15 10:54:11 -0500402 for (const auto& [wordNum, adName] : *regEntry.src.hexwordADFields)
403 {
404 // Can only set words 6 - 9
405 if (!isUserDefinedWord(wordNum))
406 {
Patrick Williams2544b412022-10-04 08:41:06 -0500407 std::string msg = "SRC user data word out of range: " +
408 std::to_string(wordNum);
Matt Spinler85f61a62020-06-03 16:28:55 -0500409 addDebugData(msg);
Matt Spinlerbd716f02019-10-15 10:54:11 -0500410 continue;
411 }
412
Harisuddin Mohamed Isa1a1b0df2020-11-23 16:34:36 +0800413 auto value = ad.getValue(std::get<0>(adName));
Matt Spinlerbd716f02019-10-15 10:54:11 -0500414 if (value)
415 {
416 _hexData[getWordIndexFromWordNum(wordNum)] =
417 std::strtoul(value.value().c_str(), nullptr, 0);
418 }
419 else
420 {
Harisuddin Mohamed Isa1a1b0df2020-11-23 16:34:36 +0800421 std::string msg = "Source for user data SRC word not found: " +
422 std::get<0>(adName);
Matt Spinler85f61a62020-06-03 16:28:55 -0500423 addDebugData(msg);
Matt Spinlerbd716f02019-10-15 10:54:11 -0500424 }
425 }
426}
427
Matt Spinler075e5ba2020-02-21 15:46:00 -0600428void SRC::setMotherboardCCIN(const DataInterfaceBase& dataIface)
429{
430 uint32_t ccin = 0;
431 auto ccinString = dataIface.getMotherboardCCIN();
432
433 try
434 {
435 if (ccinString.size() == ccinSize)
436 {
437 ccin = std::stoi(ccinString, 0, 16);
438 }
439 }
Patrick Williams66491c62021-10-06 12:23:37 -0500440 catch (const std::exception& e)
Matt Spinler075e5ba2020-02-21 15:46:00 -0600441 {
442 log<level::WARNING>("Could not convert motherboard CCIN to a number",
443 entry("CCIN=%s", ccinString.c_str()));
444 return;
445 }
446
447 // Set the first 2 bytes
448 _hexData[1] |= ccin << 16;
449}
450
Matt Spinlerf9bae182019-10-09 13:37:38 -0500451void SRC::validate()
452{
453 bool failed = false;
454
455 if ((header().id != static_cast<uint16_t>(SectionID::primarySRC)) &&
456 (header().id != static_cast<uint16_t>(SectionID::secondarySRC)))
457 {
Matt Spinler8ac20502023-01-04 11:03:58 -0600458 log<level::ERR>(
459 fmt::format("Invalid SRC section ID: {0:#x}", header().id).c_str());
Matt Spinlerf9bae182019-10-09 13:37:38 -0500460 failed = true;
461 }
462
463 // Check the version in the SRC, not in the header
Matt Spinlerbd716f02019-10-15 10:54:11 -0500464 if (_version != srcVersion)
Matt Spinlerf9bae182019-10-09 13:37:38 -0500465 {
Matt Spinler8ac20502023-01-04 11:03:58 -0600466 log<level::ERR>(
467 fmt::format("Invalid SRC version: {0:#x}", header().version)
468 .c_str());
Matt Spinlerf9bae182019-10-09 13:37:38 -0500469 failed = true;
470 }
471
472 _valid = failed ? false : true;
473}
474
Matt Spinler075e5ba2020-02-21 15:46:00 -0600475bool SRC::isBMCSRC() const
476{
477 auto as = asciiString();
478 if (as.length() >= 2)
479 {
480 uint8_t errorType = strtoul(as.substr(0, 2).c_str(), nullptr, 16);
481 return (errorType == static_cast<uint8_t>(SRCType::bmcError) ||
482 errorType == static_cast<uint8_t>(SRCType::powerError));
483 }
484 return false;
485}
486
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800487std::optional<std::string> SRC::getErrorDetails(message::Registry& registry,
488 DetailLevel type,
489 bool toCache) const
490{
491 const std::string jsonIndent(indentLevel, 0x20);
492 std::string errorOut;
Matt Spinler075e5ba2020-02-21 15:46:00 -0600493 if (isBMCSRC())
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800494 {
495 auto entry = registry.lookup("0x" + asciiString().substr(4, 4),
496 rg::LookupType::reasonCode, toCache);
497 if (entry)
498 {
499 errorOut.append(jsonIndent + "\"Error Details\": {\n");
500 auto errorMsg = getErrorMessage(*entry);
501 if (errorMsg)
502 {
503 if (type == DetailLevel::message)
504 {
505 return errorMsg.value();
506 }
507 else
508 {
509 jsonInsert(errorOut, "Message", errorMsg.value(), 2);
510 }
511 }
512 if (entry->src.hexwordADFields)
513 {
Harisuddin Mohamed Isa1a1b0df2020-11-23 16:34:36 +0800514 std::map<size_t, std::tuple<std::string, std::string>>
515 adFields = entry->src.hexwordADFields.value();
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800516 for (const auto& hexwordMap : adFields)
517 {
Zane Shelleye8db29b2021-11-13 10:34:07 -0600518 auto srcValue = getNumberString(
Harisuddin Mohamed Isa1a1b0df2020-11-23 16:34:36 +0800519 "0x%X",
Zane Shelleye8db29b2021-11-13 10:34:07 -0600520 _hexData[getWordIndexFromWordNum(hexwordMap.first)]);
521
522 auto srcKey = std::get<0>(hexwordMap.second);
523 auto srcDesc = std::get<1>(hexwordMap.second);
524
525 // Only include this hex word in the error details if the
526 // description exists.
527 if (!srcDesc.empty())
528 {
529 std::vector<std::string> valueDescr;
530 valueDescr.push_back(srcValue);
531 valueDescr.push_back(srcDesc);
532 jsonInsertArray(errorOut, srcKey, valueDescr, 2);
533 }
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800534 }
535 }
536 errorOut.erase(errorOut.size() - 2);
537 errorOut.append("\n");
538 errorOut.append(jsonIndent + "},\n");
539 return errorOut;
540 }
541 }
542 return std::nullopt;
543}
544
545std::optional<std::string>
546 SRC::getErrorMessage(const message::Entry& regEntry) const
547{
548 try
549 {
550 if (regEntry.doc.messageArgSources)
551 {
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800552 std::vector<uint32_t> argSourceVals;
553 std::string message;
554 const auto& argValues = regEntry.doc.messageArgSources.value();
555 for (size_t i = 0; i < argValues.size(); ++i)
556 {
557 argSourceVals.push_back(_hexData[getWordIndexFromWordNum(
558 argValues[i].back() - '0')]);
559 }
Patrick Williams0230abb2021-04-19 14:32:50 -0500560
561 auto it = std::begin(regEntry.doc.message);
562 auto it_end = std::end(regEntry.doc.message);
563
564 while (it != it_end)
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800565 {
Patrick Williams0230abb2021-04-19 14:32:50 -0500566 if (*it == '%')
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800567 {
Patrick Williams0230abb2021-04-19 14:32:50 -0500568 ++it;
569
570 size_t wordIndex = *it - '0';
571 if (isdigit(*it) && wordIndex >= 1 &&
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800572 static_cast<uint16_t>(wordIndex) <=
573 argSourceVals.size())
574 {
575 message.append(getNumberString(
Zane Shelley39936e32021-11-13 16:19:34 -0600576 "0x%08X", argSourceVals[wordIndex - 1]));
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800577 }
578 else
579 {
Patrick Williams0230abb2021-04-19 14:32:50 -0500580 message.append("%" + std::string(1, *it));
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800581 }
582 }
583 else
584 {
Patrick Williams0230abb2021-04-19 14:32:50 -0500585 message.push_back(*it);
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800586 }
Patrick Williams0230abb2021-04-19 14:32:50 -0500587 ++it;
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800588 }
Patrick Williams0230abb2021-04-19 14:32:50 -0500589
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800590 return message;
591 }
592 else
593 {
594 return regEntry.doc.message;
595 }
596 }
597 catch (const std::exception& e)
598 {
599 log<level::ERR>("Cannot get error message from registry entry",
600 entry("ERROR=%s", e.what()));
601 }
602 return std::nullopt;
603}
604
605std::optional<std::string> SRC::getCallouts() const
606{
607 if (!_callouts)
608 {
609 return std::nullopt;
610 }
611 std::string printOut;
612 const std::string jsonIndent(indentLevel, 0x20);
613 const auto& callout = _callouts->callouts();
614 const auto& compDescrp = pv::failingComponentType;
615 printOut.append(jsonIndent + "\"Callout Section\": {\n");
616 jsonInsert(printOut, "Callout Count", std::to_string(callout.size()), 2);
617 printOut.append(jsonIndent + jsonIndent + "\"Callouts\": [");
618 for (auto& entry : callout)
619 {
620 printOut.append("{\n");
621 if (entry->fruIdentity())
622 {
623 jsonInsert(
624 printOut, "FRU Type",
625 compDescrp.at(entry->fruIdentity()->failingComponentType()), 3);
626 jsonInsert(printOut, "Priority",
627 pv::getValue(entry->priority(),
628 pel_values::calloutPriorityValues),
629 3);
630 if (!entry->locationCode().empty())
631 {
632 jsonInsert(printOut, "Location Code", entry->locationCode(), 3);
633 }
634 if (entry->fruIdentity()->getPN().has_value())
635 {
636 jsonInsert(printOut, "Part Number",
637 entry->fruIdentity()->getPN().value(), 3);
638 }
639 if (entry->fruIdentity()->getMaintProc().has_value())
640 {
Matt Spinler9e8b49e2020-09-10 13:15:26 -0500641 jsonInsert(printOut, "Procedure",
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800642 entry->fruIdentity()->getMaintProc().value(), 3);
643 if (pv::procedureDesc.find(
644 entry->fruIdentity()->getMaintProc().value()) !=
645 pv::procedureDesc.end())
646 {
647 jsonInsert(
648 printOut, "Description",
649 pv::procedureDesc.at(
650 entry->fruIdentity()->getMaintProc().value()),
651 3);
652 }
653 }
654 if (entry->fruIdentity()->getCCIN().has_value())
655 {
656 jsonInsert(printOut, "CCIN",
657 entry->fruIdentity()->getCCIN().value(), 3);
658 }
659 if (entry->fruIdentity()->getSN().has_value())
660 {
661 jsonInsert(printOut, "Serial Number",
662 entry->fruIdentity()->getSN().value(), 3);
663 }
664 }
665 if (entry->pceIdentity())
666 {
667 const auto& pceIdentMtms = entry->pceIdentity()->mtms();
668 if (!pceIdentMtms.machineTypeAndModel().empty())
669 {
670 jsonInsert(printOut, "PCE MTMS",
671 pceIdentMtms.machineTypeAndModel() + "_" +
672 pceIdentMtms.machineSerialNumber(),
673 3);
674 }
675 if (!entry->pceIdentity()->enclosureName().empty())
676 {
677 jsonInsert(printOut, "PCE Name",
678 entry->pceIdentity()->enclosureName(), 3);
679 }
680 }
681 if (entry->mru())
682 {
683 const auto& mruCallouts = entry->mru()->mrus();
684 std::string mruId;
685 for (auto& element : mruCallouts)
686 {
687 if (!mruId.empty())
688 {
689 mruId.append(", " + getNumberString("%08X", element.id));
690 }
691 else
692 {
693 mruId.append(getNumberString("%08X", element.id));
694 }
695 }
696 jsonInsert(printOut, "MRU Id", mruId, 3);
697 }
698 printOut.erase(printOut.size() - 2);
699 printOut.append("\n" + jsonIndent + jsonIndent + "}, ");
700 };
701 printOut.erase(printOut.size() - 2);
702 printOut.append("]\n" + jsonIndent + "}");
703 return printOut;
704}
705
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800706std::optional<std::string> SRC::getJSON(message::Registry& registry,
Patrick Williamsd26fa3e2021-04-21 15:22:23 -0500707 const std::vector<std::string>& plugins
708 [[maybe_unused]],
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800709 uint8_t creatorID) const
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800710{
711 std::string ps;
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800712 std::vector<std::string> hexwords;
Harisuddin Mohamed Isabebeb942020-03-12 17:12:24 +0800713 jsonInsert(ps, pv::sectionVer, getNumberString("%d", _header.version), 1);
714 jsonInsert(ps, pv::subSection, getNumberString("%d", _header.subType), 1);
Matt Spinlerb832aa52023-03-21 15:32:34 -0500715 jsonInsert(ps, pv::createdBy,
716 getComponentName(_header.componentID, creatorID), 1);
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800717 jsonInsert(ps, "SRC Version", getNumberString("0x%02X", _version), 1);
Harisuddin Mohamed Isac32e5512020-02-06 18:05:21 +0800718 jsonInsert(ps, "SRC Format", getNumberString("0x%02X", _hexData[0] & 0xFF),
719 1);
720 jsonInsert(ps, "Virtual Progress SRC",
721 pv::boolString.at(_flags & virtualProgressSRC), 1);
722 jsonInsert(ps, "I5/OS Service Event Bit",
723 pv::boolString.at(_flags & i5OSServiceEventBit), 1);
724 jsonInsert(ps, "Hypervisor Dump Initiated",
725 pv::boolString.at(_flags & hypDumpInit), 1);
Matt Spinler075e5ba2020-02-21 15:46:00 -0600726
727 if (isBMCSRC())
728 {
729 std::string ccinString;
730 uint32_t ccin = _hexData[1] >> 16;
731
732 if (ccin)
733 {
734 ccinString = getNumberString("%04X", ccin);
735 }
736 // The PEL spec calls it a backplane, so call it that here.
737 jsonInsert(ps, "Backplane CCIN", ccinString, 1);
Matt Spinlerafa2c792020-08-27 11:01:39 -0500738
Sumit Kumar3e274432021-09-14 06:37:56 -0500739 jsonInsert(ps, "Terminate FW Error",
740 pv::boolString.at(
741 _hexData[3] &
742 static_cast<uint32_t>(ErrorStatusFlags::terminateFwErr)),
743 1);
Matt Spinlerafa2c792020-08-27 11:01:39 -0500744 jsonInsert(ps, "Deconfigured",
745 pv::boolString.at(
746 _hexData[3] &
747 static_cast<uint32_t>(ErrorStatusFlags::deconfigured)),
748 1);
749
750 jsonInsert(
751 ps, "Guarded",
752 pv::boolString.at(_hexData[3] &
753 static_cast<uint32_t>(ErrorStatusFlags::guarded)),
754 1);
Matt Spinler075e5ba2020-02-21 15:46:00 -0600755 }
756
Harisuddin Mohamed Isaa214ed32020-02-28 15:58:23 +0800757 auto errorDetails = getErrorDetails(registry, DetailLevel::json, true);
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800758 if (errorDetails)
759 {
760 ps.append(errorDetails.value());
761 }
762 jsonInsert(ps, "Valid Word Count", getNumberString("0x%02X", _wordCount),
763 1);
764 std::string refcode = asciiString();
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800765 hexwords.push_back(refcode);
Harisuddin Mohamed Isafecaa572020-03-11 16:04:50 +0800766 std::string extRefcode;
767 size_t pos = refcode.find(0x20);
768 if (pos != std::string::npos)
769 {
770 size_t nextPos = refcode.find_first_not_of(0x20, pos);
771 if (nextPos != std::string::npos)
772 {
773 extRefcode = trimEnd(refcode.substr(nextPos));
774 }
775 refcode.erase(pos);
776 }
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800777 jsonInsert(ps, "Reference Code", refcode, 1);
Harisuddin Mohamed Isafecaa572020-03-11 16:04:50 +0800778 if (!extRefcode.empty())
779 {
780 jsonInsert(ps, "Extended Reference Code", extRefcode, 1);
781 }
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800782 for (size_t i = 2; i <= _wordCount; i++)
783 {
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800784 std::string tmpWord =
785 getNumberString("%08X", _hexData[getWordIndexFromWordNum(i)]);
786 jsonInsert(ps, "Hex Word " + std::to_string(i), tmpWord, 1);
787 hexwords.push_back(tmpWord);
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800788 }
789 auto calloutJson = getCallouts();
790 if (calloutJson)
791 {
792 ps.append(calloutJson.value());
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800793 ps.append(",\n");
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800794 }
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800795 std::string subsystem = getNumberString("%c", tolower(creatorID));
796 bool srcDetailExists = false;
797#ifdef PELTOOL
798 if (std::find(plugins.begin(), plugins.end(), subsystem + "src") !=
799 plugins.end())
800 {
801 auto pyJson = getPythonJSON(hexwords, creatorID);
802 if (pyJson)
803 {
804 ps.append(pyJson.value());
805 srcDetailExists = true;
806 }
807 }
808#endif
809 if (!srcDetailExists)
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800810 {
811 ps.erase(ps.size() - 2);
812 }
813 return ps;
814}
815
Matt Spinler03984582020-04-09 13:17:58 -0500816void SRC::addCallouts(const message::Entry& regEntry,
817 const AdditionalData& additionalData,
Matt Spinler5a90a952020-08-27 09:39:03 -0500818 const nlohmann::json& jsonCallouts,
Matt Spinlered046852020-03-13 13:58:15 -0500819 const DataInterfaceBase& dataIface)
820{
Patrick Williams2544b412022-10-04 08:41:06 -0500821 auto registryCallouts = getRegistryCallouts(regEntry, additionalData,
822 dataIface);
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500823
Matt Spinlered046852020-03-13 13:58:15 -0500824 auto item = additionalData.getValue("CALLOUT_INVENTORY_PATH");
Miguel Gomez53ef1552020-10-14 21:16:32 +0000825 auto priority = additionalData.getValue("CALLOUT_PRIORITY");
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500826
Miguel Gomez53ef1552020-10-14 21:16:32 +0000827 std::optional<CalloutPriority> calloutPriority;
828
829 // Only H, M or L priority values.
830 if (priority && !(*priority).empty())
831 {
832 uint8_t p = (*priority)[0];
833 if (p == 'H' || p == 'M' || p == 'L')
834 {
835 calloutPriority = static_cast<CalloutPriority>(p);
836 }
837 }
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500838 // If the first registry callout says to use the passed in inventory
839 // path to get the location code for a symbolic FRU callout with a
840 // trusted location code, then do not add the inventory path as a
841 // normal FRU callout.
842 bool useInvForSymbolicFRULocCode =
843 !registryCallouts.empty() && registryCallouts[0].useInventoryLocCode &&
844 !registryCallouts[0].symbolicFRUTrusted.empty();
845
846 if (item && !useInvForSymbolicFRULocCode)
Matt Spinlered046852020-03-13 13:58:15 -0500847 {
Miguel Gomez53ef1552020-10-14 21:16:32 +0000848 addInventoryCallout(*item, calloutPriority, std::nullopt, dataIface);
Matt Spinlered046852020-03-13 13:58:15 -0500849 }
850
Matt Spinler717de422020-06-04 13:10:14 -0500851 addDevicePathCallouts(additionalData, dataIface);
Matt Spinler03984582020-04-09 13:17:58 -0500852
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500853 addRegistryCallouts(registryCallouts, dataIface,
854 (useInvForSymbolicFRULocCode) ? item : std::nullopt);
Matt Spinler5a90a952020-08-27 09:39:03 -0500855
856 if (!jsonCallouts.empty())
857 {
858 addJSONCallouts(jsonCallouts, dataIface);
859 }
Matt Spinlered046852020-03-13 13:58:15 -0500860}
861
862void SRC::addInventoryCallout(const std::string& inventoryPath,
Matt Spinleraf191c72020-06-04 11:35:13 -0500863 const std::optional<CalloutPriority>& priority,
864 const std::optional<std::string>& locationCode,
Matt Spinlerb8cb60f2020-08-27 10:55:55 -0500865 const DataInterfaceBase& dataIface,
866 const std::vector<src::MRU::MRUCallout>& mrus)
Matt Spinlered046852020-03-13 13:58:15 -0500867{
868 std::string locCode;
869 std::string fn;
870 std::string ccin;
871 std::string sn;
872 std::unique_ptr<src::Callout> callout;
873
Matt Spinlered046852020-03-13 13:58:15 -0500874 try
875 {
Matt Spinleraf191c72020-06-04 11:35:13 -0500876 // Use the passed in location code if there otherwise look it up
877 if (locationCode)
878 {
879 locCode = *locationCode;
880 }
881 else
882 {
883 locCode = dataIface.getLocationCode(inventoryPath);
884 }
Matt Spinlered046852020-03-13 13:58:15 -0500885
Matt Spinler9b90e2a2020-04-14 10:59:04 -0500886 try
887 {
888 dataIface.getHWCalloutFields(inventoryPath, fn, ccin, sn);
889
Patrick Williams2544b412022-10-04 08:41:06 -0500890 CalloutPriority p = priority ? priority.value()
891 : CalloutPriority::high;
Matt Spinleraf191c72020-06-04 11:35:13 -0500892
Patrick Williams2544b412022-10-04 08:41:06 -0500893 callout = std::make_unique<src::Callout>(p, locCode, fn, ccin, sn,
894 mrus);
Matt Spinler9b90e2a2020-04-14 10:59:04 -0500895 }
Patrick Williams45e83522022-07-22 19:26:52 -0500896 catch (const sdbusplus::exception_t& e)
Matt Spinler9b90e2a2020-04-14 10:59:04 -0500897 {
Patrick Williams2544b412022-10-04 08:41:06 -0500898 std::string msg = "No VPD found for " + inventoryPath + ": " +
899 e.what();
Matt Spinler85f61a62020-06-03 16:28:55 -0500900 addDebugData(msg);
Matt Spinler9b90e2a2020-04-14 10:59:04 -0500901
902 // Just create the callout with empty FRU fields
Matt Spinlerb8cb60f2020-08-27 10:55:55 -0500903 callout = std::make_unique<src::Callout>(
904 CalloutPriority::high, locCode, fn, ccin, sn, mrus);
Matt Spinler9b90e2a2020-04-14 10:59:04 -0500905 }
Matt Spinlered046852020-03-13 13:58:15 -0500906 }
Patrick Williams45e83522022-07-22 19:26:52 -0500907 catch (const sdbusplus::exception_t& e)
Matt Spinlered046852020-03-13 13:58:15 -0500908 {
Matt Spinler85f61a62020-06-03 16:28:55 -0500909 std::string msg = "Could not get location code for " + inventoryPath +
910 ": " + e.what();
911 addDebugData(msg);
Matt Spinlered046852020-03-13 13:58:15 -0500912
Matt Spinler479b6922021-08-17 16:34:59 -0500913 // Don't add a callout in this case, because:
914 // 1) With how the inventory is primed, there is no case where
915 // a location code is expected to be missing. This implies
916 // the caller is passing in something invalid.
917 // 2) The addDebugData call above will put the passed in path into
918 // a user data section that can be seen by development for debug.
919 // 3) Even if we wanted to do a 'no_vpd_for_fru' sort of maint.
920 // procedure, we don't have a good way to indicate to the user
921 // anything about the intended callout (they won't see user data).
922 // 4) Creating a new standalone event log for this problem isn't
923 // possible from inside a PEL section.
Matt Spinlered046852020-03-13 13:58:15 -0500924 }
925
Matt Spinler479b6922021-08-17 16:34:59 -0500926 if (callout)
927 {
928 createCalloutsObject();
929 _callouts->addCallout(std::move(callout));
930 }
Matt Spinler03984582020-04-09 13:17:58 -0500931}
Matt Spinlered046852020-03-13 13:58:15 -0500932
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500933std::vector<message::RegistryCallout>
934 SRC::getRegistryCallouts(const message::Entry& regEntry,
935 const AdditionalData& additionalData,
936 const DataInterfaceBase& dataIface)
937{
938 std::vector<message::RegistryCallout> registryCallouts;
939
940 if (regEntry.callouts)
941 {
Matt Spinler9a50c8d2021-04-12 14:22:26 -0500942 std::vector<std::string> systemNames;
943
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500944 try
945 {
Matt Spinler9a50c8d2021-04-12 14:22:26 -0500946 systemNames = dataIface.getSystemNames();
947 }
948 catch (const std::exception& e)
949 {
950 // Compatible interface not available yet
951 }
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500952
Matt Spinler9a50c8d2021-04-12 14:22:26 -0500953 try
954 {
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500955 registryCallouts = message::Registry::getCallouts(
956 regEntry.callouts.value(), systemNames, additionalData);
957 }
958 catch (const std::exception& e)
959 {
960 addDebugData(fmt::format(
961 "Error parsing PEL message registry callout JSON: {}",
962 e.what()));
963 }
964 }
965
966 return registryCallouts;
967}
968
969void SRC::addRegistryCallouts(
970 const std::vector<message::RegistryCallout>& callouts,
971 const DataInterfaceBase& dataIface,
972 std::optional<std::string> trustedSymbolicFRUInvPath)
Matt Spinler03984582020-04-09 13:17:58 -0500973{
974 try
975 {
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500976 for (const auto& callout : callouts)
Matt Spinler03984582020-04-09 13:17:58 -0500977 {
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500978 addRegistryCallout(callout, dataIface, trustedSymbolicFRUInvPath);
979
980 // Only the first callout gets the inventory path
981 if (trustedSymbolicFRUInvPath)
982 {
983 trustedSymbolicFRUInvPath = std::nullopt;
984 }
Matt Spinler03984582020-04-09 13:17:58 -0500985 }
986 }
Patrick Williams66491c62021-10-06 12:23:37 -0500987 catch (const std::exception& e)
Matt Spinler03984582020-04-09 13:17:58 -0500988 {
Patrick Williams2544b412022-10-04 08:41:06 -0500989 std::string msg = "Error parsing PEL message registry callout JSON: "s +
990 e.what();
Matt Spinler85f61a62020-06-03 16:28:55 -0500991 addDebugData(msg);
Matt Spinler03984582020-04-09 13:17:58 -0500992 }
993}
994
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500995void SRC::addRegistryCallout(
996 const message::RegistryCallout& regCallout,
997 const DataInterfaceBase& dataIface,
998 const std::optional<std::string>& trustedSymbolicFRUInvPath)
Matt Spinler03984582020-04-09 13:17:58 -0500999{
1000 std::unique_ptr<src::Callout> callout;
Matt Spinler03984582020-04-09 13:17:58 -05001001 auto locCode = regCallout.locCode;
1002
Matt Spinleraf191c72020-06-04 11:35:13 -05001003 if (!locCode.empty())
1004 {
1005 try
1006 {
1007 locCode = dataIface.expandLocationCode(locCode, 0);
1008 }
1009 catch (const std::exception& e)
1010 {
Patrick Williams2544b412022-10-04 08:41:06 -05001011 auto msg = "Unable to expand location code " + locCode + ": " +
1012 e.what();
Matt Spinleraf191c72020-06-04 11:35:13 -05001013 addDebugData(msg);
1014 return;
1015 }
1016 }
1017
Matt Spinler03984582020-04-09 13:17:58 -05001018 // Via the PEL values table, get the priority enum.
1019 // The schema will have validated the priority was a valid value.
Patrick Williams2544b412022-10-04 08:41:06 -05001020 auto priorityIt = pv::findByName(regCallout.priority,
1021 pv::calloutPriorityValues);
Matt Spinler03984582020-04-09 13:17:58 -05001022 assert(priorityIt != pv::calloutPriorityValues.end());
1023 auto priority =
1024 static_cast<CalloutPriority>(std::get<pv::fieldValuePos>(*priorityIt));
1025
1026 if (!regCallout.procedure.empty())
1027 {
1028 // Procedure callout
Patrick Williams2544b412022-10-04 08:41:06 -05001029 callout = std::make_unique<src::Callout>(priority,
1030 regCallout.procedure);
Matt Spinler03984582020-04-09 13:17:58 -05001031 }
1032 else if (!regCallout.symbolicFRU.empty())
1033 {
1034 // Symbolic FRU callout
1035 callout = std::make_unique<src::Callout>(
1036 priority, regCallout.symbolicFRU, locCode, false);
1037 }
1038 else if (!regCallout.symbolicFRUTrusted.empty())
1039 {
1040 // Symbolic FRU with trusted location code callout
1041
Matt Spinlerf00f9d02020-10-23 09:14:22 -05001042 // Use the location code from the inventory path if there is one.
1043 if (trustedSymbolicFRUInvPath)
1044 {
1045 try
1046 {
1047 locCode = dataIface.getLocationCode(*trustedSymbolicFRUInvPath);
1048 }
1049 catch (const std::exception& e)
1050 {
1051 addDebugData(
1052 fmt::format("Could not get location code for {}: {}",
1053 *trustedSymbolicFRUInvPath, e.what()));
1054 locCode.clear();
1055 }
1056 }
1057
Matt Spinler03984582020-04-09 13:17:58 -05001058 // The registry wants it to be trusted, but that requires a valid
1059 // location code for it to actually be.
1060 callout = std::make_unique<src::Callout>(
1061 priority, regCallout.symbolicFRUTrusted, locCode, !locCode.empty());
1062 }
1063 else
1064 {
Matt Spinleraf191c72020-06-04 11:35:13 -05001065 // A hardware callout
Matt Spinlerbad056b2023-01-25 14:16:57 -06001066 std::vector<std::string> inventoryPaths;
Matt Spinleraf191c72020-06-04 11:35:13 -05001067
1068 try
1069 {
1070 // Get the inventory item from the unexpanded location code
Matt Spinlerbad056b2023-01-25 14:16:57 -06001071 inventoryPaths =
Matt Spinler2f9225a2020-08-05 12:58:49 -05001072 dataIface.getInventoryFromLocCode(regCallout.locCode, 0, false);
Matt Spinleraf191c72020-06-04 11:35:13 -05001073 }
1074 catch (const std::exception& e)
1075 {
1076 std::string msg =
1077 "Unable to get inventory path from location code: " + locCode +
1078 ": " + e.what();
1079 addDebugData(msg);
1080 return;
1081 }
1082
Matt Spinlerbad056b2023-01-25 14:16:57 -06001083 // Just use first path returned since they all point to the same FRU.
1084 addInventoryCallout(inventoryPaths[0], priority, locCode, dataIface);
Matt Spinler03984582020-04-09 13:17:58 -05001085 }
1086
1087 if (callout)
1088 {
1089 createCalloutsObject();
1090 _callouts->addCallout(std::move(callout));
1091 }
1092}
Matt Spinlered046852020-03-13 13:58:15 -05001093
Matt Spinler717de422020-06-04 13:10:14 -05001094void SRC::addDevicePathCallouts(const AdditionalData& additionalData,
1095 const DataInterfaceBase& dataIface)
1096{
1097 std::vector<device_callouts::Callout> callouts;
1098 auto i2cBus = additionalData.getValue("CALLOUT_IIC_BUS");
1099 auto i2cAddr = additionalData.getValue("CALLOUT_IIC_ADDR");
1100 auto devPath = additionalData.getValue("CALLOUT_DEVICE_PATH");
1101
1102 // A device callout contains either:
1103 // * CALLOUT_ERRNO, CALLOUT_DEVICE_PATH
1104 // * CALLOUT_ERRNO, CALLOUT_IIC_BUS, CALLOUT_IIC_ADDR
1105 // We don't care about the errno.
1106
1107 if (devPath)
1108 {
1109 try
1110 {
1111 callouts = device_callouts::getCallouts(*devPath,
1112 dataIface.getSystemNames());
1113 }
1114 catch (const std::exception& e)
1115 {
1116 addDebugData(e.what());
1117 callouts.clear();
1118 }
1119 }
1120 else if (i2cBus && i2cAddr)
1121 {
1122 size_t bus;
1123 uint8_t address;
1124
1125 try
1126 {
1127 // If /dev/i2c- is prepended, remove it
1128 if (i2cBus->find("/dev/i2c-") != std::string::npos)
1129 {
1130 *i2cBus = i2cBus->substr(9);
1131 }
1132
1133 bus = stoul(*i2cBus, nullptr, 0);
1134 address = stoul(*i2cAddr, nullptr, 0);
1135 }
1136 catch (const std::exception& e)
1137 {
1138 std::string msg = "Invalid CALLOUT_IIC_BUS " + *i2cBus +
1139 " or CALLOUT_IIC_ADDR " + *i2cAddr +
1140 " in AdditionalData property";
1141 addDebugData(msg);
1142 return;
1143 }
1144
1145 try
1146 {
1147 callouts = device_callouts::getI2CCallouts(
1148 bus, address, dataIface.getSystemNames());
1149 }
1150 catch (const std::exception& e)
1151 {
1152 addDebugData(e.what());
1153 callouts.clear();
1154 }
1155 }
1156
1157 for (const auto& callout : callouts)
1158 {
1159 // The priority shouldn't be invalid, but check just in case.
1160 CalloutPriority priority = CalloutPriority::high;
1161
1162 if (!callout.priority.empty())
1163 {
1164 auto p = pel_values::findByValue(
1165 static_cast<uint32_t>(callout.priority[0]),
1166 pel_values::calloutPriorityValues);
1167
1168 if (p != pel_values::calloutPriorityValues.end())
1169 {
1170 priority = static_cast<CalloutPriority>(callout.priority[0]);
1171 }
1172 else
1173 {
1174 std::string msg =
1175 "Invalid priority found in dev callout JSON: " +
1176 callout.priority[0];
1177 addDebugData(msg);
1178 }
1179 }
1180
Matt Spinler0d92b522021-06-16 13:28:17 -06001181 std::optional<std::string> locCode;
1182
1183 try
1184 {
1185 locCode = dataIface.expandLocationCode(callout.locationCode, 0);
1186 }
1187 catch (const std::exception& e)
1188 {
1189 auto msg = fmt::format("Unable to expand location code {}: {}",
1190 callout.locationCode, e.what());
1191 addDebugData(msg);
1192 }
1193
Matt Spinler717de422020-06-04 13:10:14 -05001194 try
1195 {
Matt Spinlerbad056b2023-01-25 14:16:57 -06001196 auto inventoryPaths = dataIface.getInventoryFromLocCode(
Matt Spinler2f9225a2020-08-05 12:58:49 -05001197 callout.locationCode, 0, false);
Matt Spinler717de422020-06-04 13:10:14 -05001198
Matt Spinlerbad056b2023-01-25 14:16:57 -06001199 // Just use first path returned since they all
1200 // point to the same FRU.
1201 addInventoryCallout(inventoryPaths[0], priority, locCode,
1202 dataIface);
Matt Spinler717de422020-06-04 13:10:14 -05001203 }
1204 catch (const std::exception& e)
1205 {
1206 std::string msg =
1207 "Unable to get inventory path from location code: " +
1208 callout.locationCode + ": " + e.what();
1209 addDebugData(msg);
1210 }
1211
1212 // Until the code is there to convert these MRU value strings to
1213 // the official MRU values in the callout objects, just store
1214 // the MRU name in the debug UserData section.
1215 if (!callout.mru.empty())
1216 {
1217 std::string msg = "MRU: " + callout.mru;
1218 addDebugData(msg);
1219 }
1220
1221 // getCallouts() may have generated some debug data it stored
1222 // in a callout object. Save it as well.
1223 if (!callout.debug.empty())
1224 {
1225 addDebugData(callout.debug);
1226 }
1227 }
1228}
1229
Matt Spinler5a90a952020-08-27 09:39:03 -05001230void SRC::addJSONCallouts(const nlohmann::json& jsonCallouts,
1231 const DataInterfaceBase& dataIface)
1232{
1233 if (jsonCallouts.empty())
1234 {
1235 return;
1236 }
1237
1238 if (!jsonCallouts.is_array())
1239 {
1240 addDebugData("Callout JSON isn't an array");
1241 return;
1242 }
1243
1244 for (const auto& callout : jsonCallouts)
1245 {
1246 try
1247 {
1248 addJSONCallout(callout, dataIface);
1249 }
1250 catch (const std::exception& e)
1251 {
1252 addDebugData(fmt::format(
1253 "Failed extracting callout data from JSON: {}", e.what()));
1254 }
1255 }
1256}
1257
1258void SRC::addJSONCallout(const nlohmann::json& jsonCallout,
1259 const DataInterfaceBase& dataIface)
1260{
Matt Spinler3bdd0112020-08-27 10:24:34 -05001261 auto priority = getPriorityFromJSON(jsonCallout);
1262 std::string locCode;
1263 std::string unexpandedLocCode;
1264 std::unique_ptr<src::Callout> callout;
1265
1266 // Expand the location code if it's there
1267 if (jsonCallout.contains("LocationCode"))
1268 {
1269 unexpandedLocCode = jsonCallout.at("LocationCode").get<std::string>();
1270
1271 try
1272 {
1273 locCode = dataIface.expandLocationCode(unexpandedLocCode, 0);
1274 }
1275 catch (const std::exception& e)
1276 {
1277 addDebugData(fmt::format("Unable to expand location code {}: {}",
1278 unexpandedLocCode, e.what()));
1279 // Use the value from the JSON so at least there's something
1280 locCode = unexpandedLocCode;
1281 }
1282 }
1283
1284 // Create either a procedure, symbolic FRU, or normal FRU callout.
1285 if (jsonCallout.contains("Procedure"))
1286 {
1287 auto procedure = jsonCallout.at("Procedure").get<std::string>();
1288
Matt Spinler3c7ec6d2022-05-06 08:50:20 -05001289 // If it's the registry name instead of the raw name, convert.
1290 if (pv::maintenanceProcedures.find(procedure) !=
1291 pv::maintenanceProcedures.end())
1292 {
1293 procedure = pv::maintenanceProcedures.at(procedure);
1294 }
1295
Matt Spinler3bdd0112020-08-27 10:24:34 -05001296 callout = std::make_unique<src::Callout>(
1297 static_cast<CalloutPriority>(priority), procedure,
1298 src::CalloutValueType::raw);
1299 }
1300 else if (jsonCallout.contains("SymbolicFRU"))
1301 {
1302 auto fru = jsonCallout.at("SymbolicFRU").get<std::string>();
1303
Matt Spinler3c7ec6d2022-05-06 08:50:20 -05001304 // If it's the registry name instead of the raw name, convert.
1305 if (pv::symbolicFRUs.find(fru) != pv::symbolicFRUs.end())
1306 {
1307 fru = pv::symbolicFRUs.at(fru);
1308 }
1309
Matt Spinler3bdd0112020-08-27 10:24:34 -05001310 bool trusted = false;
1311 if (jsonCallout.contains("TrustedLocationCode") && !locCode.empty())
1312 {
1313 trusted = jsonCallout.at("TrustedLocationCode").get<bool>();
1314 }
1315
1316 callout = std::make_unique<src::Callout>(
1317 static_cast<CalloutPriority>(priority), fru,
1318 src::CalloutValueType::raw, locCode, trusted);
1319 }
1320 else
1321 {
1322 // A hardware FRU
1323 std::string inventoryPath;
Matt Spinlerb8cb60f2020-08-27 10:55:55 -05001324 std::vector<src::MRU::MRUCallout> mrus;
Matt Spinler3bdd0112020-08-27 10:24:34 -05001325
1326 if (jsonCallout.contains("InventoryPath"))
1327 {
1328 inventoryPath = jsonCallout.at("InventoryPath").get<std::string>();
1329 }
1330 else
1331 {
1332 if (unexpandedLocCode.empty())
1333 {
1334 throw std::runtime_error{"JSON callout needs either an "
1335 "inventory path or location code"};
1336 }
1337
1338 try
1339 {
Matt Spinlerbad056b2023-01-25 14:16:57 -06001340 auto inventoryPaths = dataIface.getInventoryFromLocCode(
Matt Spinler3bdd0112020-08-27 10:24:34 -05001341 unexpandedLocCode, 0, false);
Matt Spinlerbad056b2023-01-25 14:16:57 -06001342 // Just use first path returned since they all
1343 // point to the same FRU.
1344 inventoryPath = inventoryPaths[0];
Matt Spinler3bdd0112020-08-27 10:24:34 -05001345 }
1346 catch (const std::exception& e)
1347 {
1348 throw std::runtime_error{
1349 fmt::format("Unable to get inventory path from "
1350 "location code: {}: {}",
1351 unexpandedLocCode, e.what())};
1352 }
1353 }
1354
Matt Spinlerb8cb60f2020-08-27 10:55:55 -05001355 if (jsonCallout.contains("MRUs"))
1356 {
1357 mrus = getMRUsFromJSON(jsonCallout.at("MRUs"));
1358 }
1359
Matt Spinler3bdd0112020-08-27 10:24:34 -05001360 // If the location code was also passed in, use that here too
1361 // so addInventoryCallout doesn't have to look it up.
1362 std::optional<std::string> lc;
1363 if (!locCode.empty())
1364 {
1365 lc = locCode;
1366 }
1367
Matt Spinlerb8cb60f2020-08-27 10:55:55 -05001368 addInventoryCallout(inventoryPath, priority, lc, dataIface, mrus);
Matt Spinlerafa2c792020-08-27 11:01:39 -05001369
1370 if (jsonCallout.contains("Deconfigured"))
1371 {
1372 if (jsonCallout.at("Deconfigured").get<bool>())
1373 {
1374 setErrorStatusFlag(ErrorStatusFlags::deconfigured);
1375 }
1376 }
1377
1378 if (jsonCallout.contains("Guarded"))
1379 {
1380 if (jsonCallout.at("Guarded").get<bool>())
1381 {
1382 setErrorStatusFlag(ErrorStatusFlags::guarded);
1383 }
1384 }
Matt Spinler3bdd0112020-08-27 10:24:34 -05001385 }
1386
1387 if (callout)
1388 {
1389 createCalloutsObject();
1390 _callouts->addCallout(std::move(callout));
1391 }
1392}
1393
1394CalloutPriority SRC::getPriorityFromJSON(const nlohmann::json& json)
1395{
1396 // Looks like:
1397 // {
1398 // "Priority": "H"
1399 // }
1400 auto p = json.at("Priority").get<std::string>();
1401 if (p.empty())
1402 {
1403 throw std::runtime_error{"Priority field in callout is empty"};
1404 }
1405
1406 auto priority = static_cast<CalloutPriority>(p.front());
1407
1408 // Validate it
1409 auto priorityIt = pv::findByValue(static_cast<uint32_t>(priority),
1410 pv::calloutPriorityValues);
1411 if (priorityIt == pv::calloutPriorityValues.end())
1412 {
1413 throw std::runtime_error{
1414 fmt::format("Invalid priority '{}' found in JSON callout", p)};
1415 }
1416
1417 return priority;
Matt Spinler5a90a952020-08-27 09:39:03 -05001418}
1419
Matt Spinlerb8cb60f2020-08-27 10:55:55 -05001420std::vector<src::MRU::MRUCallout>
1421 SRC::getMRUsFromJSON(const nlohmann::json& mruJSON)
1422{
1423 std::vector<src::MRU::MRUCallout> mrus;
1424
1425 // Looks like:
1426 // [
1427 // {
1428 // "ID": 100,
1429 // "Priority": "H"
1430 // }
1431 // ]
1432 if (!mruJSON.is_array())
1433 {
1434 addDebugData("MRU callout JSON is not an array");
1435 return mrus;
1436 }
1437
1438 for (const auto& mruCallout : mruJSON)
1439 {
1440 try
1441 {
1442 auto priority = getPriorityFromJSON(mruCallout);
1443 auto id = mruCallout.at("ID").get<uint32_t>();
1444
1445 src::MRU::MRUCallout mru{static_cast<uint32_t>(priority), id};
1446 mrus.push_back(std::move(mru));
1447 }
1448 catch (const std::exception& e)
1449 {
1450 addDebugData(fmt::format("Invalid MRU entry in JSON: {}: {}",
1451 mruCallout.dump(), e.what()));
1452 }
1453 }
1454
1455 return mrus;
1456}
1457
Sumit Kumar9d43a722021-08-24 09:46:19 -05001458void SRC::setDumpStatus(const DataInterfaceBase& dataIface)
1459{
1460 std::vector<bool> dumpStatus{false, false, false};
1461
1462 try
1463 {
1464 std::vector<std::string> dumpType = {"bmc/entry", "resource/entry",
1465 "system/entry"};
1466 dumpStatus = dataIface.checkDumpStatus(dumpType);
1467
1468 // For bmc - set bit 0 of nibble [4-7] bits of byte-1 SP dump
1469 // For resource - set bit 2 of nibble [4-7] bits of byte-2 Hypervisor
1470 // For system - set bit 1 of nibble [4-7] bits of byte-2 HW dump
1471 _hexData[0] |= ((dumpStatus[0] << 19) | (dumpStatus[1] << 9) |
1472 (dumpStatus[2] << 10));
1473 }
1474 catch (const std::exception& e)
1475 {
Matt Spinler35a405b2022-03-02 11:42:42 -06001476 log<level::ERR>(
1477 fmt::format("Checking dump status failed: {}", e.what()).c_str());
Sumit Kumar9d43a722021-08-24 09:46:19 -05001478 }
1479}
1480
Sumit Kumar3e274432021-09-14 06:37:56 -05001481std::vector<uint8_t> SRC::getSrcStruct()
1482{
1483 std::vector<uint8_t> data;
1484 Stream stream{data};
1485
1486 //------ Ref section 4.3 in PEL doc---
1487 //------ SRC Structure 40 bytes-------
1488 // Byte-0 | Byte-1 | Byte-2 | Byte-3 |
1489 // -----------------------------------
1490 // 02 | 08 | 00 | 09 | ==> Header
1491 // 00 | 00 | 00 | 48 | ==> Header
1492 // 00 | 00 | 00 | 00 | ==> Hex data word-2
1493 // 00 | 00 | 00 | 00 | ==> Hex data word-3
1494 // 00 | 00 | 00 | 00 | ==> Hex data word-4
1495 // 20 | 00 | 00 | 00 | ==> Hex data word-5
1496 // 00 | 00 | 00 | 00 | ==> Hex data word-6
1497 // 00 | 00 | 00 | 00 | ==> Hex data word-7
1498 // 00 | 00 | 00 | 00 | ==> Hex data word-8
1499 // 00 | 00 | 00 | 00 | ==> Hex data word-9
1500 // -----------------------------------
1501 // ASCII string - 8 bytes |
1502 // -----------------------------------
1503 // ASCII space NULL - 24 bytes |
1504 // -----------------------------------
1505 //_size = Base SRC struct: 8 byte header + hex data section + ASCII string
1506
1507 uint8_t flags = (_flags | postOPPanel);
1508
1509 stream << _version << flags << _reserved1B << _wordCount << _reserved2B
1510 << _size;
1511
1512 for (auto& word : _hexData)
1513 {
1514 stream << word;
1515 }
1516
1517 _asciiString->flatten(stream);
1518
1519 return data;
1520}
1521
Vijay Lobo875b6c72021-10-20 17:38:56 -05001522void SRC::setProgressCode(const DataInterfaceBase& dataIface)
1523{
1524 std::vector<uint8_t> progressSRC;
1525
1526 try
1527 {
1528 progressSRC = dataIface.getRawProgressSRC();
1529 }
1530 catch (const std::exception& e)
1531 {
1532 log<level::ERR>(
1533 fmt::format("Error getting progress code: {}", e.what()).c_str());
1534 return;
1535 }
1536
1537 _hexData[2] = getProgressCode(progressSRC);
1538}
1539
1540uint32_t SRC::getProgressCode(std::vector<uint8_t>& rawProgressSRC)
1541{
1542 uint32_t progressCode = 0;
1543
1544 // A valid progress SRC is at least 72 bytes
1545 if (rawProgressSRC.size() < 72)
1546 {
1547 return progressCode;
1548 }
1549
1550 try
1551 {
1552 // The ASCII string field in progress SRCs starts at offset 40.
1553 // Take the first 8 characters to put in the uint32:
1554 // "CC009189" -> 0xCC009189
1555 Stream stream{rawProgressSRC, 40};
1556 src::AsciiString aString{stream};
1557 auto progressCodeString = aString.get().substr(0, 8);
1558
1559 if (std::all_of(progressCodeString.begin(), progressCodeString.end(),
1560 [](char c) {
Patrick Williamsac1ba3f2023-05-10 07:50:16 -05001561 return std::isxdigit(static_cast<unsigned char>(c));
1562 }))
Vijay Lobo875b6c72021-10-20 17:38:56 -05001563 {
1564 progressCode = std::stoul(progressCodeString, nullptr, 16);
1565 }
1566 }
1567 catch (const std::exception& e)
1568 {}
1569
1570 return progressCode;
1571}
1572
Matt Spinlerf9bae182019-10-09 13:37:38 -05001573} // namespace pels
1574} // namespace openpower