1 /**
2 * Copyright © 2019 IBM Corporation
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 #include "src.hpp"
17
18 #include "device_callouts.hpp"
19 #include "json_utils.hpp"
20 #include "paths.hpp"
21 #include "pel_values.hpp"
22 #ifdef PELTOOL
23 #include <Python.h>
24
25 #include <nlohmann/json.hpp>
26
27 #include <sstream>
28 #endif
29 #include <phosphor-logging/lg2.hpp>
30
31 #include <format>
32
33 namespace openpower
34 {
35 namespace pels
36 {
37 namespace pv = openpower::pels::pel_values;
38 namespace rg = openpower::pels::message;
39 using namespace std::string_literals;
40
41 constexpr size_t ccinSize = 4;
42
43 #ifdef PELTOOL
44 using orderedJSON = nlohmann::ordered_json;
45
pyDecRef(PyObject * pyObj)46 void 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 */
prettyJSON(const orderedJSON & json)62 std::string prettyJSON(const orderedJSON& json)
63 {
64 orderedJSON output;
65 if (!json.is_object())
66 {
67 output["SRC Details"] = json;
68 }
69 else
70 {
71 for (const auto& [key, value] : json.items())
72 {
73 output["SRC Details"][key] = value;
74 }
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 */
getPythonJSON(std::vector<std::string> & hexwords,uint8_t creatorID)126 std::optional<std::string> getPythonJSON(std::vector<std::string>& hexwords,
127 uint8_t creatorID)
128 {
129 PyObject *pName, *pModule, *eType, *eValue, *eTraceback;
130 std::string pErrStr;
131 std::string module = getNumberString("%c", tolower(creatorID)) + "src";
132 pName = PyUnicode_FromString(
133 std::string("srcparsers." + module + "." + module).c_str());
134 std::unique_ptr<PyObject, decltype(&pyDecRef)> modNamePtr(pName, &pyDecRef);
135 pModule = PyImport_Import(pName);
136 if (pModule == NULL)
137 {
138 pErrStr = "No error string found";
139 PyErr_Fetch(&eType, &eValue, &eTraceback);
140 if (eType)
141 {
142 Py_XDECREF(eType);
143 }
144 if (eTraceback)
145 {
146 Py_XDECREF(eTraceback);
147 }
148 if (eValue)
149 {
150 PyObject* pStr = PyObject_Str(eValue);
151 Py_XDECREF(eValue);
152 if (pStr)
153 {
154 pErrStr = PyUnicode_AsUTF8(pStr);
155 Py_XDECREF(pStr);
156 }
157 }
158 }
159 else
160 {
161 std::unique_ptr<PyObject, decltype(&pyDecRef)> modPtr(
162 pModule, &pyDecRef);
163 std::string funcToCall = "parseSRCToJson";
164 PyObject* pKey = PyUnicode_FromString(funcToCall.c_str());
165 std::unique_ptr<PyObject, decltype(&pyDecRef)> keyPtr(pKey, &pyDecRef);
166 PyObject* pDict = PyModule_GetDict(pModule);
167 Py_INCREF(pDict);
168 if (!PyDict_Contains(pDict, pKey))
169 {
170 Py_DECREF(pDict);
171 lg2::error(
172 "Python module error. Function missing: {FUNC}, SRC = {SRC}, module = {MODULE}",
173 "FUNC", funcToCall, "SRC", hexwords.front(), "MODULE", module);
174 return std::nullopt;
175 }
176 PyObject* pFunc = PyDict_GetItemString(pDict, funcToCall.c_str());
177 Py_DECREF(pDict);
178 Py_INCREF(pFunc);
179 if (PyCallable_Check(pFunc))
180 {
181 PyObject* pArgs = PyTuple_New(9);
182 std::unique_ptr<PyObject, decltype(&pyDecRef)> argPtr(
183 pArgs, &pyDecRef);
184 for (size_t i = 0; i < 9; i++)
185 {
186 std::string arg{"00000000"};
187 if (i < hexwords.size())
188 {
189 arg = hexwords[i];
190 }
191 PyTuple_SetItem(pArgs, i, Py_BuildValue("s", arg.c_str()));
192 }
193 PyObject* pResult = PyObject_CallObject(pFunc, pArgs);
194 Py_DECREF(pFunc);
195 if (pResult)
196 {
197 std::unique_ptr<PyObject, decltype(&pyDecRef)> resPtr(
198 pResult, &pyDecRef);
199 PyObject* pBytes =
200 PyUnicode_AsEncodedString(pResult, "utf-8", "~E~");
201 std::unique_ptr<PyObject, decltype(&pyDecRef)> pyBytePtr(
202 pBytes, &pyDecRef);
203 const char* output = PyBytes_AS_STRING(pBytes);
204 try
205 {
206 orderedJSON json = orderedJSON::parse(output);
207 if ((json.is_object() && !json.empty()) ||
208 (json.is_array() && json.size() > 0) ||
209 (json.is_string() && json != ""))
210 {
211 return prettyJSON(json);
212 }
213 }
214 catch (const std::exception& e)
215 {
216 lg2::error(
217 "Bad JSON from parser. Error = {ERROR}, SRC = {SRC}, module = {MODULE}",
218 "ERROR", e, "SRC", hexwords.front(), "MODULE", module);
219 return std::nullopt;
220 }
221 }
222 else
223 {
224 pErrStr = "No error string found";
225 PyErr_Fetch(&eType, &eValue, &eTraceback);
226 if (eType)
227 {
228 Py_XDECREF(eType);
229 }
230 if (eTraceback)
231 {
232 Py_XDECREF(eTraceback);
233 }
234 if (eValue)
235 {
236 PyObject* pStr = PyObject_Str(eValue);
237 Py_XDECREF(eValue);
238 if (pStr)
239 {
240 pErrStr = PyUnicode_AsUTF8(pStr);
241 Py_XDECREF(pStr);
242 }
243 }
244 }
245 }
246 }
247 if (!pErrStr.empty())
248 {
249 lg2::debug("Python exception thrown by parser. Error = {ERROR}, "
250 "SRC = {SRC}, module = {MODULE}",
251 "ERROR", pErrStr, "SRC", hexwords.front(), "MODULE", module);
252 }
253 return std::nullopt;
254 }
255 #endif
256
unflatten(Stream & stream)257 void SRC::unflatten(Stream& stream)
258 {
259 stream >> _header >> _version >> _flags >> _reserved1B >> _wordCount >>
260 _reserved2B >> _size;
261
262 for (auto& word : _hexData)
263 {
264 stream >> word;
265 }
266
267 _asciiString = std::make_unique<src::AsciiString>(stream);
268
269 if (hasAdditionalSections())
270 {
271 // The callouts section is currently the only extra subsection type
272 _callouts = std::make_unique<src::Callouts>(stream);
273 }
274 }
275
flatten(Stream & stream) const276 void SRC::flatten(Stream& stream) const
277 {
278 stream << _header << _version << _flags << _reserved1B << _wordCount
279 << _reserved2B << _size;
280
281 for (auto& word : _hexData)
282 {
283 stream << word;
284 }
285
286 _asciiString->flatten(stream);
287
288 if (_callouts)
289 {
290 _callouts->flatten(stream);
291 }
292 }
293
SRC(Stream & pel)294 SRC::SRC(Stream& pel)
295 {
296 try
297 {
298 unflatten(pel);
299 validate();
300 }
301 catch (const std::exception& e)
302 {
303 lg2::error("Cannot unflatten SRC, error = {ERROR}", "ERROR", e);
304 _valid = false;
305 }
306 }
307
SRC(const message::Entry & regEntry,const AdditionalData & additionalData,const nlohmann::json & jsonCallouts,const DataInterfaceBase & dataIface)308 SRC::SRC(const message::Entry& regEntry, const AdditionalData& additionalData,
309 const nlohmann::json& jsonCallouts, const DataInterfaceBase& dataIface)
310 {
311 _header.id = static_cast<uint16_t>(SectionID::primarySRC);
312 _header.version = srcSectionVersion;
313 _header.subType = srcSectionSubtype;
314 _header.componentID = regEntry.componentID;
315
316 _version = srcVersion;
317
318 _flags = 0;
319
320 _reserved1B = 0;
321
322 _wordCount = numSRCHexDataWords + 1;
323
324 _reserved2B = 0;
325
326 // There are multiple fields encoded in the hex data words.
327 std::for_each(_hexData.begin(), _hexData.end(),
328 [](auto& word) { word = 0; });
329
330 // Hex Word 2 Nibbles:
331 // MIGVEPFF
332 // M: Partition dump status = 0
333 // I: System boot state = TODO
334 // G: Partition Boot type = 0
335 // V: BMC dump status
336 // E: Platform boot mode = 0 (side = temporary, speed = fast)
337 // P: Platform dump status
338 // FF: SRC format, set below
339
340 setProgressCode(dataIface);
341 setBMCFormat();
342 setBMCPosition();
343 setMotherboardCCIN(dataIface);
344
345 if (regEntry.src.checkstopFlag)
346 {
347 setErrorStatusFlag(ErrorStatusFlags::hwCheckstop);
348 }
349
350 if (regEntry.src.deconfigFlag)
351 {
352 setErrorStatusFlag(ErrorStatusFlags::deconfigured);
353 }
354
355 // Fill in the last 4 words from the AdditionalData property contents.
356 setUserDefinedHexWords(regEntry, additionalData);
357
358 _asciiString = std::make_unique<src::AsciiString>(regEntry);
359
360 // Check for additional data - PEL_SUBSYSTEM
361 auto ss = additionalData.getValue("PEL_SUBSYSTEM");
362 if (ss)
363 {
364 auto eventSubsystem = std::stoul(*ss, NULL, 16);
365 std::string subsystem =
366 pv::getValue(eventSubsystem, pel_values::subsystemValues);
367 if (subsystem == "invalid")
368 {
369 lg2::warning("SRC: Invalid SubSystem value: {VAL}", "VAL", lg2::hex,
370 eventSubsystem);
371 }
372 else
373 {
374 _asciiString->setByte(2, eventSubsystem);
375 }
376 }
377
378 addCallouts(regEntry, additionalData, jsonCallouts, dataIface);
379
380 _size = baseSRCSize;
381 _size += _callouts ? _callouts->flattenedSize() : 0;
382 _header.size = Section::flattenedSize() + _size;
383
384 _valid = true;
385 }
386
setUserDefinedHexWords(const message::Entry & regEntry,const AdditionalData & ad)387 void SRC::setUserDefinedHexWords(const message::Entry& regEntry,
388 const AdditionalData& ad)
389 {
390 if (!regEntry.src.hexwordADFields)
391 {
392 return;
393 }
394
395 // Save the AdditionalData value corresponding to the first element of
396 // adName tuple into _hexData[wordNum].
397 for (const auto& [wordNum, adName] : *regEntry.src.hexwordADFields)
398 {
399 // Can only set words 6 - 9
400 if (!isUserDefinedWord(wordNum))
401 {
402 std::string msg =
403 "SRC user data word out of range: " + std::to_string(wordNum);
404 addDebugData(msg);
405 continue;
406 }
407
408 auto value = ad.getValue(std::get<0>(adName));
409 if (value)
410 {
411 _hexData[getWordIndexFromWordNum(wordNum)] =
412 std::strtoul(value.value().c_str(), nullptr, 0);
413 }
414 else
415 {
416 std::string msg = "Source for user data SRC word not found: " +
417 std::get<0>(adName);
418 addDebugData(msg);
419 }
420 }
421 }
422
setMotherboardCCIN(const DataInterfaceBase & dataIface)423 void SRC::setMotherboardCCIN(const DataInterfaceBase& dataIface)
424 {
425 uint32_t ccin = 0;
426 auto ccinString = dataIface.getMotherboardCCIN();
427
428 try
429 {
430 if (ccinString.size() == ccinSize)
431 {
432 ccin = std::stoi(ccinString, 0, 16);
433 }
434 }
435 catch (const std::exception& e)
436 {
437 lg2::warning("Could not convert motherboard CCIN {CCIN} to a number",
438 "CCIN", ccinString);
439 return;
440 }
441
442 // Set the first 2 bytes
443 _hexData[1] |= ccin << 16;
444 }
445
validate()446 void SRC::validate()
447 {
448 bool failed = false;
449
450 if ((header().id != static_cast<uint16_t>(SectionID::primarySRC)) &&
451 (header().id != static_cast<uint16_t>(SectionID::secondarySRC)))
452 {
453 lg2::error("Invalid SRC section ID: {ID}", "ID", lg2::hex, header().id);
454 failed = true;
455 }
456
457 // Check the version in the SRC, not in the header
458 if (_version != srcVersion)
459 {
460 lg2::error("Invalid SRC version: {VERSION}", "VERSION", lg2::hex,
461 header().version);
462 failed = true;
463 }
464
465 _valid = failed ? false : true;
466 }
467
isBMCSRC() const468 bool SRC::isBMCSRC() const
469 {
470 auto as = asciiString();
471 if (as.length() >= 2)
472 {
473 uint8_t errorType = strtoul(as.substr(0, 2).c_str(), nullptr, 16);
474 return (errorType == static_cast<uint8_t>(SRCType::bmcError) ||
475 errorType == static_cast<uint8_t>(SRCType::powerError));
476 }
477 return false;
478 }
479
isHostbootSRC() const480 bool SRC::isHostbootSRC() const
481 {
482 auto as = asciiString();
483 if (as.length() >= 2)
484 {
485 uint8_t errorType = strtoul(as.substr(0, 2).c_str(), nullptr, 16);
486 return errorType == static_cast<uint8_t>(SRCType::hostbootError);
487 }
488 return false;
489 }
490
getErrorDetails(message::Registry & registry,DetailLevel type,bool toCache) const491 std::optional<std::string> SRC::getErrorDetails(
492 message::Registry& registry, DetailLevel type, bool toCache) const
493 {
494 const std::string jsonIndent(indentLevel, 0x20);
495 std::string errorOut;
496 if (isBMCSRC())
497 {
498 auto entry = registry.lookup("0x" + asciiString().substr(4, 4),
499 rg::LookupType::reasonCode, toCache);
500 if (entry)
501 {
502 errorOut.append(jsonIndent + "\"Error Details\": {\n");
503 auto errorMsg = getErrorMessage(*entry);
504 if (errorMsg)
505 {
506 if (type == DetailLevel::message)
507 {
508 return errorMsg.value();
509 }
510 else
511 {
512 jsonInsert(errorOut, "Message", errorMsg.value(), 2);
513 }
514 }
515 if (entry->src.hexwordADFields)
516 {
517 std::map<size_t, std::tuple<std::string, std::string>>
518 adFields = entry->src.hexwordADFields.value();
519 for (const auto& hexwordMap : adFields)
520 {
521 auto srcValue = getNumberString(
522 "0x%X",
523 _hexData[getWordIndexFromWordNum(hexwordMap.first)]);
524
525 auto srcKey = std::get<0>(hexwordMap.second);
526 auto srcDesc = std::get<1>(hexwordMap.second);
527
528 // Only include this hex word in the error details if the
529 // description exists.
530 if (!srcDesc.empty())
531 {
532 std::vector<std::string> valueDescr;
533 valueDescr.push_back(srcValue);
534 valueDescr.push_back(srcDesc);
535 jsonInsertArray(errorOut, srcKey, valueDescr, 2);
536 }
537 }
538 }
539 errorOut.erase(errorOut.size() - 2);
540 errorOut.append("\n");
541 errorOut.append(jsonIndent + "},\n");
542 return errorOut;
543 }
544 }
545 return std::nullopt;
546 }
547
getErrorMessage(const message::Entry & regEntry) const548 std::optional<std::string> SRC::getErrorMessage(
549 const message::Entry& regEntry) const
550 {
551 try
552 {
553 if (regEntry.doc.messageArgSources)
554 {
555 std::vector<uint32_t> argSourceVals;
556 std::string message;
557 const auto& argValues = regEntry.doc.messageArgSources.value();
558 for (size_t i = 0; i < argValues.size(); ++i)
559 {
560 argSourceVals.push_back(_hexData[getWordIndexFromWordNum(
561 argValues[i].back() - '0')]);
562 }
563
564 auto it = std::begin(regEntry.doc.message);
565 auto it_end = std::end(regEntry.doc.message);
566
567 while (it != it_end)
568 {
569 if (*it == '%')
570 {
571 ++it;
572
573 size_t wordIndex = *it - '0';
574 if (isdigit(*it) && wordIndex >= 1 &&
575 static_cast<uint16_t>(wordIndex) <=
576 argSourceVals.size())
577 {
578 message.append(getNumberString(
579 "0x%08X", argSourceVals[wordIndex - 1]));
580 }
581 else
582 {
583 message.append("%" + std::string(1, *it));
584 }
585 }
586 else
587 {
588 message.push_back(*it);
589 }
590 ++it;
591 }
592
593 return message;
594 }
595 else
596 {
597 return regEntry.doc.message;
598 }
599 }
600 catch (const std::exception& e)
601 {
602 lg2::error(
603 "Cannot get error message from registry entry, error = {ERROR}",
604 "ERROR", e);
605 }
606 return std::nullopt;
607 }
608
getCallouts() const609 std::optional<std::string> SRC::getCallouts() const
610 {
611 if (!_callouts)
612 {
613 return std::nullopt;
614 }
615 std::string printOut;
616 const std::string jsonIndent(indentLevel, 0x20);
617 const auto& callout = _callouts->callouts();
618 const auto& compDescrp = pv::failingComponentType;
619 printOut.append(jsonIndent + "\"Callout Section\": {\n");
620 jsonInsert(printOut, "Callout Count", std::to_string(callout.size()), 2);
621 printOut.append(jsonIndent + jsonIndent + "\"Callouts\": [");
622 for (auto& entry : callout)
623 {
624 printOut.append("{\n");
625 if (entry->fruIdentity())
626 {
627 jsonInsert(
628 printOut, "FRU Type",
629 compDescrp.at(entry->fruIdentity()->failingComponentType()), 3);
630 jsonInsert(printOut, "Priority",
631 pv::getValue(entry->priority(),
632 pel_values::calloutPriorityValues),
633 3);
634 if (!entry->locationCode().empty())
635 {
636 jsonInsert(printOut, "Location Code", entry->locationCode(), 3);
637 }
638 if (entry->fruIdentity()->getPN().has_value())
639 {
640 jsonInsert(printOut, "Part Number",
641 entry->fruIdentity()->getPN().value(), 3);
642 }
643 if (entry->fruIdentity()->getMaintProc().has_value())
644 {
645 jsonInsert(printOut, "Procedure",
646 entry->fruIdentity()->getMaintProc().value(), 3);
647 if (pv::procedureDesc.find(
648 entry->fruIdentity()->getMaintProc().value()) !=
649 pv::procedureDesc.end())
650 {
651 jsonInsert(
652 printOut, "Description",
653 pv::procedureDesc.at(
654 entry->fruIdentity()->getMaintProc().value()),
655 3);
656 }
657 }
658 if (entry->fruIdentity()->getCCIN().has_value())
659 {
660 jsonInsert(printOut, "CCIN",
661 entry->fruIdentity()->getCCIN().value(), 3);
662 }
663 if (entry->fruIdentity()->getSN().has_value())
664 {
665 jsonInsert(printOut, "Serial Number",
666 entry->fruIdentity()->getSN().value(), 3);
667 }
668 }
669 if (entry->pceIdentity())
670 {
671 const auto& pceIdentMtms = entry->pceIdentity()->mtms();
672 if (!pceIdentMtms.machineTypeAndModel().empty())
673 {
674 jsonInsert(printOut, "PCE MTMS",
675 pceIdentMtms.machineTypeAndModel() + "_" +
676 pceIdentMtms.machineSerialNumber(),
677 3);
678 }
679 if (!entry->pceIdentity()->enclosureName().empty())
680 {
681 jsonInsert(printOut, "PCE Name",
682 entry->pceIdentity()->enclosureName(), 3);
683 }
684 }
685 if (entry->mru())
686 {
687 const auto& mruCallouts = entry->mru()->mrus();
688 std::string mruId;
689 for (auto& element : mruCallouts)
690 {
691 if (!mruId.empty())
692 {
693 mruId.append(", " + getNumberString("%08X", element.id));
694 }
695 else
696 {
697 mruId.append(getNumberString("%08X", element.id));
698 }
699 }
700 jsonInsert(printOut, "MRU Id", mruId, 3);
701 }
702 printOut.erase(printOut.size() - 2);
703 printOut.append("\n" + jsonIndent + jsonIndent + "}, ");
704 };
705 printOut.erase(printOut.size() - 2);
706 printOut.append("]\n" + jsonIndent + "}");
707 return printOut;
708 }
709
getJSON(message::Registry & registry,const std::vector<std::string> & plugins,uint8_t creatorID) const710 std::optional<std::string> SRC::getJSON(message::Registry& registry,
711 const std::vector<std::string>& plugins
712 [[maybe_unused]],
713 uint8_t creatorID) const
714 {
715 std::string ps;
716 std::vector<std::string> hexwords;
717 jsonInsert(ps, pv::sectionVer, getNumberString("%d", _header.version), 1);
718 jsonInsert(ps, pv::subSection, getNumberString("%d", _header.subType), 1);
719 jsonInsert(ps, pv::createdBy,
720 getComponentName(_header.componentID, creatorID), 1);
721 jsonInsert(ps, "SRC Version", getNumberString("0x%02X", _version), 1);
722 jsonInsert(ps, "SRC Format", getNumberString("0x%02X", _hexData[0] & 0xFF),
723 1);
724 jsonInsert(ps, "Virtual Progress SRC",
725 pv::boolString.at(_flags & virtualProgressSRC), 1);
726 jsonInsert(ps, "I5/OS Service Event Bit",
727 pv::boolString.at(_flags & i5OSServiceEventBit), 1);
728 jsonInsert(ps, "Hypervisor Dump Initiated",
729 pv::boolString.at(_flags & hypDumpInit), 1);
730
731 if (isBMCSRC())
732 {
733 std::string ccinString;
734 uint32_t ccin = _hexData[1] >> 16;
735
736 if (ccin)
737 {
738 ccinString = getNumberString("%04X", ccin);
739 }
740 // The PEL spec calls it a backplane, so call it that here.
741 jsonInsert(ps, "Backplane CCIN", ccinString, 1);
742
743 jsonInsert(ps, "Terminate FW Error",
744 pv::boolString.at(
745 _hexData[3] &
746 static_cast<uint32_t>(ErrorStatusFlags::terminateFwErr)),
747 1);
748 }
749
750 if (isBMCSRC() || isHostbootSRC())
751 {
752 jsonInsert(ps, "Deconfigured",
753 pv::boolString.at(
754 _hexData[3] &
755 static_cast<uint32_t>(ErrorStatusFlags::deconfigured)),
756 1);
757
758 jsonInsert(
759 ps, "Guarded",
760 pv::boolString.at(
761 _hexData[3] & static_cast<uint32_t>(ErrorStatusFlags::guarded)),
762 1);
763 }
764
765 auto errorDetails = getErrorDetails(registry, DetailLevel::json, true);
766 if (errorDetails)
767 {
768 ps.append(errorDetails.value());
769 }
770 jsonInsert(ps, "Valid Word Count", getNumberString("0x%02X", _wordCount),
771 1);
772 std::string refcode = asciiString();
773 hexwords.push_back(refcode);
774 std::string extRefcode;
775 size_t pos = refcode.find(0x20);
776 if (pos != std::string::npos)
777 {
778 size_t nextPos = refcode.find_first_not_of(0x20, pos);
779 if (nextPos != std::string::npos)
780 {
781 extRefcode = trimEnd(refcode.substr(nextPos));
782 }
783 refcode.erase(pos);
784 }
785 jsonInsert(ps, "Reference Code", refcode, 1);
786 if (!extRefcode.empty())
787 {
788 jsonInsert(ps, "Extended Reference Code", extRefcode, 1);
789 }
790 for (size_t i = 2; i <= _wordCount; i++)
791 {
792 std::string tmpWord =
793 getNumberString("%08X", _hexData[getWordIndexFromWordNum(i)]);
794 jsonInsert(ps, "Hex Word " + std::to_string(i), tmpWord, 1);
795 hexwords.push_back(tmpWord);
796 }
797 auto calloutJson = getCallouts();
798 if (calloutJson)
799 {
800 ps.append(calloutJson.value());
801 ps.append(",\n");
802 }
803 std::string subsystem = getNumberString("%c", tolower(creatorID));
804 bool srcDetailExists = false;
805 #ifdef PELTOOL
806 if (std::find(plugins.begin(), plugins.end(), subsystem + "src") !=
807 plugins.end())
808 {
809 auto pyJson = getPythonJSON(hexwords, creatorID);
810 if (pyJson)
811 {
812 ps.append(pyJson.value());
813 srcDetailExists = true;
814 }
815 }
816 #endif
817 if (!srcDetailExists)
818 {
819 ps.erase(ps.size() - 2);
820 }
821 return ps;
822 }
823
addCallouts(const message::Entry & regEntry,const AdditionalData & additionalData,const nlohmann::json & jsonCallouts,const DataInterfaceBase & dataIface)824 void SRC::addCallouts(const message::Entry& regEntry,
825 const AdditionalData& additionalData,
826 const nlohmann::json& jsonCallouts,
827 const DataInterfaceBase& dataIface)
828 {
829 auto registryCallouts =
830 getRegistryCallouts(regEntry, additionalData, dataIface);
831
832 auto item = additionalData.getValue("CALLOUT_INVENTORY_PATH");
833 auto priority = additionalData.getValue("CALLOUT_PRIORITY");
834
835 std::optional<CalloutPriority> calloutPriority;
836
837 // Only H, M or L priority values.
838 if (priority && !(*priority).empty())
839 {
840 uint8_t p = (*priority)[0];
841 if (p == 'H' || p == 'M' || p == 'L')
842 {
843 calloutPriority = static_cast<CalloutPriority>(p);
844 }
845 }
846 // If the first registry callout says to use the passed in inventory
847 // path to get the location code for a symbolic FRU callout with a
848 // trusted location code, then do not add the inventory path as a
849 // normal FRU callout.
850 bool useInvForSymbolicFRULocCode =
851 !registryCallouts.empty() && registryCallouts[0].useInventoryLocCode &&
852 !registryCallouts[0].symbolicFRUTrusted.empty();
853
854 if (item && !useInvForSymbolicFRULocCode)
855 {
856 addInventoryCallout(*item, calloutPriority, std::nullopt, dataIface);
857 }
858
859 addDevicePathCallouts(additionalData, dataIface);
860
861 addRegistryCallouts(registryCallouts, dataIface,
862 (useInvForSymbolicFRULocCode) ? item : std::nullopt);
863
864 if (!jsonCallouts.empty())
865 {
866 addJSONCallouts(jsonCallouts, dataIface);
867 }
868 }
869
addLocationCodeOnlyCallout(const std::string & locationCode,const CalloutPriority priority)870 void SRC::addLocationCodeOnlyCallout(const std::string& locationCode,
871 const CalloutPriority priority)
872 {
873 std::string empty;
874 std::vector<src::MRU::MRUCallout> mrus;
875 auto callout = std::make_unique<src::Callout>(priority, locationCode, empty,
876 empty, empty, mrus);
877 createCalloutsObject();
878 _callouts->addCallout(std::move(callout));
879 }
880
addInventoryCallout(const std::string & inventoryPath,const std::optional<CalloutPriority> & priority,const std::optional<std::string> & locationCode,const DataInterfaceBase & dataIface,const std::vector<src::MRU::MRUCallout> & mrus)881 void SRC::addInventoryCallout(const std::string& inventoryPath,
882 const std::optional<CalloutPriority>& priority,
883 const std::optional<std::string>& locationCode,
884 const DataInterfaceBase& dataIface,
885 const std::vector<src::MRU::MRUCallout>& mrus)
886 {
887 std::string locCode;
888 std::string fn;
889 std::string ccin;
890 std::string sn;
891 std::unique_ptr<src::Callout> callout;
892
893 try
894 {
895 // Use the passed in location code if there otherwise look it up
896 if (locationCode)
897 {
898 locCode = *locationCode;
899 }
900 else
901 {
902 locCode = dataIface.getLocationCode(inventoryPath);
903 }
904
905 try
906 {
907 dataIface.getHWCalloutFields(inventoryPath, fn, ccin, sn);
908
909 CalloutPriority p =
910 priority ? priority.value() : CalloutPriority::high;
911
912 callout =
913 std::make_unique<src::Callout>(p, locCode, fn, ccin, sn, mrus);
914 }
915 catch (const sdbusplus::exception_t& e)
916 {
917 std::string msg =
918 "No VPD found for " + inventoryPath + ": " + e.what();
919 addDebugData(msg);
920
921 // Just create the callout with empty FRU fields
922 callout = std::make_unique<src::Callout>(
923 CalloutPriority::high, locCode, fn, ccin, sn, mrus);
924 }
925 }
926 catch (const sdbusplus::exception_t& e)
927 {
928 std::string msg = "Could not get location code for " + inventoryPath +
929 ": " + e.what();
930 addDebugData(msg);
931
932 // Don't add a callout in this case, because:
933 // 1) With how the inventory is primed, there is no case where
934 // a location code is expected to be missing. This implies
935 // the caller is passing in something invalid.
936 // 2) The addDebugData call above will put the passed in path into
937 // a user data section that can be seen by development for debug.
938 // 3) Even if we wanted to do a 'no_vpd_for_fru' sort of maint.
939 // procedure, we don't have a good way to indicate to the user
940 // anything about the intended callout (they won't see user data).
941 // 4) Creating a new standalone event log for this problem isn't
942 // possible from inside a PEL section.
943 }
944
945 if (callout)
946 {
947 createCalloutsObject();
948 _callouts->addCallout(std::move(callout));
949 }
950 }
951
getRegistryCallouts(const message::Entry & regEntry,const AdditionalData & additionalData,const DataInterfaceBase & dataIface)952 std::vector<message::RegistryCallout> SRC::getRegistryCallouts(
953 const message::Entry& regEntry, const AdditionalData& additionalData,
954 const DataInterfaceBase& dataIface)
955 {
956 std::vector<message::RegistryCallout> registryCallouts;
957
958 if (regEntry.callouts)
959 {
960 std::vector<std::string> systemNames;
961
962 try
963 {
964 systemNames = dataIface.getSystemNames();
965 }
966 catch (const std::exception& e)
967 {
968 // Compatible interface not available yet
969 }
970
971 try
972 {
973 registryCallouts = message::Registry::getCallouts(
974 regEntry.callouts.value(), systemNames, additionalData);
975 }
976 catch (const std::exception& e)
977 {
978 addDebugData(std::format(
979 "Error parsing PEL message registry callout JSON: {}",
980 e.what()));
981 }
982 }
983
984 return registryCallouts;
985 }
986
addRegistryCallouts(const std::vector<message::RegistryCallout> & callouts,const DataInterfaceBase & dataIface,std::optional<std::string> trustedSymbolicFRUInvPath)987 void SRC::addRegistryCallouts(
988 const std::vector<message::RegistryCallout>& callouts,
989 const DataInterfaceBase& dataIface,
990 std::optional<std::string> trustedSymbolicFRUInvPath)
991 {
992 try
993 {
994 for (const auto& callout : callouts)
995 {
996 addRegistryCallout(callout, dataIface, trustedSymbolicFRUInvPath);
997
998 // Only the first callout gets the inventory path
999 if (trustedSymbolicFRUInvPath)
1000 {
1001 trustedSymbolicFRUInvPath = std::nullopt;
1002 }
1003 }
1004 }
1005 catch (const std::exception& e)
1006 {
1007 std::string msg =
1008 "Error parsing PEL message registry callout JSON: "s + e.what();
1009 addDebugData(msg);
1010 }
1011 }
1012
addRegistryCallout(const message::RegistryCallout & regCallout,const DataInterfaceBase & dataIface,const std::optional<std::string> & trustedSymbolicFRUInvPath)1013 void SRC::addRegistryCallout(
1014 const message::RegistryCallout& regCallout,
1015 const DataInterfaceBase& dataIface,
1016 const std::optional<std::string>& trustedSymbolicFRUInvPath)
1017 {
1018 std::unique_ptr<src::Callout> callout;
1019 auto locCode = regCallout.locCode;
1020 bool locExpanded = true;
1021
1022 if (!locCode.empty())
1023 {
1024 try
1025 {
1026 locCode = dataIface.expandLocationCode(locCode, 0);
1027 }
1028 catch (const std::exception& e)
1029 {
1030 auto msg = "Unable to expand location code " + locCode + ": " +
1031 e.what();
1032 addDebugData(msg);
1033 locExpanded = false;
1034 }
1035 }
1036
1037 // Via the PEL values table, get the priority enum.
1038 // The schema will have validated the priority was a valid value.
1039 auto priorityIt =
1040 pv::findByName(regCallout.priority, pv::calloutPriorityValues);
1041 assert(priorityIt != pv::calloutPriorityValues.end());
1042 auto priority =
1043 static_cast<CalloutPriority>(std::get<pv::fieldValuePos>(*priorityIt));
1044
1045 if (!regCallout.procedure.empty())
1046 {
1047 // Procedure callout
1048 callout = std::make_unique<src::Callout>(priority, regCallout.procedure,
1049 src::CalloutValueType::raw);
1050 }
1051 else if (!regCallout.symbolicFRU.empty())
1052 {
1053 // Symbolic FRU callout
1054 callout = std::make_unique<src::Callout>(
1055 priority, regCallout.symbolicFRU, locCode, false);
1056 }
1057 else if (!regCallout.symbolicFRUTrusted.empty())
1058 {
1059 // Symbolic FRU with trusted location code callout
1060 bool trusted = false;
1061
1062 // Use the location code from the inventory path if there is one.
1063 if (trustedSymbolicFRUInvPath)
1064 {
1065 try
1066 {
1067 locCode = dataIface.getLocationCode(*trustedSymbolicFRUInvPath);
1068 trusted = true;
1069 }
1070 catch (const std::exception& e)
1071 {
1072 addDebugData(
1073 std::format("Could not get location code for {}: {}",
1074 *trustedSymbolicFRUInvPath, e.what()));
1075 locCode.clear();
1076 }
1077 }
1078
1079 // Can only trust the location code if it isn't empty and is expanded.
1080 if (!locCode.empty() && locExpanded)
1081 {
1082 trusted = true;
1083 }
1084
1085 // The registry wants it to be trusted, but that requires a valid
1086 // location code for it to actually be.
1087 callout = std::make_unique<src::Callout>(
1088 priority, regCallout.symbolicFRUTrusted, locCode, trusted);
1089 }
1090 else
1091 {
1092 // A hardware callout
1093
1094 // If couldn't expand the location code, don't bother
1095 // looking up the inventory path.
1096 if (!locExpanded && !locCode.empty())
1097 {
1098 addLocationCodeOnlyCallout(locCode, priority);
1099 return;
1100 }
1101
1102 std::vector<std::string> inventoryPaths;
1103
1104 try
1105 {
1106 // Get the inventory item from the unexpanded location code
1107 inventoryPaths =
1108 dataIface.getInventoryFromLocCode(regCallout.locCode, 0, false);
1109 }
1110 catch (const std::exception& e)
1111 {
1112 std::string msg =
1113 "Unable to get inventory path from location code: " + locCode +
1114 ": " + e.what();
1115 addDebugData(msg);
1116 if (!locCode.empty())
1117 {
1118 // Still add a callout with just the location code.
1119 addLocationCodeOnlyCallout(locCode, priority);
1120 }
1121 return;
1122 }
1123
1124 // Just use first path returned since they all point to the same FRU.
1125 addInventoryCallout(inventoryPaths[0], priority, locCode, dataIface);
1126 }
1127
1128 if (callout)
1129 {
1130 createCalloutsObject();
1131 _callouts->addCallout(std::move(callout));
1132 }
1133 }
1134
addDevicePathCallouts(const AdditionalData & additionalData,const DataInterfaceBase & dataIface)1135 void SRC::addDevicePathCallouts(const AdditionalData& additionalData,
1136 const DataInterfaceBase& dataIface)
1137 {
1138 std::vector<device_callouts::Callout> callouts;
1139 auto i2cBus = additionalData.getValue("CALLOUT_IIC_BUS");
1140 auto i2cAddr = additionalData.getValue("CALLOUT_IIC_ADDR");
1141 auto devPath = additionalData.getValue("CALLOUT_DEVICE_PATH");
1142
1143 // A device callout contains either:
1144 // * CALLOUT_ERRNO, CALLOUT_DEVICE_PATH
1145 // * CALLOUT_ERRNO, CALLOUT_IIC_BUS, CALLOUT_IIC_ADDR
1146 // We don't care about the errno.
1147
1148 if (devPath)
1149 {
1150 try
1151 {
1152 callouts = device_callouts::getCallouts(*devPath,
1153 dataIface.getSystemNames());
1154 }
1155 catch (const std::exception& e)
1156 {
1157 addDebugData(e.what());
1158 callouts.clear();
1159 }
1160 }
1161 else if (i2cBus && i2cAddr)
1162 {
1163 size_t bus;
1164 uint8_t address;
1165
1166 try
1167 {
1168 // If /dev/i2c- is prepended, remove it
1169 if (i2cBus->find("/dev/i2c-") != std::string::npos)
1170 {
1171 *i2cBus = i2cBus->substr(9);
1172 }
1173
1174 bus = stoul(*i2cBus, nullptr, 0);
1175 address = stoul(*i2cAddr, nullptr, 0);
1176 }
1177 catch (const std::exception& e)
1178 {
1179 std::string msg =
1180 "Invalid CALLOUT_IIC_BUS " + *i2cBus + " or CALLOUT_IIC_ADDR " +
1181 *i2cAddr + " in AdditionalData property";
1182 addDebugData(msg);
1183 return;
1184 }
1185
1186 try
1187 {
1188 callouts = device_callouts::getI2CCallouts(
1189 bus, address, dataIface.getSystemNames());
1190 }
1191 catch (const std::exception& e)
1192 {
1193 addDebugData(e.what());
1194 callouts.clear();
1195 }
1196 }
1197
1198 for (const auto& callout : callouts)
1199 {
1200 // The priority shouldn't be invalid, but check just in case.
1201 CalloutPriority priority = CalloutPriority::high;
1202
1203 if (!callout.priority.empty())
1204 {
1205 auto p = pel_values::findByValue(
1206 static_cast<uint32_t>(callout.priority[0]),
1207 pel_values::calloutPriorityValues);
1208
1209 if (p != pel_values::calloutPriorityValues.end())
1210 {
1211 priority = static_cast<CalloutPriority>(callout.priority[0]);
1212 }
1213 else
1214 {
1215 std::string msg =
1216 "Invalid priority found in dev callout JSON: " +
1217 callout.priority[0];
1218 addDebugData(msg);
1219 }
1220 }
1221
1222 std::optional<std::string> locCode;
1223
1224 try
1225 {
1226 locCode = dataIface.expandLocationCode(callout.locationCode, 0);
1227 }
1228 catch (const std::exception& e)
1229 {
1230 auto msg = std::format("Unable to expand location code {}: {}",
1231 callout.locationCode, e.what());
1232 addDebugData(msg);
1233
1234 // Add the callout with just the unexpanded location code.
1235 addLocationCodeOnlyCallout(callout.locationCode, priority);
1236 continue;
1237 }
1238
1239 try
1240 {
1241 auto inventoryPaths = dataIface.getInventoryFromLocCode(
1242 callout.locationCode, 0, false);
1243
1244 // Just use first path returned since they all
1245 // point to the same FRU.
1246 addInventoryCallout(inventoryPaths[0], priority, locCode,
1247 dataIface);
1248 }
1249 catch (const std::exception& e)
1250 {
1251 std::string msg =
1252 "Unable to get inventory path from location code: " +
1253 callout.locationCode + ": " + e.what();
1254 addDebugData(msg);
1255 // Add the callout with just the location code.
1256 addLocationCodeOnlyCallout(callout.locationCode, priority);
1257 continue;
1258 }
1259
1260 // Until the code is there to convert these MRU value strings to
1261 // the official MRU values in the callout objects, just store
1262 // the MRU name in the debug UserData section.
1263 if (!callout.mru.empty())
1264 {
1265 std::string msg = "MRU: " + callout.mru;
1266 addDebugData(msg);
1267 }
1268
1269 // getCallouts() may have generated some debug data it stored
1270 // in a callout object. Save it as well.
1271 if (!callout.debug.empty())
1272 {
1273 addDebugData(callout.debug);
1274 }
1275 }
1276 }
1277
addJSONCallouts(const nlohmann::json & jsonCallouts,const DataInterfaceBase & dataIface)1278 void SRC::addJSONCallouts(const nlohmann::json& jsonCallouts,
1279 const DataInterfaceBase& dataIface)
1280 {
1281 if (jsonCallouts.empty())
1282 {
1283 return;
1284 }
1285
1286 if (!jsonCallouts.is_array())
1287 {
1288 addDebugData("Callout JSON isn't an array");
1289 return;
1290 }
1291
1292 for (const auto& callout : jsonCallouts)
1293 {
1294 try
1295 {
1296 addJSONCallout(callout, dataIface);
1297 }
1298 catch (const std::exception& e)
1299 {
1300 addDebugData(std::format(
1301 "Failed extracting callout data from JSON: {}", e.what()));
1302 }
1303 }
1304 }
1305
addJSONCallout(const nlohmann::json & jsonCallout,const DataInterfaceBase & dataIface)1306 void SRC::addJSONCallout(const nlohmann::json& jsonCallout,
1307 const DataInterfaceBase& dataIface)
1308 {
1309 auto priority = getPriorityFromJSON(jsonCallout);
1310 std::string locCode;
1311 std::string unexpandedLocCode;
1312 std::unique_ptr<src::Callout> callout;
1313
1314 // Expand the location code if it's there
1315 if (jsonCallout.contains("LocationCode"))
1316 {
1317 unexpandedLocCode = jsonCallout.at("LocationCode").get<std::string>();
1318
1319 try
1320 {
1321 locCode = dataIface.expandLocationCode(unexpandedLocCode, 0);
1322 }
1323 catch (const std::exception& e)
1324 {
1325 addDebugData(std::format("Unable to expand location code {}: {}",
1326 unexpandedLocCode, e.what()));
1327 // Use the value from the JSON so at least there's something
1328 locCode = unexpandedLocCode;
1329 }
1330 }
1331
1332 // Create either a procedure, symbolic FRU, or normal FRU callout.
1333 if (jsonCallout.contains("Procedure"))
1334 {
1335 auto procedure = jsonCallout.at("Procedure").get<std::string>();
1336
1337 // If it's the registry name instead of the raw name, convert.
1338 if (pv::maintenanceProcedures.find(procedure) !=
1339 pv::maintenanceProcedures.end())
1340 {
1341 procedure = pv::maintenanceProcedures.at(procedure);
1342 }
1343
1344 callout = std::make_unique<src::Callout>(
1345 static_cast<CalloutPriority>(priority), procedure,
1346 src::CalloutValueType::raw);
1347 }
1348 else if (jsonCallout.contains("SymbolicFRU"))
1349 {
1350 auto fru = jsonCallout.at("SymbolicFRU").get<std::string>();
1351
1352 // If it's the registry name instead of the raw name, convert.
1353 if (pv::symbolicFRUs.find(fru) != pv::symbolicFRUs.end())
1354 {
1355 fru = pv::symbolicFRUs.at(fru);
1356 }
1357
1358 bool trusted = false;
1359 if (jsonCallout.contains("TrustedLocationCode") && !locCode.empty())
1360 {
1361 trusted = jsonCallout.at("TrustedLocationCode").get<bool>();
1362 }
1363
1364 callout = std::make_unique<src::Callout>(
1365 static_cast<CalloutPriority>(priority), fru,
1366 src::CalloutValueType::raw, locCode, trusted);
1367 }
1368 else
1369 {
1370 // A hardware FRU
1371 std::string inventoryPath;
1372 std::vector<src::MRU::MRUCallout> mrus;
1373
1374 if (jsonCallout.contains("InventoryPath"))
1375 {
1376 inventoryPath = jsonCallout.at("InventoryPath").get<std::string>();
1377 }
1378 else
1379 {
1380 if (unexpandedLocCode.empty())
1381 {
1382 throw std::runtime_error{"JSON callout needs either an "
1383 "inventory path or location code"};
1384 }
1385
1386 try
1387 {
1388 auto inventoryPaths = dataIface.getInventoryFromLocCode(
1389 unexpandedLocCode, 0, false);
1390 // Just use first path returned since they all
1391 // point to the same FRU.
1392 inventoryPath = inventoryPaths[0];
1393 }
1394 catch (const std::exception& e)
1395 {
1396 addDebugData(std::format("Unable to get inventory path from "
1397 "location code: {}: {}",
1398 unexpandedLocCode, e.what()));
1399 addLocationCodeOnlyCallout(locCode, priority);
1400 return;
1401 }
1402 }
1403
1404 if (jsonCallout.contains("MRUs"))
1405 {
1406 mrus = getMRUsFromJSON(jsonCallout.at("MRUs"));
1407 }
1408
1409 // If the location code was also passed in, use that here too
1410 // so addInventoryCallout doesn't have to look it up.
1411 std::optional<std::string> lc;
1412 if (!locCode.empty())
1413 {
1414 lc = locCode;
1415 }
1416
1417 addInventoryCallout(inventoryPath, priority, lc, dataIface, mrus);
1418
1419 if (jsonCallout.contains("Deconfigured"))
1420 {
1421 if (jsonCallout.at("Deconfigured").get<bool>())
1422 {
1423 setErrorStatusFlag(ErrorStatusFlags::deconfigured);
1424 }
1425 }
1426
1427 if (jsonCallout.contains("Guarded"))
1428 {
1429 if (jsonCallout.at("Guarded").get<bool>())
1430 {
1431 setErrorStatusFlag(ErrorStatusFlags::guarded);
1432 }
1433 }
1434 }
1435
1436 if (callout)
1437 {
1438 createCalloutsObject();
1439 _callouts->addCallout(std::move(callout));
1440 }
1441 }
1442
getPriorityFromJSON(const nlohmann::json & json)1443 CalloutPriority SRC::getPriorityFromJSON(const nlohmann::json& json)
1444 {
1445 // Looks like:
1446 // {
1447 // "Priority": "H"
1448 // }
1449 auto p = json.at("Priority").get<std::string>();
1450 if (p.empty())
1451 {
1452 throw std::runtime_error{"Priority field in callout is empty"};
1453 }
1454
1455 auto priority = static_cast<CalloutPriority>(p.front());
1456
1457 // Validate it
1458 auto priorityIt = pv::findByValue(static_cast<uint32_t>(priority),
1459 pv::calloutPriorityValues);
1460 if (priorityIt == pv::calloutPriorityValues.end())
1461 {
1462 throw std::runtime_error{
1463 std::format("Invalid priority '{}' found in JSON callout", p)};
1464 }
1465
1466 return priority;
1467 }
1468
getMRUsFromJSON(const nlohmann::json & mruJSON)1469 std::vector<src::MRU::MRUCallout> SRC::getMRUsFromJSON(
1470 const nlohmann::json& mruJSON)
1471 {
1472 std::vector<src::MRU::MRUCallout> mrus;
1473
1474 // Looks like:
1475 // [
1476 // {
1477 // "ID": 100,
1478 // "Priority": "H"
1479 // }
1480 // ]
1481 if (!mruJSON.is_array())
1482 {
1483 addDebugData("MRU callout JSON is not an array");
1484 return mrus;
1485 }
1486
1487 for (const auto& mruCallout : mruJSON)
1488 {
1489 try
1490 {
1491 auto priority = getPriorityFromJSON(mruCallout);
1492 auto id = mruCallout.at("ID").get<uint32_t>();
1493
1494 src::MRU::MRUCallout mru{static_cast<uint32_t>(priority), id};
1495 mrus.push_back(std::move(mru));
1496 }
1497 catch (const std::exception& e)
1498 {
1499 addDebugData(std::format("Invalid MRU entry in JSON: {}: {}",
1500 mruCallout.dump(), e.what()));
1501 }
1502 }
1503
1504 return mrus;
1505 }
1506
getSrcStruct()1507 std::vector<uint8_t> SRC::getSrcStruct()
1508 {
1509 std::vector<uint8_t> data;
1510 Stream stream{data};
1511
1512 //------ Ref section 4.3 in PEL doc---
1513 //------ SRC Structure 40 bytes-------
1514 // Byte-0 | Byte-1 | Byte-2 | Byte-3 |
1515 // -----------------------------------
1516 // 02 | 08 | 00 | 09 | ==> Header
1517 // 00 | 00 | 00 | 48 | ==> Header
1518 // 00 | 00 | 00 | 00 | ==> Hex data word-2
1519 // 00 | 00 | 00 | 00 | ==> Hex data word-3
1520 // 00 | 00 | 00 | 00 | ==> Hex data word-4
1521 // 20 | 00 | 00 | 00 | ==> Hex data word-5
1522 // 00 | 00 | 00 | 00 | ==> Hex data word-6
1523 // 00 | 00 | 00 | 00 | ==> Hex data word-7
1524 // 00 | 00 | 00 | 00 | ==> Hex data word-8
1525 // 00 | 00 | 00 | 00 | ==> Hex data word-9
1526 // -----------------------------------
1527 // ASCII string - 8 bytes |
1528 // -----------------------------------
1529 // ASCII space NULL - 24 bytes |
1530 // -----------------------------------
1531 //_size = Base SRC struct: 8 byte header + hex data section + ASCII string
1532
1533 uint8_t flags = (_flags | postOPPanel);
1534
1535 stream << _version << flags << _reserved1B << _wordCount << _reserved2B
1536 << _size;
1537
1538 for (auto& word : _hexData)
1539 {
1540 stream << word;
1541 }
1542
1543 _asciiString->flatten(stream);
1544
1545 return data;
1546 }
1547
setProgressCode(const DataInterfaceBase & dataIface)1548 void SRC::setProgressCode(const DataInterfaceBase& dataIface)
1549 {
1550 std::vector<uint8_t> progressSRC;
1551
1552 try
1553 {
1554 progressSRC = dataIface.getRawProgressSRC();
1555 }
1556 catch (const std::exception& e)
1557 {
1558 lg2::error("Error getting progress code: {ERROR}", "ERROR", e);
1559 return;
1560 }
1561
1562 _hexData[2] = getProgressCode(progressSRC);
1563 }
1564
getProgressCode(std::vector<uint8_t> & rawProgressSRC)1565 uint32_t SRC::getProgressCode(std::vector<uint8_t>& rawProgressSRC)
1566 {
1567 uint32_t progressCode = 0;
1568
1569 // A valid progress SRC is at least 72 bytes
1570 if (rawProgressSRC.size() < 72)
1571 {
1572 return progressCode;
1573 }
1574
1575 try
1576 {
1577 // The ASCII string field in progress SRCs starts at offset 40.
1578 // Take the first 8 characters to put in the uint32:
1579 // "CC009189" -> 0xCC009189
1580 Stream stream{rawProgressSRC, 40};
1581 src::AsciiString aString{stream};
1582 auto progressCodeString = aString.get().substr(0, 8);
1583
1584 if (std::all_of(progressCodeString.begin(), progressCodeString.end(),
1585 [](char c) {
1586 return std::isxdigit(static_cast<unsigned char>(c));
1587 }))
1588 {
1589 progressCode = std::stoul(progressCodeString, nullptr, 16);
1590 }
1591 }
1592 catch (const std::exception& e)
1593 {}
1594
1595 return progressCode;
1596 }
1597
1598 } // namespace pels
1599 } // namespace openpower
1600