blob: b3e3e899df2a886732c083df363fd232208d54eb [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>
26#include <sstream>
27#endif
Matt Spinler5a90a952020-08-27 09:39:03 -050028#include <fmt/format.h>
29
Matt Spinlerf9bae182019-10-09 13:37:38 -050030#include <phosphor-logging/log.hpp>
31
32namespace openpower
33{
34namespace pels
35{
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +080036namespace pv = openpower::pels::pel_values;
37namespace rg = openpower::pels::message;
Matt Spinlerf9bae182019-10-09 13:37:38 -050038using namespace phosphor::logging;
Matt Spinler85f61a62020-06-03 16:28:55 -050039using namespace std::string_literals;
Matt Spinlerf9bae182019-10-09 13:37:38 -050040
Matt Spinler075e5ba2020-02-21 15:46:00 -060041constexpr size_t ccinSize = 4;
42
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +080043#ifdef PELTOOL
Sumit Kumar516935a2021-04-14 13:00:54 -050044using orderedJSON = nlohmann::ordered_json;
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +080045
46void pyDecRef(PyObject* pyObj)
47{
48 Py_XDECREF(pyObj);
49}
50
51/**
52 * @brief Returns a JSON string to append to SRC section.
53 *
54 * The returning string will contain a JSON object, but without
55 * the outer {}. If the input JSON isn't a JSON object (dict), then
56 * one will be created with the input added to a 'SRC Details' key.
57 *
58 * @param[in] json - The JSON to convert to a string
59 *
60 * @return std::string - The JSON string
61 */
Sumit Kumar516935a2021-04-14 13:00:54 -050062std::string prettyJSON(const orderedJSON& json)
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +080063{
Sumit Kumar516935a2021-04-14 13:00:54 -050064 orderedJSON output;
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +080065 if (!json.is_object())
66 {
67 output["SRC Details"] = json;
68 }
69 else
70 {
71 for (const auto& [key, value] : json.items())
72 {
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +080073 output["SRC Details"][key] = value;
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +080074 }
75 }
76
77 // Let nlohmann do the pretty printing.
78 std::stringstream stream;
79 stream << std::setw(4) << output;
80
81 auto jsonString = stream.str();
82
83 // Now it looks like:
84 // {
85 // "Key": "Value",
86 // ...
87 // }
88
89 // Replace the { and the following newline, and the } and its
90 // preceeding newline.
91 jsonString.erase(0, 2);
92
93 auto pos = jsonString.find_last_of('}');
94 jsonString.erase(pos - 1);
95
96 return jsonString;
97}
98
99/**
100 * @brief Call Python modules to parse the data into a JSON string
101 *
102 * The module to call is based on the Creator Subsystem ID under the namespace
103 * "srcparsers". For example: "srcparsers.xsrc.xsrc" where "x" is the Creator
104 * Subsystem ID in ASCII lowercase.
105 *
106 * All modules must provide the following:
107 * Function: parseSRCToJson
108 * Argument list:
109 * 1. (str) ASCII string (Hex Word 1)
110 * 2. (str) Hex Word 2
111 * 3. (str) Hex Word 3
112 * 4. (str) Hex Word 4
113 * 5. (str) Hex Word 5
114 * 6. (str) Hex Word 6
115 * 7. (str) Hex Word 7
116 * 8. (str) Hex Word 8
117 * 9. (str) Hex Word 9
118 *-Return data:
119 * 1. (str) JSON string
120 *
121 * @param[in] hexwords - Vector of strings of Hexwords 1-9
122 * @param[in] creatorID - The creatorID from the Private Header section
123 * @return std::optional<std::string> - The JSON string if it could be created,
124 * else std::nullopt
125 */
126std::optional<std::string> getPythonJSON(std::vector<std::string>& hexwords,
127 uint8_t creatorID)
128{
129 PyObject *pName, *pModule, *pDict, *pFunc, *pArgs, *pResult, *pBytes,
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +0800130 *eType, *eValue, *eTraceback, *pKey;
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";
165 pKey = PyUnicode_FromString(funcToCall.c_str());
166 std::unique_ptr<PyObject, decltype(&pyDecRef)> keyPtr(pKey, &pyDecRef);
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800167 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 }
180 pFunc = PyDict_GetItemString(pDict, funcToCall.c_str());
181 Py_DECREF(pDict);
182 Py_INCREF(pFunc);
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800183 if (PyCallable_Check(pFunc))
184 {
185 pArgs = PyTuple_New(9);
186 std::unique_ptr<PyObject, decltype(&pyDecRef)> argPtr(pArgs,
187 &pyDecRef);
188 for (size_t i = 0; i < 9; i++)
189 {
190 if (i < hexwords.size())
191 {
192 auto arg = hexwords[i];
193 PyTuple_SetItem(pArgs, i,
194 Py_BuildValue("s#", arg.c_str(), 8));
195 }
196 else
197 {
198 PyTuple_SetItem(pArgs, i, Py_BuildValue("s", "00000000"));
199 }
200 }
201 pResult = PyObject_CallObject(pFunc, pArgs);
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +0800202 Py_DECREF(pFunc);
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800203 if (pResult)
204 {
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +0800205 std::unique_ptr<PyObject, decltype(&pyDecRef)> resPtr(
206 pResult, &pyDecRef);
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800207 pBytes = PyUnicode_AsEncodedString(pResult, "utf-8", "~E~");
208 std::unique_ptr<PyObject, decltype(&pyDecRef)> pyBytePtr(
209 pBytes, &pyDecRef);
210 const char* output = PyBytes_AS_STRING(pBytes);
211 try
212 {
Matt Spinlerbb1c1d52021-06-03 13:18:48 -0600213 orderedJSON json = orderedJSON::parse(output);
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +0800214 if ((json.is_object() && !json.empty()) ||
215 (json.is_array() && json.size() > 0) ||
216 (json.is_string() && json != ""))
217 {
218 return prettyJSON(json);
219 }
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800220 }
221 catch (std::exception& e)
222 {
223 log<level::ERR>("Bad JSON from parser",
224 entry("ERROR=%s", e.what()),
225 entry("SRC=%s", hexwords.front().c_str()),
226 entry("PARSER_MODULE=%s", module.c_str()));
227 return std::nullopt;
228 }
229 }
230 else
231 {
232 pErrStr = "No error string found";
233 PyErr_Fetch(&eType, &eValue, &eTraceback);
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +0800234 if (eType)
235 {
236 Py_XDECREF(eType);
237 }
238 if (eTraceback)
239 {
240 Py_XDECREF(eTraceback);
241 }
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800242 if (eValue)
243 {
244 PyObject* pStr = PyObject_Str(eValue);
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +0800245 Py_XDECREF(eValue);
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800246 if (pStr)
247 {
248 pErrStr = PyUnicode_AsUTF8(pStr);
Harisuddin Mohamed Isa69c18272021-05-29 13:18:45 +0800249 Py_XDECREF(pStr);
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800250 }
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800251 }
252 }
253 }
254 }
255 if (!pErrStr.empty())
256 {
257 log<level::ERR>("Python exception thrown by parser",
258 entry("ERROR=%s", pErrStr.c_str()),
259 entry("SRC=%s", hexwords.front().c_str()),
260 entry("PARSER_MODULE=%s", module.c_str()));
261 }
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800262 return std::nullopt;
263}
264#endif
265
Matt Spinlerf9bae182019-10-09 13:37:38 -0500266void SRC::unflatten(Stream& stream)
267{
268 stream >> _header >> _version >> _flags >> _reserved1B >> _wordCount >>
269 _reserved2B >> _size;
270
271 for (auto& word : _hexData)
272 {
273 stream >> word;
274 }
275
276 _asciiString = std::make_unique<src::AsciiString>(stream);
277
278 if (hasAdditionalSections())
279 {
280 // The callouts section is currently the only extra subsection type
281 _callouts = std::make_unique<src::Callouts>(stream);
282 }
283}
284
Matt Spinler06885452019-11-06 10:35:42 -0600285void SRC::flatten(Stream& stream) const
Matt Spinlerf9bae182019-10-09 13:37:38 -0500286{
287 stream << _header << _version << _flags << _reserved1B << _wordCount
288 << _reserved2B << _size;
289
290 for (auto& word : _hexData)
291 {
292 stream << word;
293 }
294
295 _asciiString->flatten(stream);
296
297 if (_callouts)
298 {
299 _callouts->flatten(stream);
300 }
301}
302
303SRC::SRC(Stream& pel)
304{
305 try
306 {
307 unflatten(pel);
308 validate();
309 }
310 catch (const std::exception& e)
311 {
312 log<level::ERR>("Cannot unflatten SRC", entry("ERROR=%s", e.what()));
313 _valid = false;
314 }
315}
316
Matt Spinler075e5ba2020-02-21 15:46:00 -0600317SRC::SRC(const message::Entry& regEntry, const AdditionalData& additionalData,
Matt Spinler5a90a952020-08-27 09:39:03 -0500318 const nlohmann::json& jsonCallouts, const DataInterfaceBase& dataIface)
Matt Spinlerbd716f02019-10-15 10:54:11 -0500319{
320 _header.id = static_cast<uint16_t>(SectionID::primarySRC);
321 _header.version = srcSectionVersion;
322 _header.subType = srcSectionSubtype;
323 _header.componentID = regEntry.componentID;
324
325 _version = srcVersion;
326
327 _flags = 0;
Vijay Lobof3702bb2021-04-09 15:10:19 -0500328
329 auto item = additionalData.getValue("POWER_THERMAL_CRITICAL_FAULT");
330 if ((regEntry.src.powerFault.value_or(false)) ||
331 (item.value_or("") == "TRUE"))
Matt Spinlerbd716f02019-10-15 10:54:11 -0500332 {
333 _flags |= powerFaultEvent;
334 }
335
336 _reserved1B = 0;
337
338 _wordCount = numSRCHexDataWords + 1;
339
340 _reserved2B = 0;
341
342 // There are multiple fields encoded in the hex data words.
343 std::for_each(_hexData.begin(), _hexData.end(),
344 [](auto& word) { word = 0; });
Matt Spinler7c619182020-07-27 15:15:11 -0500345
346 // Hex Word 2 Nibbles:
347 // MIGVEPFF
348 // M: Partition dump status = 0
349 // I: System boot state = TODO
350 // G: Partition Boot type = 0
351 // V: BMC dump status = TODO
352 // E: Platform boot mode = 0 (side = temporary, speed = fast)
353 // P: Platform dump status = TODO
354 // FF: SRC format, set below
355
Matt Spinlerbd716f02019-10-15 10:54:11 -0500356 setBMCFormat();
357 setBMCPosition();
Matt Spinler075e5ba2020-02-21 15:46:00 -0600358 setMotherboardCCIN(dataIface);
359
Matt Spinlerbd716f02019-10-15 10:54:11 -0500360 // Fill in the last 4 words from the AdditionalData property contents.
361 setUserDefinedHexWords(regEntry, additionalData);
362
363 _asciiString = std::make_unique<src::AsciiString>(regEntry);
364
Matt Spinler5a90a952020-08-27 09:39:03 -0500365 addCallouts(regEntry, additionalData, jsonCallouts, dataIface);
Matt Spinlerbd716f02019-10-15 10:54:11 -0500366
367 _size = baseSRCSize;
368 _size += _callouts ? _callouts->flattenedSize() : 0;
369 _header.size = Section::flattenedSize() + _size;
370
371 _valid = true;
372}
373
374void SRC::setUserDefinedHexWords(const message::Entry& regEntry,
375 const AdditionalData& ad)
376{
377 if (!regEntry.src.hexwordADFields)
378 {
379 return;
380 }
381
Harisuddin Mohamed Isa1a1b0df2020-11-23 16:34:36 +0800382 // Save the AdditionalData value corresponding to the first element of
383 // adName tuple into _hexData[wordNum].
Matt Spinlerbd716f02019-10-15 10:54:11 -0500384 for (const auto& [wordNum, adName] : *regEntry.src.hexwordADFields)
385 {
386 // Can only set words 6 - 9
387 if (!isUserDefinedWord(wordNum))
388 {
Matt Spinler85f61a62020-06-03 16:28:55 -0500389 std::string msg =
390 "SRC user data word out of range: " + std::to_string(wordNum);
391 addDebugData(msg);
Matt Spinlerbd716f02019-10-15 10:54:11 -0500392 continue;
393 }
394
Harisuddin Mohamed Isa1a1b0df2020-11-23 16:34:36 +0800395 auto value = ad.getValue(std::get<0>(adName));
Matt Spinlerbd716f02019-10-15 10:54:11 -0500396 if (value)
397 {
398 _hexData[getWordIndexFromWordNum(wordNum)] =
399 std::strtoul(value.value().c_str(), nullptr, 0);
400 }
401 else
402 {
Harisuddin Mohamed Isa1a1b0df2020-11-23 16:34:36 +0800403 std::string msg = "Source for user data SRC word not found: " +
404 std::get<0>(adName);
Matt Spinler85f61a62020-06-03 16:28:55 -0500405 addDebugData(msg);
Matt Spinlerbd716f02019-10-15 10:54:11 -0500406 }
407 }
408}
409
Matt Spinler075e5ba2020-02-21 15:46:00 -0600410void SRC::setMotherboardCCIN(const DataInterfaceBase& dataIface)
411{
412 uint32_t ccin = 0;
413 auto ccinString = dataIface.getMotherboardCCIN();
414
415 try
416 {
417 if (ccinString.size() == ccinSize)
418 {
419 ccin = std::stoi(ccinString, 0, 16);
420 }
421 }
422 catch (std::exception& e)
423 {
424 log<level::WARNING>("Could not convert motherboard CCIN to a number",
425 entry("CCIN=%s", ccinString.c_str()));
426 return;
427 }
428
429 // Set the first 2 bytes
430 _hexData[1] |= ccin << 16;
431}
432
Matt Spinlerf9bae182019-10-09 13:37:38 -0500433void SRC::validate()
434{
435 bool failed = false;
436
437 if ((header().id != static_cast<uint16_t>(SectionID::primarySRC)) &&
438 (header().id != static_cast<uint16_t>(SectionID::secondarySRC)))
439 {
440 log<level::ERR>("Invalid SRC section ID",
441 entry("ID=0x%X", header().id));
442 failed = true;
443 }
444
445 // Check the version in the SRC, not in the header
Matt Spinlerbd716f02019-10-15 10:54:11 -0500446 if (_version != srcVersion)
Matt Spinlerf9bae182019-10-09 13:37:38 -0500447 {
Matt Spinlerbd716f02019-10-15 10:54:11 -0500448 log<level::ERR>("Invalid SRC version", entry("VERSION=0x%X", _version));
Matt Spinlerf9bae182019-10-09 13:37:38 -0500449 failed = true;
450 }
451
452 _valid = failed ? false : true;
453}
454
Matt Spinler075e5ba2020-02-21 15:46:00 -0600455bool SRC::isBMCSRC() const
456{
457 auto as = asciiString();
458 if (as.length() >= 2)
459 {
460 uint8_t errorType = strtoul(as.substr(0, 2).c_str(), nullptr, 16);
461 return (errorType == static_cast<uint8_t>(SRCType::bmcError) ||
462 errorType == static_cast<uint8_t>(SRCType::powerError));
463 }
464 return false;
465}
466
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800467std::optional<std::string> SRC::getErrorDetails(message::Registry& registry,
468 DetailLevel type,
469 bool toCache) const
470{
471 const std::string jsonIndent(indentLevel, 0x20);
472 std::string errorOut;
Matt Spinler075e5ba2020-02-21 15:46:00 -0600473 if (isBMCSRC())
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800474 {
475 auto entry = registry.lookup("0x" + asciiString().substr(4, 4),
476 rg::LookupType::reasonCode, toCache);
477 if (entry)
478 {
479 errorOut.append(jsonIndent + "\"Error Details\": {\n");
480 auto errorMsg = getErrorMessage(*entry);
481 if (errorMsg)
482 {
483 if (type == DetailLevel::message)
484 {
485 return errorMsg.value();
486 }
487 else
488 {
489 jsonInsert(errorOut, "Message", errorMsg.value(), 2);
490 }
491 }
492 if (entry->src.hexwordADFields)
493 {
Harisuddin Mohamed Isa1a1b0df2020-11-23 16:34:36 +0800494 std::map<size_t, std::tuple<std::string, std::string>>
495 adFields = entry->src.hexwordADFields.value();
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800496 for (const auto& hexwordMap : adFields)
497 {
Harisuddin Mohamed Isa1a1b0df2020-11-23 16:34:36 +0800498 std::vector<std::string> valueDescr;
499 valueDescr.push_back(getNumberString(
500 "0x%X",
501 _hexData[getWordIndexFromWordNum(hexwordMap.first)]));
502 valueDescr.push_back(std::get<1>(hexwordMap.second));
503 jsonInsertArray(errorOut, std::get<0>(hexwordMap.second),
504 valueDescr, 2);
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800505 }
506 }
507 errorOut.erase(errorOut.size() - 2);
508 errorOut.append("\n");
509 errorOut.append(jsonIndent + "},\n");
510 return errorOut;
511 }
512 }
513 return std::nullopt;
514}
515
516std::optional<std::string>
517 SRC::getErrorMessage(const message::Entry& regEntry) const
518{
519 try
520 {
521 if (regEntry.doc.messageArgSources)
522 {
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800523 std::vector<uint32_t> argSourceVals;
524 std::string message;
525 const auto& argValues = regEntry.doc.messageArgSources.value();
526 for (size_t i = 0; i < argValues.size(); ++i)
527 {
528 argSourceVals.push_back(_hexData[getWordIndexFromWordNum(
529 argValues[i].back() - '0')]);
530 }
Patrick Williams0230abb2021-04-19 14:32:50 -0500531
532 auto it = std::begin(regEntry.doc.message);
533 auto it_end = std::end(regEntry.doc.message);
534
535 while (it != it_end)
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800536 {
Patrick Williams0230abb2021-04-19 14:32:50 -0500537 if (*it == '%')
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800538 {
Patrick Williams0230abb2021-04-19 14:32:50 -0500539 ++it;
540
541 size_t wordIndex = *it - '0';
542 if (isdigit(*it) && wordIndex >= 1 &&
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800543 static_cast<uint16_t>(wordIndex) <=
544 argSourceVals.size())
545 {
546 message.append(getNumberString(
547 "0x%X", argSourceVals[wordIndex - 1]));
548 }
549 else
550 {
Patrick Williams0230abb2021-04-19 14:32:50 -0500551 message.append("%" + std::string(1, *it));
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800552 }
553 }
554 else
555 {
Patrick Williams0230abb2021-04-19 14:32:50 -0500556 message.push_back(*it);
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800557 }
Patrick Williams0230abb2021-04-19 14:32:50 -0500558 ++it;
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800559 }
Patrick Williams0230abb2021-04-19 14:32:50 -0500560
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800561 return message;
562 }
563 else
564 {
565 return regEntry.doc.message;
566 }
567 }
568 catch (const std::exception& e)
569 {
570 log<level::ERR>("Cannot get error message from registry entry",
571 entry("ERROR=%s", e.what()));
572 }
573 return std::nullopt;
574}
575
576std::optional<std::string> SRC::getCallouts() const
577{
578 if (!_callouts)
579 {
580 return std::nullopt;
581 }
582 std::string printOut;
583 const std::string jsonIndent(indentLevel, 0x20);
584 const auto& callout = _callouts->callouts();
585 const auto& compDescrp = pv::failingComponentType;
586 printOut.append(jsonIndent + "\"Callout Section\": {\n");
587 jsonInsert(printOut, "Callout Count", std::to_string(callout.size()), 2);
588 printOut.append(jsonIndent + jsonIndent + "\"Callouts\": [");
589 for (auto& entry : callout)
590 {
591 printOut.append("{\n");
592 if (entry->fruIdentity())
593 {
594 jsonInsert(
595 printOut, "FRU Type",
596 compDescrp.at(entry->fruIdentity()->failingComponentType()), 3);
597 jsonInsert(printOut, "Priority",
598 pv::getValue(entry->priority(),
599 pel_values::calloutPriorityValues),
600 3);
601 if (!entry->locationCode().empty())
602 {
603 jsonInsert(printOut, "Location Code", entry->locationCode(), 3);
604 }
605 if (entry->fruIdentity()->getPN().has_value())
606 {
607 jsonInsert(printOut, "Part Number",
608 entry->fruIdentity()->getPN().value(), 3);
609 }
610 if (entry->fruIdentity()->getMaintProc().has_value())
611 {
Matt Spinler9e8b49e2020-09-10 13:15:26 -0500612 jsonInsert(printOut, "Procedure",
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800613 entry->fruIdentity()->getMaintProc().value(), 3);
614 if (pv::procedureDesc.find(
615 entry->fruIdentity()->getMaintProc().value()) !=
616 pv::procedureDesc.end())
617 {
618 jsonInsert(
619 printOut, "Description",
620 pv::procedureDesc.at(
621 entry->fruIdentity()->getMaintProc().value()),
622 3);
623 }
624 }
625 if (entry->fruIdentity()->getCCIN().has_value())
626 {
627 jsonInsert(printOut, "CCIN",
628 entry->fruIdentity()->getCCIN().value(), 3);
629 }
630 if (entry->fruIdentity()->getSN().has_value())
631 {
632 jsonInsert(printOut, "Serial Number",
633 entry->fruIdentity()->getSN().value(), 3);
634 }
635 }
636 if (entry->pceIdentity())
637 {
638 const auto& pceIdentMtms = entry->pceIdentity()->mtms();
639 if (!pceIdentMtms.machineTypeAndModel().empty())
640 {
641 jsonInsert(printOut, "PCE MTMS",
642 pceIdentMtms.machineTypeAndModel() + "_" +
643 pceIdentMtms.machineSerialNumber(),
644 3);
645 }
646 if (!entry->pceIdentity()->enclosureName().empty())
647 {
648 jsonInsert(printOut, "PCE Name",
649 entry->pceIdentity()->enclosureName(), 3);
650 }
651 }
652 if (entry->mru())
653 {
654 const auto& mruCallouts = entry->mru()->mrus();
655 std::string mruId;
656 for (auto& element : mruCallouts)
657 {
658 if (!mruId.empty())
659 {
660 mruId.append(", " + getNumberString("%08X", element.id));
661 }
662 else
663 {
664 mruId.append(getNumberString("%08X", element.id));
665 }
666 }
667 jsonInsert(printOut, "MRU Id", mruId, 3);
668 }
669 printOut.erase(printOut.size() - 2);
670 printOut.append("\n" + jsonIndent + jsonIndent + "}, ");
671 };
672 printOut.erase(printOut.size() - 2);
673 printOut.append("]\n" + jsonIndent + "}");
674 return printOut;
675}
676
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800677std::optional<std::string> SRC::getJSON(message::Registry& registry,
Patrick Williamsd26fa3e2021-04-21 15:22:23 -0500678 const std::vector<std::string>& plugins
679 [[maybe_unused]],
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800680 uint8_t creatorID) const
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800681{
682 std::string ps;
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800683 std::vector<std::string> hexwords;
Harisuddin Mohamed Isabebeb942020-03-12 17:12:24 +0800684 jsonInsert(ps, pv::sectionVer, getNumberString("%d", _header.version), 1);
685 jsonInsert(ps, pv::subSection, getNumberString("%d", _header.subType), 1);
686 jsonInsert(ps, pv::createdBy, getNumberString("0x%X", _header.componentID),
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800687 1);
688 jsonInsert(ps, "SRC Version", getNumberString("0x%02X", _version), 1);
Harisuddin Mohamed Isac32e5512020-02-06 18:05:21 +0800689 jsonInsert(ps, "SRC Format", getNumberString("0x%02X", _hexData[0] & 0xFF),
690 1);
691 jsonInsert(ps, "Virtual Progress SRC",
692 pv::boolString.at(_flags & virtualProgressSRC), 1);
693 jsonInsert(ps, "I5/OS Service Event Bit",
694 pv::boolString.at(_flags & i5OSServiceEventBit), 1);
695 jsonInsert(ps, "Hypervisor Dump Initiated",
696 pv::boolString.at(_flags & hypDumpInit), 1);
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800697 jsonInsert(ps, "Power Control Net Fault",
698 pv::boolString.at(isPowerFaultEvent()), 1);
Matt Spinler075e5ba2020-02-21 15:46:00 -0600699
700 if (isBMCSRC())
701 {
702 std::string ccinString;
703 uint32_t ccin = _hexData[1] >> 16;
704
705 if (ccin)
706 {
707 ccinString = getNumberString("%04X", ccin);
708 }
709 // The PEL spec calls it a backplane, so call it that here.
710 jsonInsert(ps, "Backplane CCIN", ccinString, 1);
Matt Spinlerafa2c792020-08-27 11:01:39 -0500711
712 jsonInsert(ps, "Deconfigured",
713 pv::boolString.at(
714 _hexData[3] &
715 static_cast<uint32_t>(ErrorStatusFlags::deconfigured)),
716 1);
717
718 jsonInsert(
719 ps, "Guarded",
720 pv::boolString.at(_hexData[3] &
721 static_cast<uint32_t>(ErrorStatusFlags::guarded)),
722 1);
Matt Spinler075e5ba2020-02-21 15:46:00 -0600723 }
724
Harisuddin Mohamed Isaa214ed32020-02-28 15:58:23 +0800725 auto errorDetails = getErrorDetails(registry, DetailLevel::json, true);
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800726 if (errorDetails)
727 {
728 ps.append(errorDetails.value());
729 }
730 jsonInsert(ps, "Valid Word Count", getNumberString("0x%02X", _wordCount),
731 1);
732 std::string refcode = asciiString();
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800733 hexwords.push_back(refcode);
Harisuddin Mohamed Isafecaa572020-03-11 16:04:50 +0800734 std::string extRefcode;
735 size_t pos = refcode.find(0x20);
736 if (pos != std::string::npos)
737 {
738 size_t nextPos = refcode.find_first_not_of(0x20, pos);
739 if (nextPos != std::string::npos)
740 {
741 extRefcode = trimEnd(refcode.substr(nextPos));
742 }
743 refcode.erase(pos);
744 }
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800745 jsonInsert(ps, "Reference Code", refcode, 1);
Harisuddin Mohamed Isafecaa572020-03-11 16:04:50 +0800746 if (!extRefcode.empty())
747 {
748 jsonInsert(ps, "Extended Reference Code", extRefcode, 1);
749 }
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800750 for (size_t i = 2; i <= _wordCount; i++)
751 {
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800752 std::string tmpWord =
753 getNumberString("%08X", _hexData[getWordIndexFromWordNum(i)]);
754 jsonInsert(ps, "Hex Word " + std::to_string(i), tmpWord, 1);
755 hexwords.push_back(tmpWord);
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800756 }
757 auto calloutJson = getCallouts();
758 if (calloutJson)
759 {
760 ps.append(calloutJson.value());
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800761 ps.append(",\n");
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800762 }
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800763 std::string subsystem = getNumberString("%c", tolower(creatorID));
764 bool srcDetailExists = false;
765#ifdef PELTOOL
766 if (std::find(plugins.begin(), plugins.end(), subsystem + "src") !=
767 plugins.end())
768 {
769 auto pyJson = getPythonJSON(hexwords, creatorID);
770 if (pyJson)
771 {
772 ps.append(pyJson.value());
773 srcDetailExists = true;
774 }
775 }
776#endif
777 if (!srcDetailExists)
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800778 {
779 ps.erase(ps.size() - 2);
780 }
781 return ps;
782}
783
Matt Spinler03984582020-04-09 13:17:58 -0500784void SRC::addCallouts(const message::Entry& regEntry,
785 const AdditionalData& additionalData,
Matt Spinler5a90a952020-08-27 09:39:03 -0500786 const nlohmann::json& jsonCallouts,
Matt Spinlered046852020-03-13 13:58:15 -0500787 const DataInterfaceBase& dataIface)
788{
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500789 auto registryCallouts =
790 getRegistryCallouts(regEntry, additionalData, dataIface);
791
Matt Spinlered046852020-03-13 13:58:15 -0500792 auto item = additionalData.getValue("CALLOUT_INVENTORY_PATH");
Miguel Gomez53ef1552020-10-14 21:16:32 +0000793 auto priority = additionalData.getValue("CALLOUT_PRIORITY");
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500794
Miguel Gomez53ef1552020-10-14 21:16:32 +0000795 std::optional<CalloutPriority> calloutPriority;
796
797 // Only H, M or L priority values.
798 if (priority && !(*priority).empty())
799 {
800 uint8_t p = (*priority)[0];
801 if (p == 'H' || p == 'M' || p == 'L')
802 {
803 calloutPriority = static_cast<CalloutPriority>(p);
804 }
805 }
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500806 // If the first registry callout says to use the passed in inventory
807 // path to get the location code for a symbolic FRU callout with a
808 // trusted location code, then do not add the inventory path as a
809 // normal FRU callout.
810 bool useInvForSymbolicFRULocCode =
811 !registryCallouts.empty() && registryCallouts[0].useInventoryLocCode &&
812 !registryCallouts[0].symbolicFRUTrusted.empty();
813
814 if (item && !useInvForSymbolicFRULocCode)
Matt Spinlered046852020-03-13 13:58:15 -0500815 {
Miguel Gomez53ef1552020-10-14 21:16:32 +0000816 addInventoryCallout(*item, calloutPriority, std::nullopt, dataIface);
Matt Spinlered046852020-03-13 13:58:15 -0500817 }
818
Matt Spinler717de422020-06-04 13:10:14 -0500819 addDevicePathCallouts(additionalData, dataIface);
Matt Spinler03984582020-04-09 13:17:58 -0500820
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500821 addRegistryCallouts(registryCallouts, dataIface,
822 (useInvForSymbolicFRULocCode) ? item : std::nullopt);
Matt Spinler5a90a952020-08-27 09:39:03 -0500823
824 if (!jsonCallouts.empty())
825 {
826 addJSONCallouts(jsonCallouts, dataIface);
827 }
Matt Spinlered046852020-03-13 13:58:15 -0500828}
829
830void SRC::addInventoryCallout(const std::string& inventoryPath,
Matt Spinleraf191c72020-06-04 11:35:13 -0500831 const std::optional<CalloutPriority>& priority,
832 const std::optional<std::string>& locationCode,
Matt Spinlerb8cb60f2020-08-27 10:55:55 -0500833 const DataInterfaceBase& dataIface,
834 const std::vector<src::MRU::MRUCallout>& mrus)
Matt Spinlered046852020-03-13 13:58:15 -0500835{
836 std::string locCode;
837 std::string fn;
838 std::string ccin;
839 std::string sn;
840 std::unique_ptr<src::Callout> callout;
841
Matt Spinlered046852020-03-13 13:58:15 -0500842 try
843 {
Matt Spinleraf191c72020-06-04 11:35:13 -0500844 // Use the passed in location code if there otherwise look it up
845 if (locationCode)
846 {
847 locCode = *locationCode;
848 }
849 else
850 {
851 locCode = dataIface.getLocationCode(inventoryPath);
852 }
Matt Spinlered046852020-03-13 13:58:15 -0500853
Matt Spinler9b90e2a2020-04-14 10:59:04 -0500854 try
855 {
856 dataIface.getHWCalloutFields(inventoryPath, fn, ccin, sn);
857
Matt Spinleraf191c72020-06-04 11:35:13 -0500858 CalloutPriority p =
859 priority ? priority.value() : CalloutPriority::high;
860
Matt Spinlerb8cb60f2020-08-27 10:55:55 -0500861 callout =
862 std::make_unique<src::Callout>(p, locCode, fn, ccin, sn, mrus);
Matt Spinler9b90e2a2020-04-14 10:59:04 -0500863 }
864 catch (const SdBusError& e)
865 {
Matt Spinler85f61a62020-06-03 16:28:55 -0500866 std::string msg =
867 "No VPD found for " + inventoryPath + ": " + e.what();
868 addDebugData(msg);
Matt Spinler9b90e2a2020-04-14 10:59:04 -0500869
870 // Just create the callout with empty FRU fields
Matt Spinlerb8cb60f2020-08-27 10:55:55 -0500871 callout = std::make_unique<src::Callout>(
872 CalloutPriority::high, locCode, fn, ccin, sn, mrus);
Matt Spinler9b90e2a2020-04-14 10:59:04 -0500873 }
Matt Spinlered046852020-03-13 13:58:15 -0500874 }
875 catch (const SdBusError& e)
876 {
Matt Spinler85f61a62020-06-03 16:28:55 -0500877 std::string msg = "Could not get location code for " + inventoryPath +
878 ": " + e.what();
879 addDebugData(msg);
Matt Spinlered046852020-03-13 13:58:15 -0500880
Matt Spinlered046852020-03-13 13:58:15 -0500881 callout = std::make_unique<src::Callout>(CalloutPriority::high,
Matt Spinlera27e2e52020-04-09 11:06:11 -0500882 "no_vpd_for_fru");
Matt Spinlered046852020-03-13 13:58:15 -0500883 }
884
Matt Spinler9b90e2a2020-04-14 10:59:04 -0500885 createCalloutsObject();
Matt Spinlered046852020-03-13 13:58:15 -0500886 _callouts->addCallout(std::move(callout));
Matt Spinler03984582020-04-09 13:17:58 -0500887}
Matt Spinlered046852020-03-13 13:58:15 -0500888
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500889std::vector<message::RegistryCallout>
890 SRC::getRegistryCallouts(const message::Entry& regEntry,
891 const AdditionalData& additionalData,
892 const DataInterfaceBase& dataIface)
893{
894 std::vector<message::RegistryCallout> registryCallouts;
895
896 if (regEntry.callouts)
897 {
Matt Spinler9a50c8d2021-04-12 14:22:26 -0500898 std::vector<std::string> systemNames;
899
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500900 try
901 {
Matt Spinler9a50c8d2021-04-12 14:22:26 -0500902 systemNames = dataIface.getSystemNames();
903 }
904 catch (const std::exception& e)
905 {
906 // Compatible interface not available yet
907 }
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500908
Matt Spinler9a50c8d2021-04-12 14:22:26 -0500909 try
910 {
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500911 registryCallouts = message::Registry::getCallouts(
912 regEntry.callouts.value(), systemNames, additionalData);
913 }
914 catch (const std::exception& e)
915 {
916 addDebugData(fmt::format(
917 "Error parsing PEL message registry callout JSON: {}",
918 e.what()));
919 }
920 }
921
922 return registryCallouts;
923}
924
925void SRC::addRegistryCallouts(
926 const std::vector<message::RegistryCallout>& callouts,
927 const DataInterfaceBase& dataIface,
928 std::optional<std::string> trustedSymbolicFRUInvPath)
Matt Spinler03984582020-04-09 13:17:58 -0500929{
930 try
931 {
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500932 for (const auto& callout : callouts)
Matt Spinler03984582020-04-09 13:17:58 -0500933 {
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500934 addRegistryCallout(callout, dataIface, trustedSymbolicFRUInvPath);
935
936 // Only the first callout gets the inventory path
937 if (trustedSymbolicFRUInvPath)
938 {
939 trustedSymbolicFRUInvPath = std::nullopt;
940 }
Matt Spinler03984582020-04-09 13:17:58 -0500941 }
942 }
943 catch (std::exception& e)
944 {
Matt Spinler85f61a62020-06-03 16:28:55 -0500945 std::string msg =
946 "Error parsing PEL message registry callout JSON: "s + e.what();
947 addDebugData(msg);
Matt Spinler03984582020-04-09 13:17:58 -0500948 }
949}
950
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500951void SRC::addRegistryCallout(
952 const message::RegistryCallout& regCallout,
953 const DataInterfaceBase& dataIface,
954 const std::optional<std::string>& trustedSymbolicFRUInvPath)
Matt Spinler03984582020-04-09 13:17:58 -0500955{
956 std::unique_ptr<src::Callout> callout;
Matt Spinler03984582020-04-09 13:17:58 -0500957 auto locCode = regCallout.locCode;
958
Matt Spinleraf191c72020-06-04 11:35:13 -0500959 if (!locCode.empty())
960 {
961 try
962 {
963 locCode = dataIface.expandLocationCode(locCode, 0);
964 }
965 catch (const std::exception& e)
966 {
967 auto msg =
968 "Unable to expand location code " + locCode + ": " + e.what();
969 addDebugData(msg);
970 return;
971 }
972 }
973
Matt Spinler03984582020-04-09 13:17:58 -0500974 // Via the PEL values table, get the priority enum.
975 // The schema will have validated the priority was a valid value.
976 auto priorityIt =
977 pv::findByName(regCallout.priority, pv::calloutPriorityValues);
978 assert(priorityIt != pv::calloutPriorityValues.end());
979 auto priority =
980 static_cast<CalloutPriority>(std::get<pv::fieldValuePos>(*priorityIt));
981
982 if (!regCallout.procedure.empty())
983 {
984 // Procedure callout
985 callout =
986 std::make_unique<src::Callout>(priority, regCallout.procedure);
987 }
988 else if (!regCallout.symbolicFRU.empty())
989 {
990 // Symbolic FRU callout
991 callout = std::make_unique<src::Callout>(
992 priority, regCallout.symbolicFRU, locCode, false);
993 }
994 else if (!regCallout.symbolicFRUTrusted.empty())
995 {
996 // Symbolic FRU with trusted location code callout
997
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500998 // Use the location code from the inventory path if there is one.
999 if (trustedSymbolicFRUInvPath)
1000 {
1001 try
1002 {
1003 locCode = dataIface.getLocationCode(*trustedSymbolicFRUInvPath);
1004 }
1005 catch (const std::exception& e)
1006 {
1007 addDebugData(
1008 fmt::format("Could not get location code for {}: {}",
1009 *trustedSymbolicFRUInvPath, e.what()));
1010 locCode.clear();
1011 }
1012 }
1013
Matt Spinler03984582020-04-09 13:17:58 -05001014 // The registry wants it to be trusted, but that requires a valid
1015 // location code for it to actually be.
1016 callout = std::make_unique<src::Callout>(
1017 priority, regCallout.symbolicFRUTrusted, locCode, !locCode.empty());
1018 }
1019 else
1020 {
Matt Spinleraf191c72020-06-04 11:35:13 -05001021 // A hardware callout
1022 std::string inventoryPath;
1023
1024 try
1025 {
1026 // Get the inventory item from the unexpanded location code
1027 inventoryPath =
Matt Spinler2f9225a2020-08-05 12:58:49 -05001028 dataIface.getInventoryFromLocCode(regCallout.locCode, 0, false);
Matt Spinleraf191c72020-06-04 11:35:13 -05001029 }
1030 catch (const std::exception& e)
1031 {
1032 std::string msg =
1033 "Unable to get inventory path from location code: " + locCode +
1034 ": " + e.what();
1035 addDebugData(msg);
1036 return;
1037 }
1038
1039 addInventoryCallout(inventoryPath, priority, locCode, dataIface);
Matt Spinler03984582020-04-09 13:17:58 -05001040 }
1041
1042 if (callout)
1043 {
1044 createCalloutsObject();
1045 _callouts->addCallout(std::move(callout));
1046 }
1047}
Matt Spinlered046852020-03-13 13:58:15 -05001048
Matt Spinler717de422020-06-04 13:10:14 -05001049void SRC::addDevicePathCallouts(const AdditionalData& additionalData,
1050 const DataInterfaceBase& dataIface)
1051{
1052 std::vector<device_callouts::Callout> callouts;
1053 auto i2cBus = additionalData.getValue("CALLOUT_IIC_BUS");
1054 auto i2cAddr = additionalData.getValue("CALLOUT_IIC_ADDR");
1055 auto devPath = additionalData.getValue("CALLOUT_DEVICE_PATH");
1056
1057 // A device callout contains either:
1058 // * CALLOUT_ERRNO, CALLOUT_DEVICE_PATH
1059 // * CALLOUT_ERRNO, CALLOUT_IIC_BUS, CALLOUT_IIC_ADDR
1060 // We don't care about the errno.
1061
1062 if (devPath)
1063 {
1064 try
1065 {
1066 callouts = device_callouts::getCallouts(*devPath,
1067 dataIface.getSystemNames());
1068 }
1069 catch (const std::exception& e)
1070 {
1071 addDebugData(e.what());
1072 callouts.clear();
1073 }
1074 }
1075 else if (i2cBus && i2cAddr)
1076 {
1077 size_t bus;
1078 uint8_t address;
1079
1080 try
1081 {
1082 // If /dev/i2c- is prepended, remove it
1083 if (i2cBus->find("/dev/i2c-") != std::string::npos)
1084 {
1085 *i2cBus = i2cBus->substr(9);
1086 }
1087
1088 bus = stoul(*i2cBus, nullptr, 0);
1089 address = stoul(*i2cAddr, nullptr, 0);
1090 }
1091 catch (const std::exception& e)
1092 {
1093 std::string msg = "Invalid CALLOUT_IIC_BUS " + *i2cBus +
1094 " or CALLOUT_IIC_ADDR " + *i2cAddr +
1095 " in AdditionalData property";
1096 addDebugData(msg);
1097 return;
1098 }
1099
1100 try
1101 {
1102 callouts = device_callouts::getI2CCallouts(
1103 bus, address, dataIface.getSystemNames());
1104 }
1105 catch (const std::exception& e)
1106 {
1107 addDebugData(e.what());
1108 callouts.clear();
1109 }
1110 }
1111
1112 for (const auto& callout : callouts)
1113 {
1114 // The priority shouldn't be invalid, but check just in case.
1115 CalloutPriority priority = CalloutPriority::high;
1116
1117 if (!callout.priority.empty())
1118 {
1119 auto p = pel_values::findByValue(
1120 static_cast<uint32_t>(callout.priority[0]),
1121 pel_values::calloutPriorityValues);
1122
1123 if (p != pel_values::calloutPriorityValues.end())
1124 {
1125 priority = static_cast<CalloutPriority>(callout.priority[0]);
1126 }
1127 else
1128 {
1129 std::string msg =
1130 "Invalid priority found in dev callout JSON: " +
1131 callout.priority[0];
1132 addDebugData(msg);
1133 }
1134 }
1135
Matt Spinler0d92b522021-06-16 13:28:17 -06001136 std::optional<std::string> locCode;
1137
1138 try
1139 {
1140 locCode = dataIface.expandLocationCode(callout.locationCode, 0);
1141 }
1142 catch (const std::exception& e)
1143 {
1144 auto msg = fmt::format("Unable to expand location code {}: {}",
1145 callout.locationCode, e.what());
1146 addDebugData(msg);
1147 }
1148
Matt Spinler717de422020-06-04 13:10:14 -05001149 try
1150 {
Matt Spinler2f9225a2020-08-05 12:58:49 -05001151 auto inventoryPath = dataIface.getInventoryFromLocCode(
1152 callout.locationCode, 0, false);
Matt Spinler717de422020-06-04 13:10:14 -05001153
Matt Spinler0d92b522021-06-16 13:28:17 -06001154 addInventoryCallout(inventoryPath, priority, locCode, dataIface);
Matt Spinler717de422020-06-04 13:10:14 -05001155 }
1156 catch (const std::exception& e)
1157 {
1158 std::string msg =
1159 "Unable to get inventory path from location code: " +
1160 callout.locationCode + ": " + e.what();
1161 addDebugData(msg);
1162 }
1163
1164 // Until the code is there to convert these MRU value strings to
1165 // the official MRU values in the callout objects, just store
1166 // the MRU name in the debug UserData section.
1167 if (!callout.mru.empty())
1168 {
1169 std::string msg = "MRU: " + callout.mru;
1170 addDebugData(msg);
1171 }
1172
1173 // getCallouts() may have generated some debug data it stored
1174 // in a callout object. Save it as well.
1175 if (!callout.debug.empty())
1176 {
1177 addDebugData(callout.debug);
1178 }
1179 }
1180}
1181
Matt Spinler5a90a952020-08-27 09:39:03 -05001182void SRC::addJSONCallouts(const nlohmann::json& jsonCallouts,
1183 const DataInterfaceBase& dataIface)
1184{
1185 if (jsonCallouts.empty())
1186 {
1187 return;
1188 }
1189
1190 if (!jsonCallouts.is_array())
1191 {
1192 addDebugData("Callout JSON isn't an array");
1193 return;
1194 }
1195
1196 for (const auto& callout : jsonCallouts)
1197 {
1198 try
1199 {
1200 addJSONCallout(callout, dataIface);
1201 }
1202 catch (const std::exception& e)
1203 {
1204 addDebugData(fmt::format(
1205 "Failed extracting callout data from JSON: {}", e.what()));
1206 }
1207 }
1208}
1209
1210void SRC::addJSONCallout(const nlohmann::json& jsonCallout,
1211 const DataInterfaceBase& dataIface)
1212{
Matt Spinler3bdd0112020-08-27 10:24:34 -05001213 auto priority = getPriorityFromJSON(jsonCallout);
1214 std::string locCode;
1215 std::string unexpandedLocCode;
1216 std::unique_ptr<src::Callout> callout;
1217
1218 // Expand the location code if it's there
1219 if (jsonCallout.contains("LocationCode"))
1220 {
1221 unexpandedLocCode = jsonCallout.at("LocationCode").get<std::string>();
1222
1223 try
1224 {
1225 locCode = dataIface.expandLocationCode(unexpandedLocCode, 0);
1226 }
1227 catch (const std::exception& e)
1228 {
1229 addDebugData(fmt::format("Unable to expand location code {}: {}",
1230 unexpandedLocCode, e.what()));
1231 // Use the value from the JSON so at least there's something
1232 locCode = unexpandedLocCode;
1233 }
1234 }
1235
1236 // Create either a procedure, symbolic FRU, or normal FRU callout.
1237 if (jsonCallout.contains("Procedure"))
1238 {
1239 auto procedure = jsonCallout.at("Procedure").get<std::string>();
1240
1241 callout = std::make_unique<src::Callout>(
1242 static_cast<CalloutPriority>(priority), procedure,
1243 src::CalloutValueType::raw);
1244 }
1245 else if (jsonCallout.contains("SymbolicFRU"))
1246 {
1247 auto fru = jsonCallout.at("SymbolicFRU").get<std::string>();
1248
1249 bool trusted = false;
1250 if (jsonCallout.contains("TrustedLocationCode") && !locCode.empty())
1251 {
1252 trusted = jsonCallout.at("TrustedLocationCode").get<bool>();
1253 }
1254
1255 callout = std::make_unique<src::Callout>(
1256 static_cast<CalloutPriority>(priority), fru,
1257 src::CalloutValueType::raw, locCode, trusted);
1258 }
1259 else
1260 {
1261 // A hardware FRU
1262 std::string inventoryPath;
Matt Spinlerb8cb60f2020-08-27 10:55:55 -05001263 std::vector<src::MRU::MRUCallout> mrus;
Matt Spinler3bdd0112020-08-27 10:24:34 -05001264
1265 if (jsonCallout.contains("InventoryPath"))
1266 {
1267 inventoryPath = jsonCallout.at("InventoryPath").get<std::string>();
1268 }
1269 else
1270 {
1271 if (unexpandedLocCode.empty())
1272 {
1273 throw std::runtime_error{"JSON callout needs either an "
1274 "inventory path or location code"};
1275 }
1276
1277 try
1278 {
1279 inventoryPath = dataIface.getInventoryFromLocCode(
1280 unexpandedLocCode, 0, false);
1281 }
1282 catch (const std::exception& e)
1283 {
1284 throw std::runtime_error{
1285 fmt::format("Unable to get inventory path from "
1286 "location code: {}: {}",
1287 unexpandedLocCode, e.what())};
1288 }
1289 }
1290
Matt Spinlerb8cb60f2020-08-27 10:55:55 -05001291 if (jsonCallout.contains("MRUs"))
1292 {
1293 mrus = getMRUsFromJSON(jsonCallout.at("MRUs"));
1294 }
1295
Matt Spinler3bdd0112020-08-27 10:24:34 -05001296 // If the location code was also passed in, use that here too
1297 // so addInventoryCallout doesn't have to look it up.
1298 std::optional<std::string> lc;
1299 if (!locCode.empty())
1300 {
1301 lc = locCode;
1302 }
1303
Matt Spinlerb8cb60f2020-08-27 10:55:55 -05001304 addInventoryCallout(inventoryPath, priority, lc, dataIface, mrus);
Matt Spinlerafa2c792020-08-27 11:01:39 -05001305
1306 if (jsonCallout.contains("Deconfigured"))
1307 {
1308 if (jsonCallout.at("Deconfigured").get<bool>())
1309 {
1310 setErrorStatusFlag(ErrorStatusFlags::deconfigured);
1311 }
1312 }
1313
1314 if (jsonCallout.contains("Guarded"))
1315 {
1316 if (jsonCallout.at("Guarded").get<bool>())
1317 {
1318 setErrorStatusFlag(ErrorStatusFlags::guarded);
1319 }
1320 }
Matt Spinler3bdd0112020-08-27 10:24:34 -05001321 }
1322
1323 if (callout)
1324 {
1325 createCalloutsObject();
1326 _callouts->addCallout(std::move(callout));
1327 }
1328}
1329
1330CalloutPriority SRC::getPriorityFromJSON(const nlohmann::json& json)
1331{
1332 // Looks like:
1333 // {
1334 // "Priority": "H"
1335 // }
1336 auto p = json.at("Priority").get<std::string>();
1337 if (p.empty())
1338 {
1339 throw std::runtime_error{"Priority field in callout is empty"};
1340 }
1341
1342 auto priority = static_cast<CalloutPriority>(p.front());
1343
1344 // Validate it
1345 auto priorityIt = pv::findByValue(static_cast<uint32_t>(priority),
1346 pv::calloutPriorityValues);
1347 if (priorityIt == pv::calloutPriorityValues.end())
1348 {
1349 throw std::runtime_error{
1350 fmt::format("Invalid priority '{}' found in JSON callout", p)};
1351 }
1352
1353 return priority;
Matt Spinler5a90a952020-08-27 09:39:03 -05001354}
1355
Matt Spinlerb8cb60f2020-08-27 10:55:55 -05001356std::vector<src::MRU::MRUCallout>
1357 SRC::getMRUsFromJSON(const nlohmann::json& mruJSON)
1358{
1359 std::vector<src::MRU::MRUCallout> mrus;
1360
1361 // Looks like:
1362 // [
1363 // {
1364 // "ID": 100,
1365 // "Priority": "H"
1366 // }
1367 // ]
1368 if (!mruJSON.is_array())
1369 {
1370 addDebugData("MRU callout JSON is not an array");
1371 return mrus;
1372 }
1373
1374 for (const auto& mruCallout : mruJSON)
1375 {
1376 try
1377 {
1378 auto priority = getPriorityFromJSON(mruCallout);
1379 auto id = mruCallout.at("ID").get<uint32_t>();
1380
1381 src::MRU::MRUCallout mru{static_cast<uint32_t>(priority), id};
1382 mrus.push_back(std::move(mru));
1383 }
1384 catch (const std::exception& e)
1385 {
1386 addDebugData(fmt::format("Invalid MRU entry in JSON: {}: {}",
1387 mruCallout.dump(), e.what()));
1388 }
1389 }
1390
1391 return mrus;
1392}
1393
Matt Spinlerf9bae182019-10-09 13:37:38 -05001394} // namespace pels
1395} // namespace openpower