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 "manager.hpp"
17
18 #include "additional_data.hpp"
19 #include "elog_serialize.hpp"
20 #include "json_utils.hpp"
21 #include "pel.hpp"
22 #include "pel_entry.hpp"
23 #include "service_indicators.hpp"
24 #include "severity.hpp"
25
26 #include <sys/inotify.h>
27 #include <unistd.h>
28
29 #include <phosphor-logging/lg2.hpp>
30 #include <xyz/openbmc_project/Common/error.hpp>
31 #include <xyz/openbmc_project/Logging/Create/server.hpp>
32
33 #include <filesystem>
34 #include <format>
35 #include <fstream>
36 #include <locale>
37
38 namespace openpower
39 {
40 namespace pels
41 {
42
43 using namespace phosphor::logging;
44 namespace fs = std::filesystem;
45 namespace rg = openpower::pels::message;
46
47 namespace common_error = sdbusplus::xyz::openbmc_project::Common::Error;
48
49 using Create = sdbusplus::server::xyz::openbmc_project::logging::Create;
50
51 namespace additional_data
52 {
53 constexpr auto rawPEL = "RAWPEL";
54 constexpr auto esel = "ESEL";
55 constexpr auto error = "ERROR_NAME";
56 } // namespace additional_data
57
58 constexpr auto defaultLogMessage = "xyz.openbmc_project.Logging.Error.Default";
59 constexpr uint32_t bmcThermalCompID = 0x2700;
60 constexpr uint32_t bmcFansCompID = 0x2800;
61
~Manager()62 Manager::~Manager()
63 {
64 if (_pelFileDeleteFD != -1)
65 {
66 if (_pelFileDeleteWatchFD != -1)
67 {
68 inotify_rm_watch(_pelFileDeleteFD, _pelFileDeleteWatchFD);
69 }
70 close(_pelFileDeleteFD);
71 }
72 }
73
create(const std::string & message,uint32_t obmcLogID,uint64_t timestamp,Entry::Level severity,const std::vector<std::string> & additionalData,const std::vector<std::string> & associations,const FFDCEntries & ffdc)74 void Manager::create(const std::string& message, uint32_t obmcLogID,
75 uint64_t timestamp, Entry::Level severity,
76 const std::vector<std::string>& additionalData,
77 const std::vector<std::string>& associations,
78 const FFDCEntries& ffdc)
79 {
80 AdditionalData ad{additionalData};
81
82 // If a PEL was passed in via a filename or in an ESEL,
83 // use that. Otherwise, create one.
84 auto rawPelPath = ad.getValue(additional_data::rawPEL);
85 if (rawPelPath)
86 {
87 addRawPEL(*rawPelPath, obmcLogID);
88 }
89 else
90 {
91 auto esel = ad.getValue(additional_data::esel);
92 if (esel)
93 {
94 addESELPEL(*esel, obmcLogID);
95 }
96 else
97 {
98 createPEL(message, obmcLogID, timestamp, severity, additionalData,
99 associations, ffdc);
100 }
101 }
102
103 setEntryPath(obmcLogID);
104 setServiceProviderNotifyFlag(obmcLogID);
105 }
106
addRawPEL(const std::string & rawPelPath,uint32_t obmcLogID)107 void Manager::addRawPEL(const std::string& rawPelPath, uint32_t obmcLogID)
108 {
109 if (fs::exists(rawPelPath))
110 {
111 std::ifstream file(rawPelPath, std::ios::in | std::ios::binary);
112
113 auto data = std::vector<uint8_t>(std::istreambuf_iterator<char>(file),
114 std::istreambuf_iterator<char>());
115 if (file.fail())
116 {
117 lg2::error(
118 "Filesystem error reading a raw PEL. File = {FILE}, obmcLogID = {LOGID}",
119 "FILE", rawPelPath, "LOGID", obmcLogID);
120 // TODO, Decide what to do here. Maybe nothing.
121 return;
122 }
123
124 file.close();
125
126 addPEL(data, obmcLogID);
127
128 std::error_code ec;
129 fs::remove(rawPelPath, ec);
130 }
131 else
132 {
133 lg2::error(
134 "Raw PEL file from BMC event log does not exit. File = {FILE}, obmcLogID = {LOGID}",
135 "FILE", rawPelPath, "LOGID", obmcLogID);
136 }
137 }
138
addPEL(std::vector<uint8_t> & pelData,uint32_t obmcLogID)139 void Manager::addPEL(std::vector<uint8_t>& pelData, uint32_t obmcLogID)
140 {
141 auto pel = std::make_unique<openpower::pels::PEL>(pelData, obmcLogID);
142 if (pel->valid())
143 {
144 // PELs created by others still need this field set by us.
145 pel->setCommitTime();
146
147 // Assign Id other than to Hostbot PEL
148 if ((pel->privateHeader()).creatorID() !=
149 static_cast<uint8_t>(CreatorID::hostboot))
150 {
151 pel->assignID();
152 }
153 else
154 {
155 const Repository::LogID id{Repository::LogID::Pel(pel->id())};
156 auto result = _repo.hasPEL(id);
157 if (result)
158 {
159 lg2::warning(
160 "Duplicate HostBoot PEL ID {ID} found, moving it to archive folder",
161 "ID", lg2::hex, pel->id());
162
163 _repo.archivePEL(*pel);
164
165 // No need to keep around the openBMC event log entry
166 scheduleObmcLogDelete(obmcLogID);
167 return;
168 }
169 }
170
171 // Update System Info to Extended User Data
172 pel->updateSysInfoInExtendedUserDataSection(*_dataIface);
173
174 // Check for severity 0x51 and update boot progress SRC
175 updateProgressSRC(pel);
176
177 try
178 {
179 lg2::debug("Adding external PEL {ID} (BMC ID {BMCID}) to repo",
180 "ID", lg2::hex, pel->id(), "BMCID", obmcLogID);
181 _repo.add(pel);
182
183 if (_repo.sizeWarning())
184 {
185 scheduleRepoPrune();
186 }
187
188 // Activate any resulting service indicators if necessary
189 auto policy = service_indicators::getPolicy(*_dataIface);
190 policy->activate(*pel);
191 }
192 catch (const std::exception& e)
193 {
194 // Probably a full or r/o filesystem, not much we can do.
195 lg2::error("Unable to add PEL {ID} to Repository", "ID", lg2::hex,
196 pel->id());
197 }
198
199 updateEventId(pel);
200 updateResolution(*pel);
201 serializeLogEntry(obmcLogID);
202 createPELEntry(obmcLogID);
203
204 // Check if firmware should quiesce system due to error
205 checkPelAndQuiesce(pel);
206 }
207 else
208 {
209 lg2::error("Invalid PEL received from the host. BMC ID = {ID}", "ID",
210 obmcLogID);
211
212 AdditionalData ad;
213 ad.add("PLID", getNumberString("0x%08X", pel->plid()));
214 ad.add("OBMC_LOG_ID", std::to_string(obmcLogID));
215 ad.add("PEL_SIZE", std::to_string(pelData.size()));
216
217 std::string asciiString;
218 auto src = pel->primarySRC();
219 if (src)
220 {
221 asciiString = (*src)->asciiString();
222 }
223
224 ad.add("SRC", asciiString);
225
226 _eventLogger.log("org.open_power.Logging.Error.BadHostPEL",
227 Entry::Level::Error, ad);
228
229 // Save it to a file for debug in the lab. Just keep the latest.
230 // Not adding it to the PEL because it could already be max size
231 // and don't want to truncate an already invalid PEL.
232 std::ofstream pelFile{getPELRepoPath() / "badPEL"};
233 pelFile.write(reinterpret_cast<const char*>(pelData.data()),
234 pelData.size());
235
236 // No need to keep around the openBMC event log entry
237 scheduleObmcLogDelete(obmcLogID);
238 }
239 }
240
addESELPEL(const std::string & esel,uint32_t obmcLogID)241 void Manager::addESELPEL(const std::string& esel, uint32_t obmcLogID)
242 {
243 std::vector<uint8_t> data;
244
245 lg2::debug("Adding PEL from ESEL. BMC ID = {ID}", "ID", obmcLogID);
246
247 try
248 {
249 data = std::move(eselToRawData(esel));
250 }
251 catch (const std::exception& e)
252 {
253 // Try to add it below anyway, so it follows the usual bad data path.
254 lg2::error("Problems converting ESEL string to a byte vector");
255 }
256
257 addPEL(data, obmcLogID);
258 }
259
eselToRawData(const std::string & esel)260 std::vector<uint8_t> Manager::eselToRawData(const std::string& esel)
261 {
262 std::vector<uint8_t> data;
263 std::string byteString;
264
265 // As the eSEL string looks like: "50 48 00 ab ..." there are 3
266 // characters per raw byte, and since the actual PEL data starts
267 // at the 16th byte, the code will grab the PEL data starting at
268 // offset 48 in the string.
269 static constexpr size_t pelStart = 16 * 3;
270
271 if (esel.size() <= pelStart)
272 {
273 lg2::error("ESEL data too short, length = {LEN}", "LEN", esel.size());
274 throw std::length_error("ESEL data too short");
275 }
276
277 for (size_t i = pelStart; i < esel.size(); i += 3)
278 {
279 if (i + 1 < esel.size())
280 {
281 byteString = esel.substr(i, 2);
282 data.push_back(std::stoi(byteString, nullptr, 16));
283 }
284 else
285 {
286 lg2::error("ESEL data too short, length = {LEN}", "LEN",
287 esel.size());
288 throw std::length_error("ESEL data too short");
289 }
290 }
291
292 return data;
293 }
294
erase(uint32_t obmcLogID)295 void Manager::erase(uint32_t obmcLogID)
296 {
297 Repository::LogID id{Repository::LogID::Obmc(obmcLogID)};
298
299 auto path = std::string(OBJ_ENTRY) + '/' + std::to_string(obmcLogID);
300 _pelEntries.erase(path);
301 _repo.remove(id);
302 }
303
isDeleteProhibited(uint32_t)304 bool Manager::isDeleteProhibited(uint32_t /*obmcLogID*/)
305 {
306 return false;
307 }
308
convertToPelFFDC(const FFDCEntries & ffdc)309 PelFFDC Manager::convertToPelFFDC(const FFDCEntries& ffdc)
310 {
311 PelFFDC pelFFDC;
312
313 std::for_each(ffdc.begin(), ffdc.end(), [&pelFFDC](const auto& f) {
314 PelFFDCfile pf;
315 pf.subType = std::get<ffdcSubtypePos>(f);
316 pf.version = std::get<ffdcVersionPos>(f);
317 pf.fd = std::get<ffdcFDPos>(f);
318
319 switch (std::get<ffdcFormatPos>(f))
320 {
321 case Create::FFDCFormat::JSON:
322 pf.format = UserDataFormat::json;
323 break;
324 case Create::FFDCFormat::CBOR:
325 pf.format = UserDataFormat::cbor;
326 break;
327 case Create::FFDCFormat::Text:
328 pf.format = UserDataFormat::text;
329 break;
330 case Create::FFDCFormat::Custom:
331 pf.format = UserDataFormat::custom;
332 break;
333 }
334
335 pelFFDC.push_back(pf);
336 });
337
338 return pelFFDC;
339 }
340
createPEL(const std::string & message,uint32_t obmcLogID,uint64_t timestamp,phosphor::logging::Entry::Level severity,const std::vector<std::string> & additionalData,const std::vector<std::string> &,const FFDCEntries & ffdc)341 void Manager::createPEL(const std::string& message, uint32_t obmcLogID,
342 uint64_t timestamp,
343 phosphor::logging::Entry::Level severity,
344 const std::vector<std::string>& additionalData,
345 const std::vector<std::string>& /*associations*/,
346 const FFDCEntries& ffdc)
347 {
348 auto entry = _registry.lookup(message, rg::LookupType::name);
349 auto pelFFDC = convertToPelFFDC(ffdc);
350 AdditionalData ad{additionalData};
351 std::string msg;
352
353 if (!entry)
354 {
355 // Instead, get the default entry that means there is no
356 // other matching entry. This error will still use the
357 // AdditionalData values of the original error, and this
358 // code will add the error message value that wasn't found
359 // to this AD. This way, there will at least be a PEL,
360 // possibly with callouts, to allow users to debug the
361 // issue that caused the error even without its own PEL.
362 lg2::error("Event not found in PEL message registry: {MSG}", "MSG",
363 message);
364
365 entry = _registry.lookup(defaultLogMessage, rg::LookupType::name);
366 if (!entry)
367 {
368 lg2::error("Default event not found in PEL message registry");
369 return;
370 }
371
372 ad.add(additional_data::error, message);
373 }
374
375 auto pel = std::make_unique<openpower::pels::PEL>(
376 *entry, obmcLogID, timestamp, severity, ad, pelFFDC, *_dataIface,
377 *_journal);
378
379 _repo.add(pel);
380
381 if (_repo.sizeWarning())
382 {
383 scheduleRepoPrune();
384 }
385
386 auto src = pel->primarySRC();
387 if (src)
388 {
389 auto asciiString = (*src)->asciiString();
390 while (asciiString.back() == ' ')
391 {
392 asciiString.pop_back();
393 }
394 lg2::info("Created PEL {ID} (BMC ID {BMCID}) with SRC {SRC}", "ID",
395 lg2::hex, pel->id(), "BMCID", pel->obmcLogID(), "SRC",
396 asciiString);
397 }
398
399 // Check for severity 0x51 and update boot progress SRC
400 updateProgressSRC(pel);
401
402 // Activate any resulting service indicators if necessary
403 auto policy = service_indicators::getPolicy(*_dataIface);
404 policy->activate(*pel);
405
406 updateDBusSeverity(*pel);
407 updateEventId(pel);
408 updateResolution(*pel);
409 serializeLogEntry(obmcLogID);
410 createPELEntry(obmcLogID);
411
412 // Check if firmware should quiesce system due to error
413 checkPelAndQuiesce(pel);
414 }
415
getPEL(uint32_t pelID)416 sdbusplus::message::unix_fd Manager::getPEL(uint32_t pelID)
417 {
418 Repository::LogID id{Repository::LogID::Pel(pelID)};
419 std::optional<int> fd;
420
421 lg2::debug("getPEL {ID}", "ID", lg2::hex, pelID);
422
423 try
424 {
425 fd = _repo.getPELFD(id);
426 }
427 catch (const std::exception& e)
428 {
429 throw common_error::InternalFailure();
430 }
431
432 if (!fd)
433 {
434 throw common_error::InvalidArgument();
435 }
436
437 scheduleFDClose(*fd);
438
439 return *fd;
440 }
441
scheduleFDClose(int fd)442 void Manager::scheduleFDClose(int fd)
443 {
444 _fdCloserEventSource = std::make_unique<sdeventplus::source::Defer>(
445 _event, std::bind(std::mem_fn(&Manager::closeFD), this, fd,
446 std::placeholders::_1));
447 }
448
closeFD(int fd,sdeventplus::source::EventBase &)449 void Manager::closeFD(int fd, sdeventplus::source::EventBase& /*source*/)
450 {
451 close(fd);
452 _fdCloserEventSource.reset();
453 }
454
getPELFromOBMCID(uint32_t obmcLogID)455 std::vector<uint8_t> Manager::getPELFromOBMCID(uint32_t obmcLogID)
456 {
457 Repository::LogID id{Repository::LogID::Obmc(obmcLogID)};
458 std::optional<std::vector<uint8_t>> data;
459
460 lg2::debug("getPELFromOBMCID {BMCID}", "BMCID", obmcLogID);
461
462 try
463 {
464 data = _repo.getPELData(id);
465 }
466 catch (const std::exception& e)
467 {
468 throw common_error::InternalFailure();
469 }
470
471 if (!data)
472 {
473 throw common_error::InvalidArgument();
474 }
475
476 return *data;
477 }
478
hostAck(uint32_t pelID)479 void Manager::hostAck(uint32_t pelID)
480 {
481 Repository::LogID id{Repository::LogID::Pel(pelID)};
482
483 lg2::debug("HostHack {ID}", "ID", lg2::hex, pelID);
484
485 if (!_repo.hasPEL(id))
486 {
487 throw common_error::InvalidArgument();
488 }
489
490 if (_hostNotifier)
491 {
492 _hostNotifier->ackPEL(pelID);
493 }
494 }
495
hostReject(uint32_t pelID,RejectionReason reason)496 void Manager::hostReject(uint32_t pelID, RejectionReason reason)
497 {
498 Repository::LogID id{Repository::LogID::Pel(pelID)};
499
500 lg2::debug("HostReject {ID}, reason = {REASON}", "ID", lg2::hex, pelID,
501 "REASON", reason);
502
503 if (!_repo.hasPEL(id))
504 {
505 throw common_error::InvalidArgument();
506 }
507
508 if (reason == RejectionReason::BadPEL)
509 {
510 AdditionalData data;
511 data.add("BAD_ID", getNumberString("0x%08X", pelID));
512 _eventLogger.log("org.open_power.Logging.Error.SentBadPELToHost",
513 Entry::Level::Informational, data);
514 if (_hostNotifier)
515 {
516 _hostNotifier->setBadPEL(pelID);
517 }
518 }
519 else if ((reason == RejectionReason::HostFull) && _hostNotifier)
520 {
521 _hostNotifier->setHostFull(pelID);
522 }
523 }
524
scheduleRepoPrune()525 void Manager::scheduleRepoPrune()
526 {
527 _repoPrunerEventSource = std::make_unique<sdeventplus::source::Defer>(
528 _event, std::bind(std::mem_fn(&Manager::pruneRepo), this,
529 std::placeholders::_1));
530 }
531
pruneRepo(sdeventplus::source::EventBase &)532 void Manager::pruneRepo(sdeventplus::source::EventBase& /*source*/)
533 {
534 auto idsWithHwIsoEntry = _dataIface->getLogIDWithHwIsolation();
535
536 auto idsToDelete = _repo.prune(idsWithHwIsoEntry);
537
538 // Remove the OpenBMC event logs for the PELs that were just removed.
539 std::for_each(idsToDelete.begin(), idsToDelete.end(),
540 [this](auto id) { this->_logManager.erase(id); });
541
542 _repoPrunerEventSource.reset();
543 }
544
setupPELDeleteWatch()545 void Manager::setupPELDeleteWatch()
546 {
547 _pelFileDeleteFD = inotify_init1(IN_NONBLOCK);
548 if (-1 == _pelFileDeleteFD)
549 {
550 auto e = errno;
551 lg2::error("inotify_init1 failed with errno {ERRNO}", "ERRNO", e);
552 abort();
553 }
554
555 _pelFileDeleteWatchFD = inotify_add_watch(
556 _pelFileDeleteFD, _repo.repoPath().c_str(), IN_DELETE);
557 if (-1 == _pelFileDeleteWatchFD)
558 {
559 auto e = errno;
560 lg2::error("inotify_add_watch failed with errno {ERRNO}", "ERRNO", e);
561 abort();
562 }
563
564 _pelFileDeleteEventSource = std::make_unique<sdeventplus::source::IO>(
565 _event, _pelFileDeleteFD, EPOLLIN,
566 std::bind(std::mem_fn(&Manager::pelFileDeleted), this,
567 std::placeholders::_1, std::placeholders::_2,
568 std::placeholders::_3));
569 }
570
pelFileDeleted(sdeventplus::source::IO &,int,uint32_t revents)571 void Manager::pelFileDeleted(sdeventplus::source::IO& /*io*/, int /*fd*/,
572 uint32_t revents)
573 {
574 if (!(revents & EPOLLIN))
575 {
576 return;
577 }
578
579 // An event for 1 PEL uses 48B. When all PELs are deleted at once,
580 // as many events as there is room for can be handled in one callback.
581 // A size of 2000 will allow 41 to be processed, with additional
582 // callbacks being needed to process the remaining ones.
583 std::array<uint8_t, 2000> data{};
584 auto bytesRead = read(_pelFileDeleteFD, data.data(), data.size());
585 if (bytesRead < 0)
586 {
587 auto e = errno;
588 lg2::error("Failed reading data from inotify event, errno = {ERRNO}",
589 "ERRNO", e);
590 abort();
591 }
592
593 auto offset = 0;
594 while (offset < bytesRead)
595 {
596 auto event = reinterpret_cast<inotify_event*>(&data[offset]);
597 if (event->mask & IN_DELETE)
598 {
599 std::string filename{event->name};
600
601 // Get the PEL ID from the filename and tell the
602 // repo it's been removed, and then delete the BMC
603 // event log if it's there.
604 auto pos = filename.find_first_of('_');
605 if (pos != std::string::npos)
606 {
607 try
608 {
609 auto idString = filename.substr(pos + 1);
610 auto pelID = std::stoul(idString, nullptr, 16);
611
612 Repository::LogID id{Repository::LogID::Pel(pelID)};
613 auto removedLogID = _repo.remove(id);
614 if (removedLogID)
615 {
616 _logManager.erase(removedLogID->obmcID.id);
617 }
618 }
619 catch (const std::exception& e)
620 {
621 lg2::info("Could not find PEL ID from its filename {NAME}",
622 "NAME", filename);
623 }
624 }
625 }
626
627 offset += offsetof(inotify_event, name) + event->len;
628 }
629 }
630
createPELWithFFDCFiles(std::string message,Entry::Level severity,std::map<std::string,std::string> additionalData,std::vector<std::tuple<sdbusplus::server::xyz::openbmc_project::logging::Create::FFDCFormat,uint8_t,uint8_t,sdbusplus::message::unix_fd>> fFDC)631 std::tuple<uint32_t, uint32_t> Manager::createPELWithFFDCFiles(
632 std::string message, Entry::Level severity,
633 std::map<std::string, std::string> additionalData,
634 std::vector<std::tuple<
635 sdbusplus::server::xyz::openbmc_project::logging::Create::FFDCFormat,
636 uint8_t, uint8_t, sdbusplus::message::unix_fd>>
637 fFDC)
638 {
639 _logManager.create(message, severity, additionalData, fFDC);
640
641 return {_logManager.lastEntryID(), _repo.lastPelID()};
642 }
643
getPELJSON(uint32_t obmcLogID)644 std::string Manager::getPELJSON(uint32_t obmcLogID)
645 {
646 // Throws InvalidArgument if not found
647 auto pelID = getPELIdFromBMCLogId(obmcLogID);
648
649 auto cmd = std::format("/usr/bin/peltool -i {:#x}", pelID);
650
651 FILE* pipe = popen(cmd.c_str(), "r");
652 if (!pipe)
653 {
654 lg2::error("Error running cmd: {CMD}", "CMD", cmd);
655 throw common_error::InternalFailure();
656 }
657
658 std::string output;
659 std::array<char, 1024> buffer;
660 while (fgets(buffer.data(), buffer.size(), pipe) != nullptr)
661 {
662 output.append(buffer.data());
663 }
664
665 int rc = pclose(pipe);
666 if (WEXITSTATUS(rc) != 0)
667 {
668 lg2::error("Error running cmd: {CMD}, rc = {RC}", "CMD", cmd, "RC", rc);
669 throw common_error::InternalFailure();
670 }
671
672 return output;
673 }
674
checkPelAndQuiesce(std::unique_ptr<openpower::pels::PEL> & pel)675 void Manager::checkPelAndQuiesce(std::unique_ptr<openpower::pels::PEL>& pel)
676 {
677 if ((pel->userHeader().severity() ==
678 static_cast<uint8_t>(SeverityType::nonError)) ||
679 (pel->userHeader().severity() ==
680 static_cast<uint8_t>(SeverityType::recovered)))
681 {
682 lg2::debug(
683 "PEL severity informational or recovered. no quiesce needed");
684 return;
685 }
686 if (!_logManager.isQuiesceOnErrorEnabled())
687 {
688 lg2::debug("QuiesceOnHwError not enabled, no quiesce needed");
689 return;
690 }
691
692 CreatorID creatorID{pel->privateHeader().creatorID()};
693
694 if ((creatorID != CreatorID::openBMC) &&
695 (creatorID != CreatorID::hostboot) &&
696 (creatorID != CreatorID::ioDrawer) && (creatorID != CreatorID::occ) &&
697 (creatorID != CreatorID::phyp))
698 {
699 return;
700 }
701
702 // Now check if it has any type of callout
703 if (pel->isHwCalloutPresent())
704 {
705 lg2::info(
706 "QuiesceOnHwError enabled, PEL severity not nonError or recovered, "
707 "and callout is present");
708
709 _logManager.quiesceOnError(pel->obmcLogID());
710 }
711 }
712
getEventId(const openpower::pels::PEL & pel) const713 std::string Manager::getEventId(const openpower::pels::PEL& pel) const
714 {
715 std::string str;
716 auto src = pel.primarySRC();
717 if (src)
718 {
719 const auto& hexwords = (*src)->hexwordData();
720
721 std::string refcode = (*src)->asciiString();
722 size_t pos = refcode.find_last_not_of(0x20);
723 if (pos != std::string::npos)
724 {
725 refcode.erase(pos + 1);
726 }
727 str = refcode;
728
729 for (auto& value : hexwords)
730 {
731 str += " ";
732 str += getNumberString("%08X", value);
733 }
734 }
735 return sanitizeFieldForDBus(str);
736 }
737
updateEventId(std::unique_ptr<openpower::pels::PEL> & pel)738 void Manager::updateEventId(std::unique_ptr<openpower::pels::PEL>& pel)
739 {
740 std::string eventIdStr = getEventId(*pel);
741
742 auto entryN = _logManager.entries.find(pel->obmcLogID());
743 if (entryN != _logManager.entries.end())
744 {
745 entryN->second->eventId(eventIdStr, true);
746 }
747 }
748
sanitizeFieldForDBus(std::string field)749 std::string Manager::sanitizeFieldForDBus(std::string field)
750 {
751 std::for_each(field.begin(), field.end(), [](char& ch) {
752 if (((ch < ' ') || (ch > '~')) && (ch != '\n') && (ch != '\t'))
753 {
754 ch = ' ';
755 }
756 });
757 return field;
758 }
759
getResolution(const openpower::pels::PEL & pel) const760 std::string Manager::getResolution(const openpower::pels::PEL& pel) const
761 {
762 std::string str;
763 std::string resolution;
764 auto src = pel.primarySRC();
765 if (src)
766 {
767 // First extract the callout pointer and then go through
768 const auto& callouts = (*src)->callouts();
769 namespace pv = openpower::pels::pel_values;
770 // All PELs dont have callout, check before parsing callout data
771 if (callouts)
772 {
773 const auto& entries = callouts->callouts();
774 // Entry starts with index 1
775 uint8_t index = 1;
776 for (auto& entry : entries)
777 {
778 resolution += std::to_string(index) + ". ";
779 // Adding Location code to resolution
780 if (!entry->locationCode().empty())
781 resolution += "Location Code: " + entry->locationCode() +
782 ", ";
783 if (entry->fruIdentity())
784 {
785 // Get priority and set the resolution string
786 str = pv::getValue(entry->priority(),
787 pel_values::calloutPriorityValues,
788 pel_values::registryNamePos);
789 str[0] = toupper(str[0]);
790 resolution += "Priority: " + str + ", ";
791 if (entry->fruIdentity()->getPN().has_value())
792 {
793 resolution +=
794 "PN: " + entry->fruIdentity()->getPN().value() +
795 ", ";
796 }
797 if (entry->fruIdentity()->getSN().has_value())
798 {
799 resolution +=
800 "SN: " + entry->fruIdentity()->getSN().value() +
801 ", ";
802 }
803 if (entry->fruIdentity()->getCCIN().has_value())
804 {
805 resolution +=
806 "CCIN: " + entry->fruIdentity()->getCCIN().value() +
807 ", ";
808 }
809 // Add the maintenance procedure
810 if (entry->fruIdentity()->getMaintProc().has_value())
811 {
812 resolution +=
813 "Procedure: " +
814 entry->fruIdentity()->getMaintProc().value() + ", ";
815 }
816 }
817 resolution.resize(resolution.size() - 2);
818 resolution += "\n";
819 index++;
820 }
821 }
822 }
823 return sanitizeFieldForDBus(resolution);
824 }
825
updateResolution(const openpower::pels::PEL & pel)826 bool Manager::updateResolution(const openpower::pels::PEL& pel)
827 {
828 std::string callouts = getResolution(pel);
829 auto entryN = _logManager.entries.find(pel.obmcLogID());
830 if (entryN != _logManager.entries.end())
831 {
832 entryN->second->resolution(callouts, true);
833 }
834
835 return false;
836 }
837
serializeLogEntry(uint32_t obmcLogID)838 void Manager::serializeLogEntry(uint32_t obmcLogID)
839 {
840 auto entryN = _logManager.entries.find(obmcLogID);
841 if (entryN != _logManager.entries.end())
842 {
843 serialize(*entryN->second);
844 }
845 }
846
updateDBusSeverity(const openpower::pels::PEL & pel)847 void Manager::updateDBusSeverity(const openpower::pels::PEL& pel)
848 {
849 // The final severity of the PEL may not agree with the
850 // original severity of the D-Bus event log. Update the
851 // D-Bus property to match in some cases. This is to
852 // ensure there isn't a Critical or Warning Redfish event
853 // log for an informational or recovered PEL (or vice versa).
854 // This doesn't make an explicit call to serialize the new
855 // event log property value because updateEventId() is called
856 // right after this and will do it.
857 auto sevType =
858 static_cast<SeverityType>(pel.userHeader().severity() & 0xF0);
859
860 auto entryN = _logManager.entries.find(pel.obmcLogID());
861 if (entryN != _logManager.entries.end())
862 {
863 auto newSeverity = fixupLogSeverity(entryN->second->severity(),
864 sevType);
865 if (newSeverity)
866 {
867 lg2::info("Changing event log {ID} severity from {OLD} "
868 "to {NEW} to match PEL",
869 "ID", lg2::hex, entryN->second->id(), "OLD",
870 Entry::convertLevelToString(entryN->second->severity()),
871 "NEW", Entry::convertLevelToString(*newSeverity));
872
873 entryN->second->severity(*newSeverity, true);
874 }
875 }
876 }
877
setEntryPath(uint32_t obmcLogID)878 void Manager::setEntryPath(uint32_t obmcLogID)
879 {
880 Repository::LogID id{Repository::LogID::Obmc(obmcLogID)};
881 if (auto attributes = _repo.getPELAttributes(id); attributes)
882 {
883 auto& attr = attributes.value().get();
884 auto entry = _logManager.entries.find(obmcLogID);
885 if (entry != _logManager.entries.end())
886 {
887 entry->second->path(attr.path, true);
888 }
889 }
890 }
891
setServiceProviderNotifyFlag(uint32_t obmcLogID)892 void Manager::setServiceProviderNotifyFlag(uint32_t obmcLogID)
893 {
894 Repository::LogID id{Repository::LogID::Obmc(obmcLogID)};
895 if (auto attributes = _repo.getPELAttributes(id); attributes)
896 {
897 auto& attr = attributes.value().get();
898 auto entry = _logManager.entries.find(obmcLogID);
899 if (entry != _logManager.entries.end())
900 {
901 if (attr.actionFlags.test(callHomeFlagBit))
902 {
903 entry->second->serviceProviderNotify(Entry::Notify::Notify,
904 true);
905 }
906 else
907 {
908 entry->second->serviceProviderNotify(Entry::Notify::Inhibit,
909 true);
910 }
911 }
912 }
913 }
914
createPELEntry(uint32_t obmcLogID,bool skipIaSignal)915 void Manager::createPELEntry(uint32_t obmcLogID, bool skipIaSignal)
916 {
917 std::map<std::string, PropertiesVariant> varData;
918 Repository::LogID id{Repository::LogID::Obmc(obmcLogID)};
919 if (auto attributes = _repo.getPELAttributes(id); attributes)
920 {
921 namespace pv = openpower::pels::pel_values;
922 auto& attr = attributes.value().get();
923
924 // get the hidden flag values
925 auto sevType = static_cast<SeverityType>(attr.severity & 0xF0);
926 auto isHidden = true;
927 if (((sevType != SeverityType::nonError) &&
928 attr.actionFlags.test(reportFlagBit) &&
929 !attr.actionFlags.test(hiddenFlagBit)) ||
930 ((sevType == SeverityType::nonError) &&
931 attr.actionFlags.test(serviceActionFlagBit)))
932 {
933 isHidden = false;
934 }
935 varData.emplace(std::string("Hidden"), isHidden);
936 varData.emplace(
937 std::string("Subsystem"),
938 pv::getValue(attr.subsystem, pel_values::subsystemValues));
939
940 varData.emplace(
941 std::string("ManagementSystemAck"),
942 (attr.hmcState == TransmissionState::acked ? true : false));
943
944 varData.emplace("PlatformLogID", attr.plid);
945 varData.emplace("Deconfig", attr.deconfig);
946 varData.emplace("Guard", attr.guard);
947 varData.emplace("Timestamp", attr.creationTime);
948
949 // Path to create PELEntry Interface is same as PEL
950 auto path = std::string(OBJ_ENTRY) + '/' + std::to_string(obmcLogID);
951 // Create Interface for PELEntry and set properties
952 auto pelEntry = std::make_unique<PELEntry>(_logManager.getBus(), path,
953 varData, obmcLogID, &_repo);
954 if (!skipIaSignal)
955 {
956 pelEntry->emit_added();
957 }
958 _pelEntries.emplace(std::move(path), std::move(pelEntry));
959 }
960 }
961
getPELIdFromBMCLogId(uint32_t bmcLogId)962 uint32_t Manager::getPELIdFromBMCLogId(uint32_t bmcLogId)
963 {
964 Repository::LogID id{Repository::LogID::Obmc(bmcLogId)};
965 if (auto logId = _repo.getLogID(id); !logId.has_value())
966 {
967 throw common_error::InvalidArgument();
968 }
969 else
970 {
971 return logId->pelID.id;
972 }
973 }
974
getBMCLogIdFromPELId(uint32_t pelId)975 uint32_t Manager::getBMCLogIdFromPELId(uint32_t pelId)
976 {
977 Repository::LogID id{Repository::LogID::Pel(pelId)};
978 if (auto logId = _repo.getLogID(id); !logId.has_value())
979 {
980 throw common_error::InvalidArgument();
981 }
982 else
983 {
984 return logId->obmcID.id;
985 }
986 }
987
updateProgressSRC(std::unique_ptr<openpower::pels::PEL> & pel) const988 void Manager::updateProgressSRC(
989 std::unique_ptr<openpower::pels::PEL>& pel) const
990 {
991 // Check for pel severity of type - 0x51 = critical error, system
992 // termination
993 if (pel->userHeader().severity() == 0x51)
994 {
995 auto src = pel->primarySRC();
996 if (src)
997 {
998 std::vector<uint8_t> asciiSRC = (*src)->getSrcStruct();
999 uint64_t srcRefCode = 0;
1000
1001 // Read bytes from offset [40-47] e.g. BD8D1001
1002 for (int i = 0; i < 8; i++)
1003 {
1004 srcRefCode |= (static_cast<uint64_t>(asciiSRC[40 + i])
1005 << (8 * i));
1006 }
1007
1008 try
1009 {
1010 _dataIface->createProgressSRC(srcRefCode, asciiSRC);
1011 }
1012 catch (const std::exception&)
1013 {
1014 // Exception - may be no boot progress interface on dbus
1015 }
1016 }
1017 }
1018 }
1019
scheduleObmcLogDelete(uint32_t obmcLogID)1020 void Manager::scheduleObmcLogDelete(uint32_t obmcLogID)
1021 {
1022 _obmcLogDeleteEventSource = std::make_unique<sdeventplus::source::Defer>(
1023 _event, std::bind(std::mem_fn(&Manager::deleteObmcLog), this,
1024 std::placeholders::_1, obmcLogID));
1025 }
1026
deleteObmcLog(sdeventplus::source::EventBase &,uint32_t obmcLogID)1027 void Manager::deleteObmcLog(sdeventplus::source::EventBase&, uint32_t obmcLogID)
1028 {
1029 lg2::info("Removing event log with no PEL: {BMCID}", "BMCID", obmcLogID);
1030 _logManager.erase(obmcLogID);
1031 _obmcLogDeleteEventSource.reset();
1032 }
1033
clearPowerThermalDeconfigFlag(const std::string & locationCode,openpower::pels::PEL & pel)1034 bool Manager::clearPowerThermalDeconfigFlag(const std::string& locationCode,
1035 openpower::pels::PEL& pel)
1036 {
1037 // The requirements state that only power-thermal or
1038 // fan PELs need their deconfig flag cleared.
1039 static const std::vector<uint32_t> compIDs{bmcThermalCompID, bmcFansCompID};
1040
1041 if (std::find(compIDs.begin(), compIDs.end(),
1042 pel.privateHeader().header().componentID) == compIDs.end())
1043 {
1044 return false;
1045 }
1046
1047 auto src = pel.primarySRC();
1048 const auto& callouts = (*src)->callouts();
1049 if (!callouts)
1050 {
1051 return false;
1052 }
1053
1054 for (const auto& callout : callouts->callouts())
1055 {
1056 // Look for the passed in location code in a callout that
1057 // is either a normal HW callout or a symbolic FRU with
1058 // a trusted location code callout.
1059 if ((callout->locationCode() != locationCode) ||
1060 !callout->fruIdentity())
1061 {
1062 continue;
1063 }
1064
1065 if ((callout->fruIdentity()->failingComponentType() !=
1066 src::FRUIdentity::hardwareFRU) &&
1067 (callout->fruIdentity()->failingComponentType() !=
1068 src::FRUIdentity::symbolicFRUTrustedLocCode))
1069 {
1070 continue;
1071 }
1072
1073 lg2::info(
1074 "Clearing deconfig flag in PEL {ID} with SRC {SRC} because {LOC} was replaced",
1075 "ID", lg2::hex, pel.id(), "SRC", (*src)->asciiString().substr(0, 8),
1076 "LOC", locationCode);
1077 (*src)->clearErrorStatusFlag(SRC::ErrorStatusFlags::deconfigured);
1078 return true;
1079 }
1080 return false;
1081 }
1082
hardwarePresent(const std::string & locationCode)1083 void Manager::hardwarePresent(const std::string& locationCode)
1084 {
1085 Repository::PELUpdateFunc handlePowerThermalHardwarePresent =
1086 [locationCode](openpower::pels::PEL& pel) {
1087 return Manager::clearPowerThermalDeconfigFlag(locationCode, pel);
1088 };
1089
1090 // If the PEL was created by the BMC and has the deconfig flag set,
1091 // it's a candidate to have the deconfig flag cleared.
1092 for (const auto& [id, attributes] : _repo.getAttributesMap())
1093 {
1094 if ((attributes.creator == static_cast<uint8_t>(CreatorID::openBMC)) &&
1095 attributes.deconfig)
1096 {
1097 auto updated = _repo.updatePEL(attributes.path,
1098 handlePowerThermalHardwarePresent);
1099
1100 if (updated)
1101 {
1102 // Also update the property on D-Bus
1103 auto objPath = std::string(OBJ_ENTRY) + '/' +
1104 std::to_string(id.obmcID.id);
1105 auto entryN = _pelEntries.find(objPath);
1106 if (entryN != _pelEntries.end())
1107 {
1108 entryN->second->deconfig(false);
1109 }
1110 else
1111 {
1112 lg2::error(
1113 "Could not find PEL Entry D-Bus object for {PATH}",
1114 "PATH", objPath);
1115 }
1116 }
1117 }
1118 }
1119 }
1120
1121 } // namespace pels
1122 } // namespace openpower
1123