xref: /openbmc/phosphor-logging/extensions/openpower-pels/manager.cpp (revision b6d3e2fc727801053925d99081486989fc320900)
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::map<std::string, 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  void Manager::getLogIDWithHwIsolation(std::vector<uint32_t>& idsWithHwIsoEntry)
305  {
306      idsWithHwIsoEntry = _dataIface->getLogIDWithHwIsolation();
307  }
308  
309  bool Manager::isDeleteProhibited(uint32_t obmcLogID)
310  {
311      auto entryPath{std::string(OBJ_ENTRY) + '/' + std::to_string(obmcLogID)};
312      auto entry = _pelEntries.find(entryPath);
313      if (entry != _pelEntries.end())
314      {
315          if (entry->second->guard())
316          {
317              auto hwIsolationAssocPaths = _dataIface->getAssociatedPaths(
318                  entryPath += "/isolated_hw_entry", "/", 0,
319                  {"xyz.openbmc_project.HardwareIsolation.Entry"});
320              if (!hwIsolationAssocPaths.empty())
321              {
322                  return true;
323              }
324          }
325      }
326      return false;
327  }
328  
329  PelFFDC Manager::convertToPelFFDC(const FFDCEntries& ffdc)
330  {
331      PelFFDC pelFFDC;
332  
333      std::for_each(ffdc.begin(), ffdc.end(), [&pelFFDC](const auto& f) {
334          PelFFDCfile pf;
335          pf.subType = std::get<ffdcSubtypePos>(f);
336          pf.version = std::get<ffdcVersionPos>(f);
337          pf.fd = std::get<ffdcFDPos>(f);
338  
339          switch (std::get<ffdcFormatPos>(f))
340          {
341              case Create::FFDCFormat::JSON:
342                  pf.format = UserDataFormat::json;
343                  break;
344              case Create::FFDCFormat::CBOR:
345                  pf.format = UserDataFormat::cbor;
346                  break;
347              case Create::FFDCFormat::Text:
348                  pf.format = UserDataFormat::text;
349                  break;
350              case Create::FFDCFormat::Custom:
351                  pf.format = UserDataFormat::custom;
352                  break;
353          }
354  
355          pelFFDC.push_back(pf);
356      });
357  
358      return pelFFDC;
359  }
360  
361  void Manager::createPEL(
362      const std::string& message, uint32_t obmcLogID, uint64_t timestamp,
363      phosphor::logging::Entry::Level severity,
364      const std::map<std::string, std::string>& additionalData,
365      const std::vector<std::string>& /*associations*/, const FFDCEntries& ffdc)
366  {
367      auto entry = _registry.lookup(message, rg::LookupType::name);
368      auto pelFFDC = convertToPelFFDC(ffdc);
369      AdditionalData ad{additionalData};
370      std::string msg;
371  
372      if (!entry)
373      {
374          // Instead, get the default entry that means there is no
375          // other matching entry.  This error will still use the
376          // AdditionalData values of the original error, and this
377          // code will add the error message value that wasn't found
378          // to this AD.  This way, there will at least be a PEL,
379          // possibly with callouts, to allow users to debug the
380          // issue that caused the error even without its own PEL.
381          lg2::error("Event not found in PEL message registry: {MSG}", "MSG",
382                     message);
383  
384          entry = _registry.lookup(defaultLogMessage, rg::LookupType::name);
385          if (!entry)
386          {
387              lg2::error("Default event not found in PEL message registry");
388              return;
389          }
390  
391          ad.add(additional_data::error, message);
392      }
393  
394      auto pel = std::make_unique<openpower::pels::PEL>(
395          *entry, obmcLogID, timestamp, severity, ad, pelFFDC, *_dataIface,
396          *_journal);
397  
398      _repo.add(pel);
399  
400      if (_repo.sizeWarning())
401      {
402          scheduleRepoPrune();
403      }
404  
405      auto src = pel->primarySRC();
406      if (src)
407      {
408          auto asciiString = (*src)->asciiString();
409          while (asciiString.back() == ' ')
410          {
411              asciiString.pop_back();
412          }
413          lg2::info("Created PEL {ID} (BMC ID {BMCID}) with SRC {SRC}", "ID",
414                    lg2::hex, pel->id(), "BMCID", pel->obmcLogID(), "SRC",
415                    asciiString);
416      }
417  
418      // Check for severity 0x51 and update boot progress SRC
419      updateProgressSRC(pel);
420  
421      // Activate any resulting service indicators if necessary
422      auto policy = service_indicators::getPolicy(*_dataIface);
423      policy->activate(*pel);
424  
425      updateDBusSeverity(*pel);
426      updateEventId(pel);
427      updateResolution(*pel);
428      serializeLogEntry(obmcLogID);
429      createPELEntry(obmcLogID);
430  
431      // Check if firmware should quiesce system due to error
432      checkPelAndQuiesce(pel);
433  }
434  
435  sdbusplus::message::unix_fd Manager::getPEL(uint32_t pelID)
436  {
437      Repository::LogID id{Repository::LogID::Pel(pelID)};
438      std::optional<int> fd;
439  
440      lg2::debug("getPEL {ID}", "ID", lg2::hex, pelID);
441  
442      try
443      {
444          fd = _repo.getPELFD(id);
445      }
446      catch (const std::exception& e)
447      {
448          throw common_error::InternalFailure();
449      }
450  
451      if (!fd)
452      {
453          throw common_error::InvalidArgument();
454      }
455  
456      scheduleFDClose(*fd);
457  
458      return *fd;
459  }
460  
461  void Manager::scheduleFDClose(int fd)
462  {
463      _fdCloserEventSource = std::make_unique<sdeventplus::source::Defer>(
464          _event, std::bind(std::mem_fn(&Manager::closeFD), this, fd,
465                            std::placeholders::_1));
466  }
467  
468  void Manager::closeFD(int fd, sdeventplus::source::EventBase& /*source*/)
469  {
470      close(fd);
471      _fdCloserEventSource.reset();
472  }
473  
474  std::vector<uint8_t> Manager::getPELFromOBMCID(uint32_t obmcLogID)
475  {
476      Repository::LogID id{Repository::LogID::Obmc(obmcLogID)};
477      std::optional<std::vector<uint8_t>> data;
478  
479      lg2::debug("getPELFromOBMCID  {BMCID}", "BMCID", obmcLogID);
480  
481      try
482      {
483          data = _repo.getPELData(id);
484      }
485      catch (const std::exception& e)
486      {
487          throw common_error::InternalFailure();
488      }
489  
490      if (!data)
491      {
492          throw common_error::InvalidArgument();
493      }
494  
495      return *data;
496  }
497  
498  void Manager::hostAck(uint32_t pelID)
499  {
500      Repository::LogID id{Repository::LogID::Pel(pelID)};
501  
502      lg2::debug("HostHack {ID}", "ID", lg2::hex, pelID);
503  
504      if (!_repo.hasPEL(id))
505      {
506          throw common_error::InvalidArgument();
507      }
508  
509      if (_hostNotifier)
510      {
511          _hostNotifier->ackPEL(pelID);
512      }
513  }
514  
515  void Manager::hostReject(uint32_t pelID, RejectionReason reason)
516  {
517      Repository::LogID id{Repository::LogID::Pel(pelID)};
518  
519      lg2::debug("HostReject {ID}, reason = {REASON}", "ID", lg2::hex, pelID,
520                 "REASON", reason);
521  
522      if (!_repo.hasPEL(id))
523      {
524          throw common_error::InvalidArgument();
525      }
526  
527      if (reason == RejectionReason::BadPEL)
528      {
529          AdditionalData data;
530          data.add("BAD_ID", getNumberString("0x%08X", pelID));
531          _eventLogger.log("org.open_power.Logging.Error.SentBadPELToHost",
532                           Entry::Level::Informational, data);
533          if (_hostNotifier)
534          {
535              _hostNotifier->setBadPEL(pelID);
536          }
537      }
538      else if ((reason == RejectionReason::HostFull) && _hostNotifier)
539      {
540          _hostNotifier->setHostFull(pelID);
541      }
542  }
543  
544  void Manager::scheduleRepoPrune()
545  {
546      _repoPrunerEventSource = std::make_unique<sdeventplus::source::Defer>(
547          _event, std::bind(std::mem_fn(&Manager::pruneRepo), this,
548                            std::placeholders::_1));
549  }
550  
551  void Manager::pruneRepo(sdeventplus::source::EventBase& /*source*/)
552  {
553      auto idsWithHwIsoEntry = _dataIface->getLogIDWithHwIsolation();
554  
555      auto idsToDelete = _repo.prune(idsWithHwIsoEntry);
556  
557      // Remove the OpenBMC event logs for the PELs that were just removed.
558      std::for_each(idsToDelete.begin(), idsToDelete.end(),
559                    [this](auto id) { this->_logManager.erase(id); });
560  
561      _repoPrunerEventSource.reset();
562  }
563  
564  void Manager::setupPELDeleteWatch()
565  {
566      _pelFileDeleteFD = inotify_init1(IN_NONBLOCK);
567      if (-1 == _pelFileDeleteFD)
568      {
569          auto e = errno;
570          lg2::error("inotify_init1 failed with errno {ERRNO}", "ERRNO", e);
571          abort();
572      }
573  
574      _pelFileDeleteWatchFD = inotify_add_watch(
575          _pelFileDeleteFD, _repo.repoPath().c_str(), IN_DELETE);
576      if (-1 == _pelFileDeleteWatchFD)
577      {
578          auto e = errno;
579          lg2::error("inotify_add_watch failed with errno {ERRNO}", "ERRNO", e);
580          abort();
581      }
582  
583      _pelFileDeleteEventSource = std::make_unique<sdeventplus::source::IO>(
584          _event, _pelFileDeleteFD, EPOLLIN,
585          std::bind(std::mem_fn(&Manager::pelFileDeleted), this,
586                    std::placeholders::_1, std::placeholders::_2,
587                    std::placeholders::_3));
588  }
589  
590  void Manager::pelFileDeleted(sdeventplus::source::IO& /*io*/, int /*fd*/,
591                               uint32_t revents)
592  {
593      if (!(revents & EPOLLIN))
594      {
595          return;
596      }
597  
598      // An event for 1 PEL uses 48B. When all PELs are deleted at once,
599      // as many events as there is room for can be handled in one callback.
600      // A size of 2000 will allow 41 to be processed, with additional
601      // callbacks being needed to process the remaining ones.
602      std::array<uint8_t, 2000> data{};
603      auto bytesRead = read(_pelFileDeleteFD, data.data(), data.size());
604      if (bytesRead < 0)
605      {
606          auto e = errno;
607          lg2::error("Failed reading data from inotify event, errno = {ERRNO}",
608                     "ERRNO", e);
609          abort();
610      }
611  
612      auto offset = 0;
613      while (offset < bytesRead)
614      {
615          auto event = reinterpret_cast<inotify_event*>(&data[offset]);
616          if (event->mask & IN_DELETE)
617          {
618              std::string filename{event->name};
619  
620              // Get the PEL ID from the filename and tell the
621              // repo it's been removed, and then delete the BMC
622              // event log if it's there.
623              auto pos = filename.find_first_of('_');
624              if (pos != std::string::npos)
625              {
626                  try
627                  {
628                      auto idString = filename.substr(pos + 1);
629                      auto pelID = std::stoul(idString, nullptr, 16);
630  
631                      Repository::LogID id{Repository::LogID::Pel(pelID)};
632                      auto removedLogID = _repo.remove(id);
633                      if (removedLogID)
634                      {
635                          _logManager.erase(removedLogID->obmcID.id);
636                      }
637                  }
638                  catch (const std::exception& e)
639                  {
640                      lg2::info("Could not find PEL ID from its filename {NAME}",
641                                "NAME", filename);
642                  }
643              }
644          }
645  
646          offset += offsetof(inotify_event, name) + event->len;
647      }
648  }
649  
650  std::tuple<uint32_t, uint32_t> Manager::createPELWithFFDCFiles(
651      std::string message, Entry::Level severity,
652      std::map<std::string, std::string> additionalData,
653      std::vector<std::tuple<
654          sdbusplus::server::xyz::openbmc_project::logging::Create::FFDCFormat,
655          uint8_t, uint8_t, sdbusplus::message::unix_fd>>
656          fFDC)
657  {
658      _logManager.create(message, severity, additionalData, fFDC);
659  
660      return {_logManager.lastEntryID(), _repo.lastPelID()};
661  }
662  
663  std::string Manager::getPELJSON(uint32_t obmcLogID)
664  {
665      // Throws InvalidArgument if not found
666      auto pelID = getPELIdFromBMCLogId(obmcLogID);
667  
668      auto cmd = std::format("/usr/bin/peltool -i {:#x}", pelID);
669  
670      FILE* pipe = popen(cmd.c_str(), "r");
671      if (!pipe)
672      {
673          lg2::error("Error running cmd: {CMD}", "CMD", cmd);
674          throw common_error::InternalFailure();
675      }
676  
677      std::string output;
678      std::array<char, 1024> buffer;
679      while (fgets(buffer.data(), buffer.size(), pipe) != nullptr)
680      {
681          output.append(buffer.data());
682      }
683  
684      int rc = pclose(pipe);
685      if (WEXITSTATUS(rc) != 0)
686      {
687          lg2::error("Error running cmd: {CMD}, rc = {RC}", "CMD", cmd, "RC", rc);
688          throw common_error::InternalFailure();
689      }
690  
691      return output;
692  }
693  
694  void Manager::checkPelAndQuiesce(std::unique_ptr<openpower::pels::PEL>& pel)
695  {
696      if ((pel->userHeader().severity() ==
697           static_cast<uint8_t>(SeverityType::nonError)) ||
698          (pel->userHeader().severity() ==
699           static_cast<uint8_t>(SeverityType::recovered)))
700      {
701          lg2::debug(
702              "PEL severity informational or recovered. no quiesce needed");
703          return;
704      }
705      if (!_logManager.isQuiesceOnErrorEnabled())
706      {
707          lg2::debug("QuiesceOnHwError not enabled, no quiesce needed");
708          return;
709      }
710  
711      CreatorID creatorID{pel->privateHeader().creatorID()};
712  
713      if ((creatorID != CreatorID::openBMC) &&
714          (creatorID != CreatorID::hostboot) &&
715          (creatorID != CreatorID::ioDrawer) && (creatorID != CreatorID::occ) &&
716          (creatorID != CreatorID::phyp))
717      {
718          return;
719      }
720  
721      // Now check if it has any type of callout
722      if (pel->isHwCalloutPresent())
723      {
724          lg2::info(
725              "QuiesceOnHwError enabled, PEL severity not nonError or recovered, "
726              "and callout is present");
727  
728          _logManager.quiesceOnError(pel->obmcLogID());
729      }
730  }
731  
732  std::string Manager::getEventId(const openpower::pels::PEL& pel) const
733  {
734      std::string str;
735      auto src = pel.primarySRC();
736      if (src)
737      {
738          const auto& hexwords = (*src)->hexwordData();
739  
740          std::string refcode = (*src)->asciiString();
741          size_t pos = refcode.find_last_not_of(0x20);
742          if (pos != std::string::npos)
743          {
744              refcode.erase(pos + 1);
745          }
746          str = refcode;
747  
748          for (auto& value : hexwords)
749          {
750              str += " ";
751              str += getNumberString("%08X", value);
752          }
753      }
754      return sanitizeFieldForDBus(str);
755  }
756  
757  void Manager::updateEventId(std::unique_ptr<openpower::pels::PEL>& pel)
758  {
759      std::string eventIdStr = getEventId(*pel);
760  
761      auto entryN = _logManager.entries.find(pel->obmcLogID());
762      if (entryN != _logManager.entries.end())
763      {
764          entryN->second->eventId(eventIdStr, true);
765      }
766  }
767  
768  std::string Manager::sanitizeFieldForDBus(std::string field)
769  {
770      std::for_each(field.begin(), field.end(), [](char& ch) {
771          if (((ch < ' ') || (ch > '~')) && (ch != '\n') && (ch != '\t'))
772          {
773              ch = ' ';
774          }
775      });
776      return field;
777  }
778  
779  std::string Manager::getResolution(const openpower::pels::PEL& pel) const
780  {
781      std::string str;
782      std::string resolution;
783      auto src = pel.primarySRC();
784      if (src)
785      {
786          // First extract the callout pointer and then go through
787          const auto& callouts = (*src)->callouts();
788          namespace pv = openpower::pels::pel_values;
789          // All PELs dont have callout, check before parsing callout data
790          if (callouts)
791          {
792              const auto& entries = callouts->callouts();
793              // Entry starts with index 1
794              uint8_t index = 1;
795              for (auto& entry : entries)
796              {
797                  resolution += std::to_string(index) + ". ";
798                  // Adding Location code to resolution
799                  if (!entry->locationCode().empty())
800                      resolution += "Location Code: " + entry->locationCode() +
801                                    ", ";
802                  if (entry->fruIdentity())
803                  {
804                      // Get priority and set the resolution string
805                      str = pv::getValue(entry->priority(),
806                                         pel_values::calloutPriorityValues,
807                                         pel_values::registryNamePos);
808                      str[0] = toupper(str[0]);
809                      resolution += "Priority: " + str + ", ";
810                      if (entry->fruIdentity()->getPN().has_value())
811                      {
812                          resolution +=
813                              "PN: " + entry->fruIdentity()->getPN().value() +
814                              ", ";
815                      }
816                      if (entry->fruIdentity()->getSN().has_value())
817                      {
818                          resolution +=
819                              "SN: " + entry->fruIdentity()->getSN().value() +
820                              ", ";
821                      }
822                      if (entry->fruIdentity()->getCCIN().has_value())
823                      {
824                          resolution +=
825                              "CCIN: " + entry->fruIdentity()->getCCIN().value() +
826                              ", ";
827                      }
828                      // Add the maintenance procedure
829                      if (entry->fruIdentity()->getMaintProc().has_value())
830                      {
831                          resolution +=
832                              "Procedure: " +
833                              entry->fruIdentity()->getMaintProc().value() + ", ";
834                      }
835                  }
836                  resolution.resize(resolution.size() - 2);
837                  resolution += "\n";
838                  index++;
839              }
840          }
841      }
842      return sanitizeFieldForDBus(resolution);
843  }
844  
845  bool Manager::updateResolution(const openpower::pels::PEL& pel)
846  {
847      std::string callouts = getResolution(pel);
848      auto entryN = _logManager.entries.find(pel.obmcLogID());
849      if (entryN != _logManager.entries.end())
850      {
851          entryN->second->resolution(callouts, true);
852      }
853  
854      return false;
855  }
856  
857  void Manager::serializeLogEntry(uint32_t obmcLogID)
858  {
859      auto entryN = _logManager.entries.find(obmcLogID);
860      if (entryN != _logManager.entries.end())
861      {
862          serialize(*entryN->second);
863      }
864  }
865  
866  void Manager::updateDBusSeverity(const openpower::pels::PEL& pel)
867  {
868      // The final severity of the PEL may not agree with the
869      // original severity of the D-Bus event log.  Update the
870      // D-Bus property to match in some cases.  This is to
871      // ensure there isn't a Critical or Warning Redfish event
872      // log for an informational or recovered PEL (or vice versa).
873      // This doesn't make an explicit call to serialize the new
874      // event log property value because updateEventId() is called
875      // right after this and will do it.
876      auto sevType =
877          static_cast<SeverityType>(pel.userHeader().severity() & 0xF0);
878  
879      auto entryN = _logManager.entries.find(pel.obmcLogID());
880      if (entryN != _logManager.entries.end())
881      {
882          auto newSeverity =
883              fixupLogSeverity(entryN->second->severity(), sevType);
884          if (newSeverity)
885          {
886              lg2::info("Changing event log {ID} severity from {OLD} "
887                        "to {NEW} to match PEL",
888                        "ID", lg2::hex, entryN->second->id(), "OLD",
889                        Entry::convertLevelToString(entryN->second->severity()),
890                        "NEW", Entry::convertLevelToString(*newSeverity));
891  
892              entryN->second->severity(*newSeverity, true);
893          }
894      }
895  }
896  
897  void Manager::setEntryPath(uint32_t obmcLogID)
898  {
899      Repository::LogID id{Repository::LogID::Obmc(obmcLogID)};
900      if (auto attributes = _repo.getPELAttributes(id); attributes)
901      {
902          auto& attr = attributes.value().get();
903          auto entry = _logManager.entries.find(obmcLogID);
904          if (entry != _logManager.entries.end())
905          {
906              entry->second->path(attr.path, true);
907          }
908      }
909  }
910  
911  void Manager::setServiceProviderNotifyFlag(uint32_t obmcLogID)
912  {
913      Repository::LogID id{Repository::LogID::Obmc(obmcLogID)};
914      if (auto attributes = _repo.getPELAttributes(id); attributes)
915      {
916          auto& attr = attributes.value().get();
917          auto entry = _logManager.entries.find(obmcLogID);
918          if (entry != _logManager.entries.end())
919          {
920              if (attr.actionFlags.test(callHomeFlagBit))
921              {
922                  entry->second->serviceProviderNotify(Entry::Notify::Notify,
923                                                       true);
924              }
925              else
926              {
927                  entry->second->serviceProviderNotify(Entry::Notify::Inhibit,
928                                                       true);
929              }
930          }
931      }
932  }
933  
934  void Manager::createPELEntry(uint32_t obmcLogID, bool skipIaSignal)
935  {
936      std::map<std::string, PropertiesVariant> varData;
937      Repository::LogID id{Repository::LogID::Obmc(obmcLogID)};
938      if (auto attributes = _repo.getPELAttributes(id); attributes)
939      {
940          namespace pv = openpower::pels::pel_values;
941          auto& attr = attributes.value().get();
942  
943          // get the hidden flag values
944          auto sevType = static_cast<SeverityType>(attr.severity & 0xF0);
945          auto isHidden = true;
946          if (((sevType != SeverityType::nonError) &&
947               attr.actionFlags.test(reportFlagBit) &&
948               !attr.actionFlags.test(hiddenFlagBit)) ||
949              ((sevType == SeverityType::nonError) &&
950               attr.actionFlags.test(serviceActionFlagBit)))
951          {
952              isHidden = false;
953          }
954          varData.emplace(std::string("Hidden"), isHidden);
955          varData.emplace(
956              std::string("Subsystem"),
957              pv::getValue(attr.subsystem, pel_values::subsystemValues));
958  
959          varData.emplace(
960              std::string("ManagementSystemAck"),
961              (attr.hmcState == TransmissionState::acked ? true : false));
962  
963          varData.emplace("PlatformLogID", attr.plid);
964          varData.emplace("Deconfig", attr.deconfig);
965          varData.emplace("Guard", attr.guard);
966          varData.emplace("Timestamp", attr.creationTime);
967  
968          // Path to create PELEntry Interface is same as PEL
969          auto path = std::string(OBJ_ENTRY) + '/' + std::to_string(obmcLogID);
970          // Create Interface for PELEntry and set properties
971          auto pelEntry = std::make_unique<PELEntry>(_logManager.getBus(), path,
972                                                     varData, obmcLogID, &_repo);
973          if (!skipIaSignal)
974          {
975              pelEntry->emit_added();
976          }
977          _pelEntries.emplace(std::move(path), std::move(pelEntry));
978      }
979  }
980  
981  uint32_t Manager::getPELIdFromBMCLogId(uint32_t bmcLogId)
982  {
983      Repository::LogID id{Repository::LogID::Obmc(bmcLogId)};
984      if (auto logId = _repo.getLogID(id); !logId.has_value())
985      {
986          throw common_error::InvalidArgument();
987      }
988      else
989      {
990          return logId->pelID.id;
991      }
992  }
993  
994  uint32_t Manager::getBMCLogIdFromPELId(uint32_t pelId)
995  {
996      Repository::LogID id{Repository::LogID::Pel(pelId)};
997      if (auto logId = _repo.getLogID(id); !logId.has_value())
998      {
999          throw common_error::InvalidArgument();
1000      }
1001      else
1002      {
1003          return logId->obmcID.id;
1004      }
1005  }
1006  
1007  void
1008      Manager::updateProgressSRC(std::unique_ptr<openpower::pels::PEL>& pel) const
1009  {
1010      // Check for pel severity of type - 0x51 = critical error, system
1011      // termination
1012      if (pel->userHeader().severity() == 0x51)
1013      {
1014          auto src = pel->primarySRC();
1015          if (src)
1016          {
1017              std::vector<uint8_t> asciiSRC = (*src)->getSrcStruct();
1018              uint64_t srcRefCode = 0;
1019  
1020              // Read bytes from offset [40-47] e.g. BD8D1001
1021              for (int i = 0; i < 8; i++)
1022              {
1023                  srcRefCode |=
1024                      (static_cast<uint64_t>(asciiSRC[40 + i]) << (8 * i));
1025              }
1026  
1027              try
1028              {
1029                  _dataIface->createProgressSRC(srcRefCode, asciiSRC);
1030              }
1031              catch (const std::exception&)
1032              {
1033                  // Exception - may be no boot progress interface on dbus
1034              }
1035          }
1036      }
1037  }
1038  
1039  void Manager::scheduleObmcLogDelete(uint32_t obmcLogID)
1040  {
1041      _obmcLogDeleteEventSource = std::make_unique<sdeventplus::source::Defer>(
1042          _event, std::bind(std::mem_fn(&Manager::deleteObmcLog), this,
1043                            std::placeholders::_1, obmcLogID));
1044  }
1045  
1046  void Manager::deleteObmcLog(sdeventplus::source::EventBase&, uint32_t obmcLogID)
1047  {
1048      lg2::info("Removing event log with no PEL: {BMCID}", "BMCID", obmcLogID);
1049      _logManager.erase(obmcLogID);
1050      _obmcLogDeleteEventSource.reset();
1051  }
1052  
1053  bool Manager::clearPowerThermalDeconfigFlag(const std::string& locationCode,
1054                                              openpower::pels::PEL& pel)
1055  {
1056      // The requirements state that only power-thermal or
1057      // fan PELs need their deconfig flag cleared.
1058      static const std::vector<uint32_t> compIDs{bmcThermalCompID, bmcFansCompID};
1059  
1060      if (std::find(compIDs.begin(), compIDs.end(),
1061                    pel.privateHeader().header().componentID) == compIDs.end())
1062      {
1063          return false;
1064      }
1065  
1066      auto src = pel.primarySRC();
1067      const auto& callouts = (*src)->callouts();
1068      if (!callouts)
1069      {
1070          return false;
1071      }
1072  
1073      for (const auto& callout : callouts->callouts())
1074      {
1075          // Look for the passed in location code in a callout that
1076          // is either a normal HW callout or a symbolic FRU with
1077          // a trusted location code callout.
1078          if ((callout->locationCode() != locationCode) ||
1079              !callout->fruIdentity())
1080          {
1081              continue;
1082          }
1083  
1084          if ((callout->fruIdentity()->failingComponentType() !=
1085               src::FRUIdentity::hardwareFRU) &&
1086              (callout->fruIdentity()->failingComponentType() !=
1087               src::FRUIdentity::symbolicFRUTrustedLocCode))
1088          {
1089              continue;
1090          }
1091  
1092          lg2::info(
1093              "Clearing deconfig flag in PEL {ID} with SRC {SRC} because {LOC} was replaced",
1094              "ID", lg2::hex, pel.id(), "SRC", (*src)->asciiString().substr(0, 8),
1095              "LOC", locationCode);
1096          (*src)->clearErrorStatusFlag(SRC::ErrorStatusFlags::deconfigured);
1097          return true;
1098      }
1099      return false;
1100  }
1101  
1102  void Manager::hardwarePresent(const std::string& locationCode)
1103  {
1104      Repository::PELUpdateFunc handlePowerThermalHardwarePresent =
1105          [locationCode](openpower::pels::PEL& pel) {
1106              return Manager::clearPowerThermalDeconfigFlag(locationCode, pel);
1107          };
1108  
1109      // If the PEL was created by the BMC and has the deconfig flag set,
1110      // it's a candidate to have the deconfig flag cleared.
1111      for (const auto& [id, attributes] : _repo.getAttributesMap())
1112      {
1113          if ((attributes.creator == static_cast<uint8_t>(CreatorID::openBMC)) &&
1114              attributes.deconfig)
1115          {
1116              auto updated = _repo.updatePEL(attributes.path,
1117                                             handlePowerThermalHardwarePresent);
1118  
1119              if (updated)
1120              {
1121                  // Also update the property on D-Bus
1122                  auto objPath = std::string(OBJ_ENTRY) + '/' +
1123                                 std::to_string(id.obmcID.id);
1124                  auto entryN = _pelEntries.find(objPath);
1125                  if (entryN != _pelEntries.end())
1126                  {
1127                      entryN->second->deconfig(false);
1128                  }
1129                  else
1130                  {
1131                      lg2::error(
1132                          "Could not find PEL Entry D-Bus object for {PATH}",
1133                          "PATH", objPath);
1134                  }
1135              }
1136          }
1137      }
1138  }
1139  
1140  } // namespace pels
1141  } // namespace openpower
1142