1 #include <unistd.h>
2
3 #include <analyzer/analyzer_main.hpp>
4 #include <attn/attn_common.hpp>
5 #include <attn/attn_dbus.hpp>
6 #include <attn/attn_dump.hpp>
7 #include <attn/attn_logging.hpp>
8 #include <attn/pel/pel_minimal.hpp>
9 #include <phosphor-logging/log.hpp>
10 #include <util/dbus.hpp>
11 #include <util/ffdc.hpp>
12 #include <util/trace.hpp>
13
14 namespace attn
15 {
16 /** @brief Tuple containing information about ffdc files */
17 using FFDCTuple =
18 std::tuple<util::FFDCFormat, uint8_t, uint8_t, sdbusplus::message::unix_fd>;
19
20 /**
21 * Create FFDCTuple objects corresponding to the specified FFDC files.
22 *
23 * The D-Bus method to create an error log requires a vector of tuples to
24 * pass in the FFDC file information.
25 *
26 * @param files - FFDC files
27 * @return vector of FFDCTuple objects
28 */
29 std::vector<FFDCTuple>
createFFDCTuples(const std::vector<util::FFDCFile> & files)30 createFFDCTuples(const std::vector<util::FFDCFile>& files)
31 {
32 std::vector<FFDCTuple> ffdcTuples{};
33 util::transformFFDC(files, ffdcTuples);
34
35 return ffdcTuples;
36 }
37
38 /**
39 * @brief Create an FFDCFile object containing raw data
40 *
41 * Throws an exception if an error occurs.
42 *
43 * @param i_buffer - raw data to add to ffdc faw data file
44 * @param i_size - size of the raw data
45 * @return FFDCFile object
46 */
createFFDCRawFile(void * i_buffer,size_t i_size)47 util::FFDCFile createFFDCRawFile(void* i_buffer, size_t i_size)
48 {
49 util::FFDCFile file{util::FFDCFormat::Custom};
50
51 // Write buffer to file and then reset file description file offset
52 int fd = file.getFileDescriptor();
53 size_t numBytes = write(fd, static_cast<char*>(i_buffer), i_size);
54 if (i_size != numBytes)
55 {
56 trace::err("%s only %u of %u bytes written", file.getPath().c_str(),
57 numBytes, i_size);
58 }
59
60 lseek(fd, 0, SEEK_SET);
61
62 return file;
63 }
64
65 /**
66 * Create FFDCFile objects containing debug data to store in the error log.
67 *
68 * If an error occurs, the error is written to the journal but an exception
69 * is not thrown.
70 *
71 * @param i_buffer - raw data (if creating raw dump ffdc entry in log)
72 * @return vector of FFDCFile objects
73 */
createFFDCFiles(char * i_buffer=nullptr,size_t i_size=0)74 std::vector<util::FFDCFile> createFFDCFiles(char* i_buffer = nullptr,
75 size_t i_size = 0)
76 {
77 std::vector<util::FFDCFile> files{};
78
79 // Create raw dump file
80 if ((nullptr != i_buffer) && (0 != i_size))
81 {
82 files.emplace_back(createFFDCRawFile(i_buffer, i_size));
83 }
84
85 // Create trace dump file
86 util::createFFDCTraceFiles(files);
87
88 // Add PRD scratch registers
89 addPrdScratchRegs(files);
90
91 return files;
92 }
93
94 /**
95 * Create a PEL from an existing PEL
96 *
97 * Create a new PEL based on the specified raw PEL and submit the new PEL
98 * to the backend logging code as a raw PEL. Note that additional data map
99 * here contains data to be committed to the PEL and it can also be used to
100 * create the PEL as it contains needed information.
101 *
102 * @param i_rawPel - buffer containing a raw PEL
103 * @param i_additional - additional data to be added to the new PEL
104 */
createPelCustom(std::vector<uint8_t> & i_rawPel,std::map<std::string,std::string> i_additional)105 void createPelCustom(std::vector<uint8_t>& i_rawPel,
106 std::map<std::string, std::string> i_additional)
107 {
108 // create PEL object from buffer
109 auto tiPel = std::make_unique<pel::PelMinimal>(i_rawPel);
110
111 // The additional data contains the TI info as well as the value for the
112 // subystem that provided the TI info. Get the subystem from additional
113 // data and then populate the primary SRC and SRC words for the custom PEL
114 // based on the subsystem's TI info.
115 std::map<std::string, std::string>::iterator it;
116 uint8_t subsystem;
117
118 it = i_additional.find("Subsystem");
119 if (it != i_additional.end())
120 {
121 subsystem = std::stoi(it->second);
122 tiPel->setSubsystem(subsystem);
123 }
124 else
125 {
126 // The entry with key "Subsystem" does not exist in the additional map.
127 // Log the error, create failure event, and return.
128 trace::err("Error the key Subsystem does not exist in the map.");
129 eventAttentionFail((int)AttnSection::attnLogging | ATTN_INVALID_KEY);
130 return;
131 }
132
133 // If recoverable attentions are active we will call the analyzer and
134 // then link the custom pel to analyzer pel.
135 it = i_additional.find("recoverables");
136 if (it != i_additional.end() && "true" == it->second)
137 {
138 DumpParameters dumpParameters;
139 auto plid = analyzer::analyzeHardware(
140 analyzer::AnalysisType::TERMINATE_IMMEDIATE, dumpParameters);
141 if (0 != plid)
142 {
143 // Link the PLID if an attention was found and a PEL was generated.
144 tiPel->setPlid(plid);
145 }
146 }
147
148 if (static_cast<uint8_t>(pel::SubsystemID::hypervisor) == subsystem)
149 {
150 // populate hypervisor SRC words
151 tiPel->setSrcWords(std::array<uint32_t, pel::numSrcWords>{
152 (uint32_t)std::stoul(i_additional["0x10 SRC Word 12"], 0, 16),
153 (uint32_t)std::stoul(i_additional["0x14 SRC Word 13"], 0, 16),
154 (uint32_t)std::stoul(i_additional["0x18 SRC Word 14"], 0, 16),
155 (uint32_t)std::stoul(i_additional["0x1c SRC Word 15"], 0, 16),
156 (uint32_t)std::stoul(i_additional["0x20 SRC Word 16"], 0, 16),
157 (uint32_t)std::stoul(i_additional["0x24 SRC Word 17"], 0, 16),
158 (uint32_t)std::stoul(i_additional["0x28 SRC Word 18"], 0, 16),
159 (uint32_t)std::stoul(i_additional["0x2c SRC Word 19"], 0, 16)});
160
161 // Populate phyp primary SRC
162
163 // char array for raw pel src
164 std::array<char, pel::asciiStringSize> srcChars{'0'};
165 std::string srcString;
166
167 // src from TI info
168 it = i_additional.find("SrcAscii");
169 if (it != i_additional.end())
170 {
171 srcString = it->second;
172 }
173 else
174 {
175 // The entry with key "Subsystem" does not exist in the additional
176 // map. Log the error, create failure event, and return.
177 trace::err("Error the key SrcAscii does not exist in the map.");
178 eventAttentionFail((int)AttnSection::attnLogging |
179 ATTN_INVALID_KEY);
180 return;
181 }
182
183 // copy from string to char array
184 srcString.copy(srcChars.data(),
185 std::min(srcString.size(), pel::asciiStringSize), 0);
186
187 tiPel->setAsciiString(srcChars); // pel object src is char array
188
189 // set symptom-id
190 auto symptomId = (srcString.substr(0, 8) + '_');
191
192 symptomId += (i_additional["0x10 SRC Word 12"]);
193 symptomId += (i_additional["0x14 SRC Word 13"] + '_');
194 symptomId += (i_additional["0x18 SRC Word 14"]);
195 symptomId += (i_additional["0x1c SRC Word 15"] + '_');
196 symptomId += (i_additional["0x20 SRC Word 16"]);
197 symptomId += (i_additional["0x24 SRC Word 17"] + '_');
198 symptomId += (i_additional["0x28 SRC Word 18"]);
199 symptomId += (i_additional["0x2c SRC Word 19"]);
200
201 // setSymptomId will take care of required null-terminate and padding
202 tiPel->setSymptomId(symptomId);
203 }
204 else
205 {
206 // Populate hostboot SRC words - note HB word 0 from the shared info
207 // data (additional data "0x10 HB Word") is reflected in the PEL as
208 // "reason code" so we zero it here. Also note that the first word
209 // in this group of words starts at word 0 and word 1 does not exits.
210 tiPel->setSrcWords(std::array<uint32_t, pel::numSrcWords>{
211 (uint32_t)0x00000000,
212 (uint32_t)std::stoul(i_additional["0x14 HB Word 2"], 0, 16),
213 (uint32_t)std::stoul(i_additional["0x18 HB Word 3"], 0, 16),
214 (uint32_t)std::stoul(i_additional["0x1c HB Word 4"], 0, 16),
215 (uint32_t)std::stoul(i_additional["0x20 HB Word 5"], 0, 16),
216 (uint32_t)std::stoul(i_additional["0x24 HB Word 6"], 0, 16),
217 (uint32_t)std::stoul(i_additional["0x28 HB Word 7"], 0, 16),
218 (uint32_t)std::stoul(i_additional["0x2c HB Word 8"], 0, 16)});
219
220 // Populate hostboot primary SRC
221
222 // char array for raw pel src
223 std::array<char, pel::asciiStringSize> srcChars{'0'};
224 std::string srcString;
225
226 // src from TI info
227 it = i_additional.find("SrcAscii");
228 if (it != i_additional.end())
229 {
230 srcString = it->second;
231 }
232 else
233 {
234 // The entry with key "Subsystem" does not exist in the additional
235 // map. Log the error, create failure event, and return.
236 trace::err("Error the key SrcAscii does not exist in the map.");
237 eventAttentionFail((int)AttnSection::attnLogging |
238 ATTN_INVALID_KEY);
239 return;
240 }
241
242 // copy from string to char array
243 srcString.copy(srcChars.data(),
244 std::min(srcString.size(), pel::asciiStringSize), 0);
245
246 tiPel->setAsciiString(srcChars); // pel object src is char array
247
248 // set symptom-id
249 auto symptomId = (srcString.substr(0, 8) + '_');
250
251 symptomId += (i_additional["0x10 HB Word 0"]); // note: word 1
252 symptomId += (i_additional["0x14 HB Word 2"] + '_'); // does not exist
253 symptomId += (i_additional["0x18 HB Word 3"]);
254 symptomId += (i_additional["0x1c HB Word 4"] + '_');
255 symptomId += (i_additional["0x20 HB Word 5"]);
256 symptomId += (i_additional["0x24 HB Word 6"] + '_');
257 symptomId += (i_additional["0x28 HB Word 7"]);
258 symptomId += (i_additional["0x2c HB Word 8"]);
259
260 // setSymptomId will take care of required null-terminate and padding
261 tiPel->setSymptomId(symptomId);
262 }
263
264 // set severity, event type and action flags
265 tiPel->setSeverity(static_cast<uint8_t>(pel::Severity::termination));
266 tiPel->setType(static_cast<uint8_t>(pel::EventType::na));
267
268 auto actionFlags = pel::ActionFlags::service | pel::ActionFlags::report |
269 pel::ActionFlags::call;
270
271 it = i_additional.find("hidden");
272 if (it != i_additional.end() && "true" == it->second)
273 {
274 trace::inf("making HB TI PEL hidden");
275 actionFlags = actionFlags | pel::ActionFlags::hidden;
276 }
277
278 tiPel->setAction(static_cast<uint16_t>(actionFlags));
279
280 // The raw PEL that we used as the basis for this custom PEL contains some
281 // user data sections that do not need to be in this PEL. However we do
282 // want to include the raw TI information.
283 int ffdcCount = 0;
284 it = i_additional.find("FFDC count");
285 if (it != i_additional.end())
286 {
287 // remove all sections except 1 (raw Ti info)
288 ffdcCount = std::stoi(it->second) - 1;
289 }
290 tiPel->setSectionCount(tiPel->getSectionCount() - ffdcCount);
291
292 // Update the raw PEL with the new custom PEL data
293 tiPel->raw(i_rawPel);
294
295 // create PEL from raw data
296 createPelRaw(i_rawPel);
297 }
298
299 /**
300 * Log an event handled by the attention handler
301 *
302 * Basic (non TI) events will generate a standard message-registry based PEL
303 *
304 * TI events will create two PEL's. One PEL will be informational and will
305 * contain trace information relevent to attention handler. The second PEL
306 * will be specific to the TI type (including the primary SRC) and will be
307 * based off of the TI information provided to the attention handler through
308 * shared TI info data area.
309 *
310 * @param i_event - The event type
311 * @param i_additional - Additional PEL data
312 * @param i_ffdc - FFDC PEL data
313 * @param i_severity - Severity level
314 * @return Event log Id (0 if no event log generated)
315 */
event(EventType i_event,std::map<std::string,std::string> & i_additional,const std::vector<util::FFDCFile> & i_ffdc,std::string i_severity=levelPelError)316 uint32_t event(EventType i_event,
317 std::map<std::string, std::string>& i_additional,
318 const std::vector<util::FFDCFile>& i_ffdc,
319 std::string i_severity = levelPelError)
320 {
321 uint32_t pelId = 0; // assume no event log generated
322
323 bool eventValid = false; // assume no event created
324 bool tiEvent = false; // assume not a terminate event
325
326 // count user data sections so we can fixup custom PEL
327 i_additional["FFDC count"] = std::to_string(i_ffdc.size());
328
329 std::string eventName;
330
331 switch (i_event)
332 {
333 case EventType::Checkstop:
334 eventName = "org.open_power.HwDiags.Error.Checkstop";
335 eventValid = true;
336 break;
337 case EventType::Terminate:
338 eventName = "org.open_power.Attn.Error.Terminate";
339 eventValid = true;
340 tiEvent = true;
341 break;
342 case EventType::Vital:
343 eventName = "org.open_power.Attn.Error.Vital";
344 eventValid = true;
345 break;
346 case EventType::HwDiagsFail:
347 case EventType::AttentionFail:
348 eventName = "org.open_power.Attn.Error.Fail";
349 eventValid = true;
350 break;
351 default:
352 eventValid = false;
353 break;
354 }
355
356 if (true == eventValid)
357 {
358 // Create PEL with additional data and FFDC data. The newly created
359 // PEL's platform log-id will be returned.
360 pelId = util::dbus::createPel(eventName, i_severity, i_additional,
361 createFFDCTuples(i_ffdc));
362
363 // If this is a TI event we will create an additional PEL that is
364 // specific to the subsystem that generated the TI.
365 if ((0 != pelId) && (true == tiEvent))
366 {
367 // get file descriptor and size of information PEL
368 int pelFd = getPel(pelId);
369
370 // if PEL found, read into buffer
371 if (-1 != pelFd)
372 {
373 auto pelSize = lseek(pelFd, 0, SEEK_END);
374 lseek(pelFd, 0, SEEK_SET);
375
376 // read information PEL into buffer
377 std::vector<uint8_t> buffer(pelSize);
378 size_t numBytes = read(pelFd, buffer.data(), buffer.size());
379 if (buffer.size() != numBytes)
380 {
381 trace::err("Error reading event log: %u of %u bytes read",
382 numBytes, buffer.size());
383 }
384 else
385 {
386 // create PEL from buffer
387 createPelCustom(buffer, i_additional);
388 }
389
390 close(pelFd);
391 }
392
393 std::map<std::string, std::string>::iterator it;
394 uint8_t subsystem;
395
396 it = i_additional.find("Subsystem");
397 if (it != i_additional.end())
398 {
399 subsystem = std::stoi(it->second);
400 }
401 else
402 {
403 // The entry with key "Subsystem" does not exist in the
404 // additional map. Log the error, create failure event, and
405 // return.
406 trace::err(
407 "Error the key Subsystem does not exist in the map.");
408 eventAttentionFail((int)AttnSection::attnLogging |
409 ATTN_INVALID_KEY);
410 return 0;
411 }
412
413 // If not hypervisor TI
414 if (static_cast<uint8_t>(pel::SubsystemID::hypervisor) != subsystem)
415 {
416 // Request a dump and transition the host
417 if ("true" == i_additional["Dump"])
418 {
419 // will not return until dump is complete
420 requestDump(pelId, DumpParameters{0, DumpType::Hostboot});
421 }
422 }
423 }
424 }
425 return pelId;
426 }
427
428 /**
429 * Commit special attention TI event to log
430 *
431 * Create a event log with provided additional information and standard
432 * FFDC data plus TI FFDC data
433 *
434 * @param i_additional - Additional log data
435 * @param i_ti_InfoData - TI FFDC data
436 */
eventTerminate(std::map<std::string,std::string> i_additionalData,char * i_tiInfoData)437 void eventTerminate(std::map<std::string, std::string> i_additionalData,
438 char* i_tiInfoData)
439 {
440 uint32_t tiInfoSize = 0; // assume TI info was not available
441
442 if (nullptr != i_tiInfoData)
443 {
444 tiInfoSize = 56; // assume not hypervisor TI
445
446 std::map<std::string, std::string>::iterator it;
447 uint8_t subsystem;
448
449 it = i_additionalData.find("Subsystem");
450 if (it != i_additionalData.end())
451 {
452 subsystem = std::stoi(it->second);
453 }
454 else
455 {
456 // The entry with key "Subsystem" does not exist in the additional
457 // map. Log the error, create failure event, and return.
458 trace::err("Error the key Subsystem does not exist in the map.");
459 eventAttentionFail((int)AttnSection::attnLogging |
460 ATTN_INVALID_KEY);
461 return;
462 }
463
464 // If hypervisor
465 if (static_cast<uint8_t>(pel::SubsystemID::hypervisor) == subsystem)
466 {
467 tiInfoSize = 1024; // assume hypervisor max
468
469 // hypervisor may just want some of the data
470 if (0 == (*(i_tiInfoData + 0x09) & 0x01))
471 {
472 uint32_t* additionalLength = (uint32_t*)(i_tiInfoData + 0x50);
473 uint32_t tiAdditional = be32toh(*additionalLength);
474 tiInfoSize = std::min(tiInfoSize, (84 + tiAdditional));
475 }
476 }
477 }
478
479 trace::inf("TI info size = %u", tiInfoSize);
480
481 event(EventType::Terminate, i_additionalData,
482 createFFDCFiles(i_tiInfoData, tiInfoSize));
483 }
484
485 /** @brief Commit SBE vital event to log, returns event log ID */
eventVital(std::string severity)486 uint32_t eventVital(std::string severity)
487 {
488 // Additional data for log
489 std::map<std::string, std::string> additionalData;
490
491 // Create log event with additional data and FFDC data
492 return event(EventType::Vital, additionalData, createFFDCFiles(nullptr, 0),
493 severity);
494 }
495
496 /**
497 * Commit attention handler failure event to log
498 *
499 * Create an event log containing the specified error code.
500 *
501 * @param i_error - Error code
502 */
eventAttentionFail(int i_error)503 void eventAttentionFail(int i_error)
504 {
505 // Additional data for log
506 std::map<std::string, std::string> additionalData;
507 additionalData["ERROR_CODE"] = std::to_string(i_error);
508
509 // Create log event with additional data and FFDC data
510 event(EventType::AttentionFail, additionalData,
511 createFFDCFiles(nullptr, 0));
512 }
513
514 } // namespace attn
515