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 
getLogIDWithHwIsolation(std::vector<uint32_t> & idsWithHwIsoEntry)304 void Manager::getLogIDWithHwIsolation(std::vector<uint32_t>& idsWithHwIsoEntry)
305 {
306     idsWithHwIsoEntry = _dataIface->getLogIDWithHwIsolation();
307 }
308 
isDeleteProhibited(uint32_t obmcLogID)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 
convertToPelFFDC(const FFDCEntries & ffdc)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 
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)361 void Manager::createPEL(
362     const std::string& message, uint32_t obmcLogID, uint64_t timestamp,
363     phosphor::logging::Entry::Level severity,
364     const std::vector<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 
getPEL(uint32_t pelID)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 
scheduleFDClose(int fd)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 
closeFD(int fd,sdeventplus::source::EventBase &)468 void Manager::closeFD(int fd, sdeventplus::source::EventBase& /*source*/)
469 {
470     close(fd);
471     _fdCloserEventSource.reset();
472 }
473 
getPELFromOBMCID(uint32_t obmcLogID)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 
hostAck(uint32_t pelID)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 
hostReject(uint32_t pelID,RejectionReason reason)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 
scheduleRepoPrune()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 
pruneRepo(sdeventplus::source::EventBase &)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 
setupPELDeleteWatch()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 
pelFileDeleted(sdeventplus::source::IO &,int,uint32_t revents)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 
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)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 
getPELJSON(uint32_t obmcLogID)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 
checkPelAndQuiesce(std::unique_ptr<openpower::pels::PEL> & pel)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 
getEventId(const openpower::pels::PEL & pel) const732 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 
updateEventId(std::unique_ptr<openpower::pels::PEL> & pel)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 
sanitizeFieldForDBus(std::string field)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 
getResolution(const openpower::pels::PEL & pel) const779 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 
updateResolution(const openpower::pels::PEL & pel)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 
serializeLogEntry(uint32_t obmcLogID)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 
updateDBusSeverity(const openpower::pels::PEL & pel)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 
setEntryPath(uint32_t obmcLogID)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 
setServiceProviderNotifyFlag(uint32_t obmcLogID)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 
createPELEntry(uint32_t obmcLogID,bool skipIaSignal)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 
getPELIdFromBMCLogId(uint32_t bmcLogId)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 
getBMCLogIdFromPELId(uint32_t pelId)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 
updateProgressSRC(std::unique_ptr<openpower::pels::PEL> & pel) const1007 void Manager::updateProgressSRC(
1008     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 
scheduleObmcLogDelete(uint32_t obmcLogID)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 
deleteObmcLog(sdeventplus::source::EventBase &,uint32_t obmcLogID)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 
clearPowerThermalDeconfigFlag(const std::string & locationCode,openpower::pels::PEL & pel)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 
hardwarePresent(const std::string & locationCode)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