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 
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 
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 
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 
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 
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 
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 
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 
304 bool Manager::isDeleteProhibited(uint32_t /*obmcLogID*/)
305 {
306     return false;
307 }
308 
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 
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 
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 
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 
449 void Manager::closeFD(int fd, sdeventplus::source::EventBase& /*source*/)
450 {
451     close(fd);
452     _fdCloserEventSource.reset();
453 }
454 
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 
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 
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 
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 
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 
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 
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 
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.createWithFFDC(message, severity, additionalData, fFDC);
640 
641     return {_logManager.lastEntryID(), _repo.lastPelID()};
642 }
643 
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 
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 
713 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 
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 
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 
760 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 
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 
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 
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 
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 
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 
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 
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 
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 
988 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 
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 
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 
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 
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