blob: 3e6e519b3dbbaf03c646902248c126a0f9cac6a8 [file] [log] [blame]
Matt Spinlerf9bae182019-10-09 13:37:38 -05001#pragma once
2
3#include "additional_data.hpp"
4#include "ascii_string.hpp"
5#include "callouts.hpp"
Matt Spinler075e5ba2020-02-21 15:46:00 -06006#include "data_interface.hpp"
Matt Spinlerf9bae182019-10-09 13:37:38 -05007#include "pel_types.hpp"
Matt Spinlerbd716f02019-10-15 10:54:11 -05008#include "registry.hpp"
Matt Spinlerf9bae182019-10-09 13:37:38 -05009#include "section.hpp"
10#include "stream.hpp"
11
12namespace openpower
13{
14namespace pels
15{
16
Matt Spinlerbd716f02019-10-15 10:54:11 -050017constexpr uint8_t srcSectionVersion = 0x01;
18constexpr uint8_t srcSectionSubtype = 0x01;
Matt Spinlerf9bae182019-10-09 13:37:38 -050019constexpr size_t numSRCHexDataWords = 8;
Matt Spinlerbd716f02019-10-15 10:54:11 -050020constexpr uint8_t srcVersion = 0x02;
21constexpr uint8_t bmcSRCFormat = 0x55;
22constexpr uint8_t primaryBMCPosition = 0x10;
23constexpr size_t baseSRCSize = 72;
Matt Spinlerf9bae182019-10-09 13:37:38 -050024
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +080025enum class DetailLevel
26{
27 message = 0x01,
28 json = 0x02
29};
Matt Spinlerf9bae182019-10-09 13:37:38 -050030/**
31 * @class SRC
32 *
33 * SRC stands for System Reference Code.
34 *
35 * This class represents the SRC sections in the PEL, of which there are 2:
36 * primary SRC and secondary SRC. These are the same structurally, the
37 * difference is that the primary SRC must be the 3rd section in the PEL if
38 * present and there is only one of them, and the secondary SRC sections are
39 * optional and there can be more than one (by definition, for there to be a
40 * secondary SRC, a primary SRC must also exist).
41 *
42 * This section consists of:
43 * - An 8B header (Has the version, flags, hexdata word count, and size fields)
44 * - 8 4B words of hex data
45 * - An ASCII character string
46 * - An optional subsection for Callouts
47 */
48class SRC : public Section
49{
50 public:
51 enum HeaderFlags
52 {
Matt Spinlerbd716f02019-10-15 10:54:11 -050053 additionalSections = 0x01,
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +080054 powerFaultEvent = 0x02,
55 hypDumpInit = 0x04,
Sumit Kumar3e274432021-09-14 06:37:56 -050056 postOPPanel = 0x08,
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +080057 i5OSServiceEventBit = 0x10,
58 virtualProgressSRC = 0x80
Matt Spinlerf9bae182019-10-09 13:37:38 -050059 };
60
Matt Spinlerafa2c792020-08-27 11:01:39 -050061 /**
62 * @brief Enums for the error status bits in hex word 5
63 * of BMC SRCs.
64 */
65 enum class ErrorStatusFlags
66 {
Sumit Kumar3e274432021-09-14 06:37:56 -050067 terminateFwErr = 0x20000000,
Matt Spinlerafa2c792020-08-27 11:01:39 -050068 deconfigured = 0x02000000,
69 guarded = 0x01000000
70 };
71
Matt Spinlerf9bae182019-10-09 13:37:38 -050072 SRC() = delete;
73 ~SRC() = default;
74 SRC(const SRC&) = delete;
75 SRC& operator=(const SRC&) = delete;
76 SRC(SRC&&) = delete;
77 SRC& operator=(SRC&&) = delete;
78
79 /**
80 * @brief Constructor
81 *
82 * Fills in this class's data fields from the stream.
83 *
84 * @param[in] pel - the PEL data stream
85 */
86 explicit SRC(Stream& pel);
87
88 /**
Matt Spinlerbd716f02019-10-15 10:54:11 -050089 * @brief Constructor
90 *
91 * Creates the section with data from the PEL message registry entry for
92 * this error, along with the AdditionalData property contents from the
93 * corresponding event log.
94 *
95 * @param[in] regEntry - The message registry entry for this event log
96 * @param[in] additionalData - The AdditionalData properties in this event
97 * log
Matt Spinler075e5ba2020-02-21 15:46:00 -060098 * @param[in] dataIface - The DataInterface object
Matt Spinlerbd716f02019-10-15 10:54:11 -050099 */
Matt Spinler075e5ba2020-02-21 15:46:00 -0600100 SRC(const message::Entry& regEntry, const AdditionalData& additionalData,
Matt Spinler5a90a952020-08-27 09:39:03 -0500101 const DataInterfaceBase& dataIface) :
102 SRC(regEntry, additionalData, nlohmann::json{}, dataIface)
Patrick Williams2544b412022-10-04 08:41:06 -0500103 {}
Matt Spinler5a90a952020-08-27 09:39:03 -0500104
105 /**
106 * @brief Constructor
107 *
108 * Creates the section with data from the PEL message registry entry for
109 * this error, along with the AdditionalData property contents from the
110 * corresponding event log, and a JSON array of callouts to add.
111 *
112 * @param[in] regEntry - The message registry entry for this event log
113 * @param[in] additionalData - The AdditionalData properties in this event
114 * log
115 * @param[in] jsonCallouts - The array of JSON callouts, or an empty object.
116 * @param[in] dataIface - The DataInterface object
117 */
118 SRC(const message::Entry& regEntry, const AdditionalData& additionalData,
119 const nlohmann::json& jsonCallouts, const DataInterfaceBase& dataIface);
Matt Spinlerbd716f02019-10-15 10:54:11 -0500120
121 /**
Matt Spinlerf9bae182019-10-09 13:37:38 -0500122 * @brief Flatten the section into the stream
123 *
124 * @param[in] stream - The stream to write to
125 */
Matt Spinler06885452019-11-06 10:35:42 -0600126 void flatten(Stream& stream) const override;
Matt Spinlerf9bae182019-10-09 13:37:38 -0500127
128 /**
129 * @brief Returns the SRC version, which is a different field
130 * than the version byte in the section header.
131 *
132 * @return uint8_t
133 */
134 uint8_t version() const
135 {
136 return _version;
137 }
138
139 /**
140 * @brief Returns the flags byte
141 *
142 * @return uint8_t
143 */
144 uint8_t flags() const
145 {
146 return _flags;
147 }
148
149 /**
150 * @brief Returns the hex data word count.
151 *
152 * Even though there always 8 words, this returns 9 due to previous
153 * SRC version formats.
154 *
155 * @return uint8_t
156 */
157 uint8_t hexWordCount() const
158 {
159 return _wordCount;
160 }
161
162 /**
163 * @brief Returns the size of the SRC section, not including the header.
164 *
165 * @return uint16_t
166 */
167 uint16_t size() const
168 {
169 return _size;
170 }
171
172 /**
173 * @brief Returns the 8 hex data words.
174 *
175 * @return const std::array<uint32_t, numSRCHexDataWords>&
176 */
177 const std::array<uint32_t, numSRCHexDataWords>& hexwordData() const
178 {
179 return _hexData;
180 }
181
182 /**
183 * @brief Returns the ASCII string
184 *
185 * @return std::string
186 */
187 std::string asciiString() const
188 {
189 return _asciiString->get();
190 }
191
192 /**
193 * @brief Returns the callouts subsection
194 *
195 * If no callouts, this unique_ptr will be empty
196 *
197 * @return const std::unique_ptr<src::Callouts>&
198 */
199 const std::unique_ptr<src::Callouts>& callouts() const
200 {
201 return _callouts;
202 }
203
Matt Spinlerf9bae182019-10-09 13:37:38 -0500204 /**
Matt Spinlerbd716f02019-10-15 10:54:11 -0500205 * @brief Returns the size of this section when flattened into a PEL
Matt Spinlerf9bae182019-10-09 13:37:38 -0500206 *
Matt Spinlerbd716f02019-10-15 10:54:11 -0500207 * @return size_t - the size of the section
Matt Spinlerf9bae182019-10-09 13:37:38 -0500208 */
Matt Spinlerbd716f02019-10-15 10:54:11 -0500209 size_t flattenedSize() const
210 {
211 return _header.size;
212 }
Matt Spinlerf9bae182019-10-09 13:37:38 -0500213
214 /**
215 * @brief Says if this SRC has additional subsections in it
216 *
217 * Note: The callouts section is the only possible subsection.
218 *
219 * @return bool
220 */
221 inline bool hasAdditionalSections() const
222 {
Matt Spinlerbd716f02019-10-15 10:54:11 -0500223 return _flags & additionalSections;
224 }
225
226 /**
227 * @brief Indicates if this event log is for a power fault.
228 *
229 * This comes from a field in the message registry for BMC
230 * generated PELs.
231 *
232 * @return bool
233 */
234 inline bool isPowerFaultEvent() const
235 {
236 return _flags & powerFaultEvent;
237 }
238
Matt Spinlerc63e2e82019-12-02 15:50:12 -0600239 /**
240 * @brief Get the _hexData[] index to use based on the corresponding
241 * SRC word number.
242 *
243 * Converts the specification nomenclature to this data structure.
244 * See the _hexData documentation below for more information.
245 *
246 * @param[in] wordNum - The SRC word number, as defined by the spec.
247 *
248 * @return size_t The corresponding index into _hexData.
249 */
250 inline size_t getWordIndexFromWordNum(size_t wordNum) const
251 {
252 assert(wordNum >= 2 && wordNum <= 9);
253 return wordNum - 2;
254 }
255
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800256 /**
257 * @brief Get section in JSON.
Harisuddin Mohamed Isaa214ed32020-02-28 15:58:23 +0800258 * @param[in] registry - Registry object reference
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800259 * @param[in] plugins - Vector of strings of plugins found in filesystem
260 * @param[in] creatorID - Creator Subsystem ID from Private Header
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800261 * @return std::optional<std::string> - SRC section's JSON
262 */
Harisuddin Mohamed Isac8d6cc62020-08-19 22:47:19 +0800263 std::optional<std::string> getJSON(message::Registry& registry,
264 const std::vector<std::string>& plugins,
265 uint8_t creatorID) const override;
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800266
267 /**
268 * @brief Get error details based on refcode and hexwords
269 * @param[in] registry - Registry object
270 * @param[in] type - detail level enum value : single message or full json
271 * @param[in] toCache - boolean to cache registry in memory, default=false
272 * @return std::optional<std::string> - Error details
273 */
274 std::optional<std::string> getErrorDetails(message::Registry& registry,
275 DetailLevel type,
276 bool toCache = false) const;
277
Matt Spinler075e5ba2020-02-21 15:46:00 -0600278 /**
279 * @brief Says if this SRC was created by the BMC (i.e. this code).
280 *
281 * @return bool - If created by the BMC or not
282 */
283 bool isBMCSRC() const;
284
Sumit Kumar3e274432021-09-14 06:37:56 -0500285 /**
286 * @brief Set the terminate bit in hex data word 3.
287 */
288 void setTerminateBit()
289 {
290 setErrorStatusFlag(ErrorStatusFlags::terminateFwErr);
291 }
292
293 /**
294 * @brief Get the SRC structure to pass on to the boot progress dbus
295 * interface.
296 *
297 * @return std::vector<uint8_t> - SRC struct data
298 */
299 std::vector<uint8_t> getSrcStruct();
300
Vijay Lobo875b6c72021-10-20 17:38:56 -0500301 /**
302 * @brief Extracts the first 8 characters of the ASCII String field
303 * from the raw progress SRC and converts it to a uint32_t.
304 *
305 * @param[in] rawProgressSRC - The progress SRC bytes
306 *
307 * @return uint32_t - The code, like 0xCC0099EE from "CC0099EE"
308 */
309 static uint32_t getProgressCode(std::vector<uint8_t>& rawProgressSRC);
310
Matt Spinlerbd716f02019-10-15 10:54:11 -0500311 private:
312 /**
313 * @brief Fills in the user defined hex words from the
314 * AdditionalData fields.
315 *
316 * When creating this section from a message registry entry,
317 * that entry has a field that says which AdditionalData property
318 * fields to use to fill in the user defined hex data words 6-9
319 * (which correspond to hexData words 4-7).
320 *
321 * For example, given that AdditionalData is a map of string keys
322 * to string values, find the AdditionalData value for AdditionalData
323 * key X, convert it to a uint32_t, and save it in user data word Y.
324 *
325 * @param[in] regEntry - The message registry entry for the error
326 * @param[in] additionalData - The AdditionalData map
327 */
328 void setUserDefinedHexWords(const message::Entry& regEntry,
329 const AdditionalData& additionalData);
330 /**
331 * @brief Fills in the object from the stream data
332 *
333 * @param[in] stream - The stream to read from
334 */
335 void unflatten(Stream& stream);
336
337 /**
Matt Spinlerbd716f02019-10-15 10:54:11 -0500338 * @brief Says if the word number is in the range of user defined words.
339 *
340 * This is only used for BMC generated SRCs, where words 6 - 9 are the
341 * user defined ones, meaning that setUserDefinedHexWords() will be
342 * used to fill them in based on the contents of the OpenBMC event log.
343 *
344 * @param[in] wordNum - The SRC word number, as defined by the spec.
345 *
346 * @return bool - If this word number can be filled in by the creator.
347 */
348 inline bool isUserDefinedWord(size_t wordNum) const
349 {
350 return (wordNum >= 6) && (wordNum <= 9);
351 }
352
353 /**
354 * @brief Sets the SRC format byte in the hex word data.
355 */
356 inline void setBMCFormat()
357 {
358 _hexData[0] |= bmcSRCFormat;
359 }
360
361 /**
362 * @brief Sets the hex word field that specifies which BMC
363 * (primary vs backup) created the error.
364 *
365 * Can be hardcoded until there are systems with redundant BMCs.
366 */
367 inline void setBMCPosition()
368 {
369 _hexData[1] |= primaryBMCPosition;
Matt Spinlerf9bae182019-10-09 13:37:38 -0500370 }
371
372 /**
Matt Spinler075e5ba2020-02-21 15:46:00 -0600373 * @brief Sets the motherboard CCIN hex word field
374 *
375 * @param[in] dataIface - The DataInterface object
376 */
377 void setMotherboardCCIN(const DataInterfaceBase& dataIface);
378
379 /**
Vijay Lobo875b6c72021-10-20 17:38:56 -0500380 * @brief Sets the progress code hex word field
381 *
382 * @param[in] dataIface - The DataInterface object
383 */
384 void setProgressCode(const DataInterfaceBase& dataIface);
385
386 /**
Matt Spinlerafa2c792020-08-27 11:01:39 -0500387 * @brief Sets an error status bit in the SRC.
388 *
389 * @param[in] flag - The flag to set
390 */
391 void setErrorStatusFlag(ErrorStatusFlags flag)
392 {
393 _hexData[3] |= static_cast<uint32_t>(flag);
394 }
395
396 /**
Matt Spinlerf9bae182019-10-09 13:37:38 -0500397 * @brief Validates the section contents
398 *
399 * Updates _valid (in Section) with the results.
400 */
401 void validate() override;
402
403 /**
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800404 * @brief Get error description from message registry
405 * @param[in] regEntry - The message registry entry for the error
406 * @return std::optional<std::string> - Error message
407 */
408 std::optional<std::string>
409 getErrorMessage(const message::Entry& regEntry) const;
410
411 /**
412 * @brief Get Callout info in JSON
413 * @return std::optional<std::string> - Callout details
414 */
415 std::optional<std::string> getCallouts() const;
416
417 /**
Matt Spinlered046852020-03-13 13:58:15 -0500418 * @brief Checks the AdditionalData property and the message registry
419 * JSON and adds any necessary callouts.
420 *
421 * The callout sources are the AdditionalData event log property
422 * and the message registry JSON.
423 *
Matt Spinler03984582020-04-09 13:17:58 -0500424 * @param[in] regEntry - The message registry entry for the error
425 * @param[in] additionalData - The AdditionalData values
Matt Spinler5a90a952020-08-27 09:39:03 -0500426 * @param[in] jsonCallouts - The array of JSON callouts, or an empty object
Matt Spinlered046852020-03-13 13:58:15 -0500427 * @param[in] dataIface - The DataInterface object
428 */
Matt Spinler03984582020-04-09 13:17:58 -0500429 void addCallouts(const message::Entry& regEntry,
430 const AdditionalData& additionalData,
Matt Spinler5a90a952020-08-27 09:39:03 -0500431 const nlohmann::json& jsonCallouts,
Matt Spinlered046852020-03-13 13:58:15 -0500432 const DataInterfaceBase& dataIface);
433
434 /**
435 * @brief Adds a FRU callout based on an inventory path
436 *
437 * @param[in] inventoryPath - The inventory item to call out
Matt Spinleraf191c72020-06-04 11:35:13 -0500438 * @param[in] priority - An optional priority (uses high if nullopt)
439 * @param[in] locationCode - The expanded location code (or look it up)
Matt Spinlered046852020-03-13 13:58:15 -0500440 * @param[in] dataIface - The DataInterface object
Matt Spinlerb8cb60f2020-08-27 10:55:55 -0500441 * @param[in] mrus - The MRUs to add to the callout
Matt Spinlered046852020-03-13 13:58:15 -0500442 */
Matt Spinlerb8cb60f2020-08-27 10:55:55 -0500443 void
444 addInventoryCallout(const std::string& inventoryPath,
445 const std::optional<CalloutPriority>& priority,
446 const std::optional<std::string>& locationCode,
447 const DataInterfaceBase& dataIface,
448 const std::vector<src::MRU::MRUCallout>& mrus = {});
Matt Spinlered046852020-03-13 13:58:15 -0500449
450 /**
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500451 * @brief Returns the callouts to use from the registry entry.
452 *
Matt Spinler03984582020-04-09 13:17:58 -0500453 * @param[in] regEntry - The message registry entry for the error
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500454 * @param[in] additionalData - The AdditionalData property
Matt Spinler03984582020-04-09 13:17:58 -0500455 * @param[in] dataIface - The DataInterface object
456 */
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500457 std::vector<message::RegistryCallout>
458 getRegistryCallouts(const message::Entry& regEntry,
459 const AdditionalData& additionalData,
460 const DataInterfaceBase& dataIface);
461
462 /**
463 * @brief Adds the FRU callouts from the list of registry callouts
464 * passed in to the SRC.
465 *
466 * The last parameter is used only in a special case when the first
467 * callout is a symbolic FRU with a trusted location code. See the
468 * addRegistryCallout documentation.
469 *
470 * @param[in] callouts - The message registry callouts to add
471 * @param[in] dataIface - The DataInterface object
472 * @param[in] trustedSymbolicFRUInvPath - The optional inventory path used
473 * in the symbolic FRU case.
474 */
475 void addRegistryCallouts(
476 const std::vector<message::RegistryCallout>& callouts,
477 const DataInterfaceBase& dataIface,
478 std::optional<std::string> trustedSymbolicFRUInvPath);
Matt Spinler03984582020-04-09 13:17:58 -0500479
480 /**
481 * @brief Adds a single FRU callout from the message registry.
482 *
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500483 * If the last parameter is filled in, and the registry callout is a
484 * symbolic FRU callout with a trusted location code, and it has the
485 * 'useInventoryLocCode' member set to true, then the location code of
486 * that inventory item will be what is used for that trusted location code.
487 *
Matt Spinler03984582020-04-09 13:17:58 -0500488 * @param[in] callout - The registry callout structure
489 * @param[in] dataIface - The DataInterface object
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500490 * @param[in] trustedSymbolicFRUInvPath - The optional inventory path used
491 * in the symbolic FRU case.
Matt Spinler03984582020-04-09 13:17:58 -0500492 */
Matt Spinlerf00f9d02020-10-23 09:14:22 -0500493 void addRegistryCallout(
494 const message::RegistryCallout& callout,
495 const DataInterfaceBase& dataIface,
496 const std::optional<std::string>& trustedSymbolicFRUInvPath);
Matt Spinler03984582020-04-09 13:17:58 -0500497
498 /**
Matt Spinlered046852020-03-13 13:58:15 -0500499 * @brief Creates the Callouts object _callouts
500 * so that callouts can be added to it.
501 */
502 void createCalloutsObject()
503 {
504 if (!_callouts)
505 {
506 _callouts = std::make_unique<src::Callouts>();
507 _flags |= additionalSections;
508 }
509 }
510
511 /**
Matt Spinler717de422020-06-04 13:10:14 -0500512 * @brief Adds any FRU callouts based on a device path in the
513 * AdditionalData parameter.
514 *
515 * @param[in] additionalData - The AdditionalData values
516 * @param[in] dataIface - The DataInterface object
517 */
518 void addDevicePathCallouts(const AdditionalData& additionalData,
519 const DataInterfaceBase& dataIface);
520
521 /**
Matt Spinler5a90a952020-08-27 09:39:03 -0500522 * @brief Adds any FRU callouts specified in the incoming JSON.
523 *
524 * @param[in] jsonCallouts - The JSON array of callouts
525 * @param[in] dataIface - The DataInterface object
526 */
527 void addJSONCallouts(const nlohmann::json& jsonCallouts,
528 const DataInterfaceBase& dataIface);
529
530 /**
531 * @brief Adds a single callout based on the JSON
532 *
533 * @param[in] jsonCallouts - A single callout entry
534 * @param[in] dataIface - The DataInterface object
535 */
536 void addJSONCallout(const nlohmann::json& jsonCallout,
537 const DataInterfaceBase& dataIface);
Matt Spinler3bdd0112020-08-27 10:24:34 -0500538
539 /**
540 * @brief Extracts a CalloutPriority value from the json
541 * using the 'Priority' key.
542 *
543 * @param[in] json - A JSON object that contains the priority key
544 *
545 * @return CalloutPriority - The priority value
546 */
547 CalloutPriority getPriorityFromJSON(const nlohmann::json& json);
548
Matt Spinler5a90a952020-08-27 09:39:03 -0500549 /**
Matt Spinlerb8cb60f2020-08-27 10:55:55 -0500550 * @brief Exracts MRU values and their priorities from the
551 * input JSON array.
552 *
553 * @param[in] mruJSON - The JSON array
554 */
555 std::vector<src::MRU::MRUCallout>
556 getMRUsFromJSON(const nlohmann::json& mruJSON);
557
558 /**
Sumit Kumar9d43a722021-08-24 09:46:19 -0500559 * @brief Sets the dump status
560 *
561 * @param[in] dataIface - The DataInterface object
562 */
563 void setDumpStatus(const DataInterfaceBase& dataIface);
564
565 /**
Matt Spinlerf9bae182019-10-09 13:37:38 -0500566 * @brief The SRC version field
567 */
568 uint8_t _version;
569
570 /**
571 * @brief The SRC flags field
572 */
573 uint8_t _flags;
574
575 /**
576 * @brief A byte of reserved data after the flags field
577 */
578 uint8_t _reserved1B;
579
580 /**
581 * @brief The hex data word count.
582 *
583 * To be compatible with previous versions of SRCs, this is
584 * number of hex words (8) + 1 = 9.
585 */
586 uint8_t _wordCount;
587
588 /**
589 * @brief Two bytes of reserved data after the hex word count
590 */
591 uint16_t _reserved2B;
592
593 /**
594 * @brief The total size of the SRC section, not including the section
595 * header.
596 */
597 uint16_t _size;
598
599 /**
600 * @brief The SRC 'hex words'.
601 *
602 * In the spec these are referred to as SRC words 2 - 9 as words 0 and 1
603 * are filled by the 8 bytes of fields from above.
604 */
605 std::array<uint32_t, numSRCHexDataWords> _hexData;
606
607 /**
608 * @brief The 32 byte ASCII character string of the SRC
609 *
610 * It is padded with spaces to fill the 32 bytes.
611 * An example is:
612 * "BD8D1234 "
613 *
614 * That first word is what is commonly referred to as the refcode, and
615 * sometimes also called an SRC.
616 */
617 std::unique_ptr<src::AsciiString> _asciiString;
618
619 /**
620 * @brief The callouts subsection.
621 *
622 * Optional and only created if there are callouts.
623 */
624 std::unique_ptr<src::Callouts> _callouts;
625};
626
627} // namespace pels
628} // namespace openpower