blob: 9a647222b806af6d475f73a644fad95a36e4b175 [file] [log] [blame]
Matt Spinler711d51d2019-11-06 09:36:51 -06001/**
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 */
Matt Spinler4e8078c2019-07-09 13:22:32 -050016#include "manager.hpp"
17
18#include "additional_data.hpp"
Matt Spinler3387eac2023-07-06 14:56:02 -050019#include "elog_serialize.hpp"
Matt Spinler05c2c6c2019-12-18 14:02:09 -060020#include "json_utils.hpp"
Matt Spinler89fa0822019-07-17 13:54:30 -050021#include "pel.hpp"
Vijay Lobo2fb10212021-08-22 23:24:16 -050022#include "pel_entry.hpp"
Matt Spinler1962e082020-08-05 13:44:53 -050023#include "service_indicators.hpp"
Matt Spinler8b81ec02022-07-12 13:25:37 -050024#include "severity.hpp"
Matt Spinler89fa0822019-07-17 13:54:30 -050025
Matt Spinlerff9cec22020-07-15 13:06:35 -050026#include <sys/inotify.h>
Matt Spinler6b1a5c82020-01-07 08:48:53 -060027#include <unistd.h>
28
Matt Spinlerfbdfc762023-06-30 15:15:44 -050029#include <phosphor-logging/lg2.hpp>
Patrick Williams2544b412022-10-04 08:41:06 -050030#include <xyz/openbmc_project/Common/error.hpp>
31#include <xyz/openbmc_project/Logging/Create/server.hpp>
32
Matt Spinler89fa0822019-07-17 13:54:30 -050033#include <filesystem>
Jayanth Othayoth1aa90d42023-09-13 04:25:45 -050034#include <format>
Matt Spinler89fa0822019-07-17 13:54:30 -050035#include <fstream>
Matt Spinler0003af12022-06-08 10:46:17 -050036#include <locale>
Matt Spinler4e8078c2019-07-09 13:22:32 -050037
38namespace openpower
39{
40namespace pels
41{
42
43using namespace phosphor::logging;
Matt Spinler89fa0822019-07-17 13:54:30 -050044namespace fs = std::filesystem;
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +080045namespace rg = openpower::pels::message;
Matt Spinler4e8078c2019-07-09 13:22:32 -050046
Matt Spinlera34ab722019-12-16 10:39:32 -060047namespace common_error = sdbusplus::xyz::openbmc_project::Common::Error;
48
Willy Tu6ddbf692023-09-05 10:54:16 -070049using Create = sdbusplus::server::xyz::openbmc_project::logging::Create;
Matt Spinler56ad2a02020-03-26 14:00:52 -050050
Matt Spinler4e8078c2019-07-09 13:22:32 -050051namespace additional_data
52{
53constexpr auto rawPEL = "RAWPEL";
Matt Spinler19e72902020-01-24 11:05:20 -060054constexpr auto esel = "ESEL";
Matt Spinler30ddc9f2020-07-16 15:39:59 -050055constexpr auto error = "ERROR_NAME";
Matt Spinler19e72902020-01-24 11:05:20 -060056} // namespace additional_data
Matt Spinler4e8078c2019-07-09 13:22:32 -050057
Matt Spinler30ddc9f2020-07-16 15:39:59 -050058constexpr auto defaultLogMessage = "xyz.openbmc_project.Logging.Error.Default";
Matt Spinler0dd22c82023-05-04 15:28:12 -050059constexpr uint32_t bmcThermalCompID = 0x2700;
60constexpr uint32_t bmcFansCompID = 0x2800;
Matt Spinler30ddc9f2020-07-16 15:39:59 -050061
Matt Spinlerff9cec22020-07-15 13:06:35 -050062Manager::~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
Matt Spinler4e8078c2019-07-09 13:22:32 -050074void Manager::create(const std::string& message, uint32_t obmcLogID,
75 uint64_t timestamp, Entry::Level severity,
76 const std::vector<std::string>& additionalData,
Matt Spinler56ad2a02020-03-26 14:00:52 -050077 const std::vector<std::string>& associations,
78 const FFDCEntries& ffdc)
Matt Spinler4e8078c2019-07-09 13:22:32 -050079{
80 AdditionalData ad{additionalData};
81
Matt Spinler19e72902020-01-24 11:05:20 -060082 // If a PEL was passed in via a filename or in an ESEL,
83 // use that. Otherwise, create one.
Matt Spinler4e8078c2019-07-09 13:22:32 -050084 auto rawPelPath = ad.getValue(additional_data::rawPEL);
85 if (rawPelPath)
86 {
87 addRawPEL(*rawPelPath, obmcLogID);
88 }
89 else
90 {
Matt Spinler19e72902020-01-24 11:05:20 -060091 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,
Matt Spinler56ad2a02020-03-26 14:00:52 -050099 associations, ffdc);
Matt Spinler19e72902020-01-24 11:05:20 -0600100 }
Matt Spinler4e8078c2019-07-09 13:22:32 -0500101 }
Adriana Kobylake7d271a2020-12-07 14:32:44 -0600102
103 setEntryPath(obmcLogID);
Vijay Lobocbc93a42021-05-20 19:04:07 -0500104 setServiceProviderNotifyFlag(obmcLogID);
Matt Spinler4e8078c2019-07-09 13:22:32 -0500105}
106
107void Manager::addRawPEL(const std::string& rawPelPath, uint32_t obmcLogID)
108{
Matt Spinler89fa0822019-07-17 13:54:30 -0500109 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 {
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500117 lg2::error(
118 "Filesystem error reading a raw PEL. File = {FILE}, obmcLogID = {LOGID}",
119 "FILE", rawPelPath, "LOGID", obmcLogID);
Matt Spinler89fa0822019-07-17 13:54:30 -0500120 // TODO, Decide what to do here. Maybe nothing.
121 return;
122 }
123
124 file.close();
125
Matt Spinler19e72902020-01-24 11:05:20 -0600126 addPEL(data, obmcLogID);
Matt Spinler67416922021-07-19 12:34:57 -0600127
128 std::error_code ec;
129 fs::remove(rawPelPath, ec);
Matt Spinler89fa0822019-07-17 13:54:30 -0500130 }
131 else
132 {
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500133 lg2::error(
134 "Raw PEL file from BMC event log does not exit. File = {FILE}, obmcLogID = {LOGID}",
135 "FILE", rawPelPath, "LOGID", obmcLogID);
Matt Spinler89fa0822019-07-17 13:54:30 -0500136 }
Matt Spinler4e8078c2019-07-09 13:22:32 -0500137}
138
Matt Spinler19e72902020-01-24 11:05:20 -0600139void Manager::addPEL(std::vector<uint8_t>& pelData, uint32_t obmcLogID)
140{
Matt Spinler19e72902020-01-24 11:05:20 -0600141 auto pel = std::make_unique<openpower::pels::PEL>(pelData, obmcLogID);
142 if (pel->valid())
143 {
Sumit Kumar8ec41562021-10-29 05:39:37 -0500144 // PELs created by others still need this field set by us.
145 pel->setCommitTime();
146
Sumit Kumara1e40842021-06-23 09:52:25 -0500147 // Assign Id other than to Hostbot PEL
148 if ((pel->privateHeader()).creatorID() !=
149 static_cast<uint8_t>(CreatorID::hostboot))
150 {
151 pel->assignID();
152 }
Sumit Kumar2ccdcef2021-07-31 10:04:58 -0500153 else
154 {
155 const Repository::LogID id{Repository::LogID::Pel(pel->id())};
156 auto result = _repo.hasPEL(id);
157 if (result)
158 {
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500159 lg2::warning(
160 "Duplicate HostBoot PEL ID {ID} found, moving it to archive folder",
161 "ID", lg2::hex, pel->id());
Sumit Kumar2ccdcef2021-07-31 10:04:58 -0500162
163 _repo.archivePEL(*pel);
Matt Spinlerd8fb5ba2022-01-25 13:01:14 -0600164
165 // No need to keep around the openBMC event log entry
166 scheduleObmcLogDelete(obmcLogID);
Sumit Kumar2ccdcef2021-07-31 10:04:58 -0500167 return;
168 }
169 }
Sumit Kumara1e40842021-06-23 09:52:25 -0500170
Sumit Kumar3160a542021-04-26 08:07:04 -0500171 // Update System Info to Extended User Data
172 pel->updateSysInfoInExtendedUserDataSection(*_dataIface);
173
Sumit Kumar3e274432021-09-14 06:37:56 -0500174 // Check for severity 0x51 and update boot progress SRC
175 updateProgressSRC(pel);
176
Matt Spinler19e72902020-01-24 11:05:20 -0600177 try
178 {
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500179 lg2::debug("Adding external PEL {ID} (BMC ID {BMCID}) to repo",
180 "ID", lg2::hex, pel->id(), "BMCID", obmcLogID);
Matt Spinler19e72902020-01-24 11:05:20 -0600181 _repo.add(pel);
Matt Spinler7e727a32020-07-07 15:00:17 -0500182
183 if (_repo.sizeWarning())
184 {
185 scheduleRepoPrune();
186 }
Matt Spinler1962e082020-08-05 13:44:53 -0500187
188 // Activate any resulting service indicators if necessary
189 auto policy = service_indicators::getPolicy(*_dataIface);
190 policy->activate(*pel);
Matt Spinler19e72902020-01-24 11:05:20 -0600191 }
Patrick Williams66491c62021-10-06 12:23:37 -0500192 catch (const std::exception& e)
Matt Spinler19e72902020-01-24 11:05:20 -0600193 {
194 // Probably a full or r/o filesystem, not much we can do.
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500195 lg2::error("Unable to add PEL {ID} to Repository", "ID", lg2::hex,
196 pel->id());
Matt Spinler19e72902020-01-24 11:05:20 -0600197 }
Andrew Geissler44fc3162020-07-09 09:21:31 -0500198
Vijay Lobod354a392021-06-01 16:21:02 -0500199 updateEventId(pel);
Matt Spinler28d6ae22022-03-18 11:18:27 -0500200 updateResolution(*pel);
Matt Spinler3387eac2023-07-06 14:56:02 -0500201 serializeLogEntry(obmcLogID);
Vijay Loboafb1b462021-07-21 23:29:13 -0500202 createPELEntry(obmcLogID);
Matt Spinlerdf5cb832022-07-12 12:47:26 -0500203
204 // Check if firmware should quiesce system due to error
205 checkPelAndQuiesce(pel);
Matt Spinler19e72902020-01-24 11:05:20 -0600206 }
207 else
208 {
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500209 lg2::error("Invalid PEL received from the host. BMC ID = {ID}", "ID",
210 obmcLogID);
Matt Spinler19e72902020-01-24 11:05:20 -0600211
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);
Matt Spinlerfe721892020-04-02 10:28:08 -0500228
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());
Matt Spinlerd8fb5ba2022-01-25 13:01:14 -0600235
236 // No need to keep around the openBMC event log entry
237 scheduleObmcLogDelete(obmcLogID);
Matt Spinler19e72902020-01-24 11:05:20 -0600238 }
239}
240
241void Manager::addESELPEL(const std::string& esel, uint32_t obmcLogID)
242{
243 std::vector<uint8_t> data;
244
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500245 lg2::debug("Adding PEL from ESEL. BMC ID = {ID}", "ID", obmcLogID);
Matt Spinler5f5352e2020-03-05 16:23:27 -0600246
Matt Spinler19e72902020-01-24 11:05:20 -0600247 try
248 {
249 data = std::move(eselToRawData(esel));
250 }
Patrick Williams66491c62021-10-06 12:23:37 -0500251 catch (const std::exception& e)
Matt Spinler19e72902020-01-24 11:05:20 -0600252 {
253 // Try to add it below anyway, so it follows the usual bad data path.
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500254 lg2::error("Problems converting ESEL string to a byte vector");
Matt Spinler19e72902020-01-24 11:05:20 -0600255 }
256
257 addPEL(data, obmcLogID);
258}
259
260std::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 {
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500273 lg2::error("ESEL data too short, length = {LEN}", "LEN", esel.size());
Matt Spinler19e72902020-01-24 11:05:20 -0600274 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 {
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500286 lg2::error("ESEL data too short, length = {LEN}", "LEN",
287 esel.size());
Matt Spinler19e72902020-01-24 11:05:20 -0600288 throw std::length_error("ESEL data too short");
289 }
290 }
291
292 return data;
293}
294
Matt Spinler4e8078c2019-07-09 13:22:32 -0500295void Manager::erase(uint32_t obmcLogID)
296{
Matt Spinler475e5742019-07-18 16:09:49 -0500297 Repository::LogID id{Repository::LogID::Obmc(obmcLogID)};
298
Vijay Loboafb1b462021-07-21 23:29:13 -0500299 auto path = std::string(OBJ_ENTRY) + '/' + std::to_string(obmcLogID);
300 _pelEntries.erase(path);
Matt Spinler475e5742019-07-18 16:09:49 -0500301 _repo.remove(id);
Matt Spinler4e8078c2019-07-09 13:22:32 -0500302}
303
Patrick Williamsd26fa3e2021-04-21 15:22:23 -0500304bool Manager::isDeleteProhibited(uint32_t /*obmcLogID*/)
Matt Spinler4e8078c2019-07-09 13:22:32 -0500305{
306 return false;
307}
308
Matt Spinler56ad2a02020-03-26 14:00:52 -0500309PelFFDC 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
Matt Spinler4e8078c2019-07-09 13:22:32 -0500341void 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,
Patrick Williamsd26fa3e2021-04-21 15:22:23 -0500345 const std::vector<std::string>& /*associations*/,
Matt Spinler56ad2a02020-03-26 14:00:52 -0500346 const FFDCEntries& ffdc)
Matt Spinler4e8078c2019-07-09 13:22:32 -0500347{
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800348 auto entry = _registry.lookup(message, rg::LookupType::name);
Matt Spinler30ddc9f2020-07-16 15:39:59 -0500349 auto pelFFDC = convertToPelFFDC(ffdc);
350 AdditionalData ad{additionalData};
Matt Spinler1d4c74a2019-12-16 14:40:21 -0600351 std::string msg;
Matt Spinler67456c22019-10-21 12:22:49 -0500352
Matt Spinler30ddc9f2020-07-16 15:39:59 -0500353 if (!entry)
Matt Spinler67456c22019-10-21 12:22:49 -0500354 {
Matt Spinler30ddc9f2020-07-16 15:39:59 -0500355 // 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.
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500362 lg2::error("Event not found in PEL message registry: {MSG}", "MSG",
363 message);
Matt Spinler30ddc9f2020-07-16 15:39:59 -0500364
365 entry = _registry.lookup(defaultLogMessage, rg::LookupType::name);
366 if (!entry)
367 {
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500368 lg2::error("Default event not found in PEL message registry");
Matt Spinler30ddc9f2020-07-16 15:39:59 -0500369 return;
370 }
371
372 ad.add(additional_data::error, message);
373 }
374
375 auto pel = std::make_unique<openpower::pels::PEL>(
Matt Spinler9d921092022-12-15 11:54:49 -0600376 *entry, obmcLogID, timestamp, severity, ad, pelFFDC, *_dataIface,
377 *_journal);
Matt Spinler30ddc9f2020-07-16 15:39:59 -0500378
379 _repo.add(pel);
380
381 if (_repo.sizeWarning())
382 {
383 scheduleRepoPrune();
384 }
385
386 auto src = pel->primarySRC();
387 if (src)
388 {
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500389 auto asciiString = (*src)->asciiString();
390 while (asciiString.back() == ' ')
Matt Spinler30ddc9f2020-07-16 15:39:59 -0500391 {
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500392 asciiString.pop_back();
Matt Spinler30ddc9f2020-07-16 15:39:59 -0500393 }
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500394 lg2::info("Created PEL {ID} (BMC ID {BMCID}) with SRC {SRC}", "ID",
395 lg2::hex, pel->id(), "BMCID", pel->obmcLogID(), "SRC",
396 asciiString);
Matt Spinler1d4c74a2019-12-16 14:40:21 -0600397 }
Matt Spinler1962e082020-08-05 13:44:53 -0500398
Sumit Kumar3e274432021-09-14 06:37:56 -0500399 // Check for severity 0x51 and update boot progress SRC
400 updateProgressSRC(pel);
401
Matt Spinler1962e082020-08-05 13:44:53 -0500402 // Activate any resulting service indicators if necessary
403 auto policy = service_indicators::getPolicy(*_dataIface);
404 policy->activate(*pel);
Andrew Geissler44fc3162020-07-09 09:21:31 -0500405
Matt Spinler8b81ec02022-07-12 13:25:37 -0500406 updateDBusSeverity(*pel);
Vijay Lobod354a392021-06-01 16:21:02 -0500407 updateEventId(pel);
Matt Spinler28d6ae22022-03-18 11:18:27 -0500408 updateResolution(*pel);
Matt Spinler3387eac2023-07-06 14:56:02 -0500409 serializeLogEntry(obmcLogID);
Vijay Loboafb1b462021-07-21 23:29:13 -0500410 createPELEntry(obmcLogID);
Matt Spinlerdf5cb832022-07-12 12:47:26 -0500411
412 // Check if firmware should quiesce system due to error
413 checkPelAndQuiesce(pel);
Matt Spinler4e8078c2019-07-09 13:22:32 -0500414}
415
Matt Spinlera34ab722019-12-16 10:39:32 -0600416sdbusplus::message::unix_fd Manager::getPEL(uint32_t pelID)
417{
418 Repository::LogID id{Repository::LogID::Pel(pelID)};
419 std::optional<int> fd;
420
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500421 lg2::debug("getPEL {ID}", "ID", lg2::hex, pelID);
Matt Spinler5f5352e2020-03-05 16:23:27 -0600422
Matt Spinlera34ab722019-12-16 10:39:32 -0600423 try
424 {
425 fd = _repo.getPELFD(id);
426 }
Patrick Williams66491c62021-10-06 12:23:37 -0500427 catch (const std::exception& e)
Matt Spinlera34ab722019-12-16 10:39:32 -0600428 {
429 throw common_error::InternalFailure();
430 }
431
432 if (!fd)
433 {
434 throw common_error::InvalidArgument();
435 }
436
Matt Spinler6b1a5c82020-01-07 08:48:53 -0600437 scheduleFDClose(*fd);
438
Matt Spinlera34ab722019-12-16 10:39:32 -0600439 return *fd;
440}
441
Matt Spinler6b1a5c82020-01-07 08:48:53 -0600442void Manager::scheduleFDClose(int fd)
443{
444 _fdCloserEventSource = std::make_unique<sdeventplus::source::Defer>(
Matt Spinlerff9cec22020-07-15 13:06:35 -0500445 _event, std::bind(std::mem_fn(&Manager::closeFD), this, fd,
446 std::placeholders::_1));
Matt Spinler6b1a5c82020-01-07 08:48:53 -0600447}
448
Patrick Williamsd26fa3e2021-04-21 15:22:23 -0500449void Manager::closeFD(int fd, sdeventplus::source::EventBase& /*source*/)
Matt Spinler6b1a5c82020-01-07 08:48:53 -0600450{
451 close(fd);
452 _fdCloserEventSource.reset();
453}
454
Matt Spinlera34ab722019-12-16 10:39:32 -0600455std::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
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500460 lg2::debug("getPELFromOBMCID {BMCID}", "BMCID", obmcLogID);
Matt Spinler5f5352e2020-03-05 16:23:27 -0600461
Matt Spinlera34ab722019-12-16 10:39:32 -0600462 try
463 {
464 data = _repo.getPELData(id);
465 }
Patrick Williams66491c62021-10-06 12:23:37 -0500466 catch (const std::exception& e)
Matt Spinlera34ab722019-12-16 10:39:32 -0600467 {
468 throw common_error::InternalFailure();
469 }
470
471 if (!data)
472 {
473 throw common_error::InvalidArgument();
474 }
475
476 return *data;
477}
478
479void Manager::hostAck(uint32_t pelID)
480{
481 Repository::LogID id{Repository::LogID::Pel(pelID)};
482
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500483 lg2::debug("HostHack {ID}", "ID", lg2::hex, pelID);
Matt Spinler5f5352e2020-03-05 16:23:27 -0600484
Matt Spinlera34ab722019-12-16 10:39:32 -0600485 if (!_repo.hasPEL(id))
486 {
487 throw common_error::InvalidArgument();
488 }
489
490 if (_hostNotifier)
491 {
492 _hostNotifier->ackPEL(pelID);
493 }
494}
495
496void Manager::hostReject(uint32_t pelID, RejectionReason reason)
497{
498 Repository::LogID id{Repository::LogID::Pel(pelID)};
499
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500500 lg2::debug("HostReject {ID}, reason = {REASON}", "ID", lg2::hex, pelID,
501 "REASON", reason);
Matt Spinler5f5352e2020-03-05 16:23:27 -0600502
Matt Spinlera34ab722019-12-16 10:39:32 -0600503 if (!_repo.hasPEL(id))
504 {
505 throw common_error::InvalidArgument();
506 }
507
Matt Spinler05c2c6c2019-12-18 14:02:09 -0600508 if (reason == RejectionReason::BadPEL)
Matt Spinlera34ab722019-12-16 10:39:32 -0600509 {
Matt Spinler05c2c6c2019-12-18 14:02:09 -0600510 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)
Matt Spinlera34ab722019-12-16 10:39:32 -0600515 {
516 _hostNotifier->setBadPEL(pelID);
517 }
Matt Spinler05c2c6c2019-12-18 14:02:09 -0600518 }
519 else if ((reason == RejectionReason::HostFull) && _hostNotifier)
520 {
521 _hostNotifier->setHostFull(pelID);
Matt Spinlera34ab722019-12-16 10:39:32 -0600522 }
523}
524
Matt Spinler7e727a32020-07-07 15:00:17 -0500525void Manager::scheduleRepoPrune()
526{
Matt Spinler7e727a32020-07-07 15:00:17 -0500527 _repoPrunerEventSource = std::make_unique<sdeventplus::source::Defer>(
Matt Spinlerff9cec22020-07-15 13:06:35 -0500528 _event, std::bind(std::mem_fn(&Manager::pruneRepo), this,
529 std::placeholders::_1));
Matt Spinler7e727a32020-07-07 15:00:17 -0500530}
531
Patrick Williamsd26fa3e2021-04-21 15:22:23 -0500532void Manager::pruneRepo(sdeventplus::source::EventBase& /*source*/)
Matt Spinler7e727a32020-07-07 15:00:17 -0500533{
Sumit Kumar027bf282022-01-24 11:25:19 -0600534 auto idsWithHwIsoEntry = _dataIface->getLogIDWithHwIsolation();
535
536 auto idsToDelete = _repo.prune(idsWithHwIsoEntry);
Matt Spinler7e727a32020-07-07 15:00:17 -0500537
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
Matt Spinlerff9cec22020-07-15 13:06:35 -0500545void Manager::setupPELDeleteWatch()
546{
547 _pelFileDeleteFD = inotify_init1(IN_NONBLOCK);
548 if (-1 == _pelFileDeleteFD)
549 {
550 auto e = errno;
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500551 lg2::error("inotify_init1 failed with errno {ERRNO}", "ERRNO", e);
Matt Spinlerff9cec22020-07-15 13:06:35 -0500552 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;
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500560 lg2::error("inotify_add_watch failed with errno {ERRNO}", "ERRNO", e);
Matt Spinlerff9cec22020-07-15 13:06:35 -0500561 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
Patrick Williamsd26fa3e2021-04-21 15:22:23 -0500571void Manager::pelFileDeleted(sdeventplus::source::IO& /*io*/, int /*fd*/,
Matt Spinlerff9cec22020-07-15 13:06:35 -0500572 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.
Matt Spinler9d59d582021-05-19 07:57:10 -0600583 std::array<uint8_t, 2000> data{};
Matt Spinlerff9cec22020-07-15 13:06:35 -0500584 auto bytesRead = read(_pelFileDeleteFD, data.data(), data.size());
585 if (bytesRead < 0)
586 {
587 auto e = errno;
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500588 lg2::error("Failed reading data from inotify event, errno = {ERRNO}",
589 "ERRNO", e);
Matt Spinlerff9cec22020-07-15 13:06:35 -0500590 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 {
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500621 lg2::info("Could not find PEL ID from its filename {NAME}",
622 "NAME", filename);
Matt Spinlerff9cec22020-07-15 13:06:35 -0500623 }
624 }
625 }
626
627 offset += offsetof(inotify_event, name) + event->len;
628 }
629}
Matt Spinler9cc30072020-09-16 15:39:34 -0500630
631std::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<
Willy Tu6ddbf692023-09-05 10:54:16 -0700635 sdbusplus::server::xyz::openbmc_project::logging::Create::FFDCFormat,
Matt Spinler9cc30072020-09-16 15:39:34 -0500636 uint8_t, uint8_t, sdbusplus::message::unix_fd>>
637 fFDC)
638{
Matt Spinler44893cc2020-08-26 11:34:17 -0500639 _logManager.createWithFFDC(message, severity, additionalData, fFDC);
640
641 return {_logManager.lastEntryID(), _repo.lastPelID()};
Matt Spinler9cc30072020-09-16 15:39:34 -0500642}
643
Matt Spinler8bd4ca42022-04-01 16:06:06 -0500644std::string Manager::getPELJSON(uint32_t obmcLogID)
Matt Spinleraa85a072022-03-23 11:26:41 -0500645{
Matt Spinler8bd4ca42022-04-01 16:06:06 -0500646 // Throws InvalidArgument if not found
647 auto pelID = getPELIdFromBMCLogId(obmcLogID);
648
Jayanth Othayoth1aa90d42023-09-13 04:25:45 -0500649 auto cmd = std::format("/usr/bin/peltool -i {:#x}", pelID);
Matt Spinler8bd4ca42022-04-01 16:06:06 -0500650
651 FILE* pipe = popen(cmd.c_str(), "r");
652 if (!pipe)
653 {
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500654 lg2::error("Error running cmd: {CMD}", "CMD", cmd);
Matt Spinler8bd4ca42022-04-01 16:06:06 -0500655 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 {
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500668 lg2::error("Error running cmd: {CMD}, rc = {RC}", "CMD", cmd, "RC", rc);
Matt Spinler8bd4ca42022-04-01 16:06:06 -0500669 throw common_error::InternalFailure();
670 }
671
672 return output;
Matt Spinleraa85a072022-03-23 11:26:41 -0500673}
674
Andrew Geissler44fc3162020-07-09 09:21:31 -0500675void Manager::checkPelAndQuiesce(std::unique_ptr<openpower::pels::PEL>& pel)
676{
Matt Spinlerb2abc042021-05-17 15:32:50 -0600677 if ((pel->userHeader().severity() ==
678 static_cast<uint8_t>(SeverityType::nonError)) ||
679 (pel->userHeader().severity() ==
680 static_cast<uint8_t>(SeverityType::recovered)))
Andrew Geissler44fc3162020-07-09 09:21:31 -0500681 {
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500682 lg2::debug(
Matt Spinlerb2abc042021-05-17 15:32:50 -0600683 "PEL severity informational or recovered. no quiesce needed");
Andrew Geissler44fc3162020-07-09 09:21:31 -0500684 return;
685 }
686 if (!_logManager.isQuiesceOnErrorEnabled())
687 {
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500688 lg2::debug("QuiesceOnHwError not enabled, no quiesce needed");
Andrew Geissler44fc3162020-07-09 09:21:31 -0500689 return;
690 }
691
Matt Spinler845c6242022-03-01 16:45:08 -0600692 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
Andrew Geissler44fc3162020-07-09 09:21:31 -0500702 // Now check if it has any type of callout
Andrew Geisslerf8e750d2022-01-14 14:56:13 -0600703 if (pel->isHwCalloutPresent())
Andrew Geissler44fc3162020-07-09 09:21:31 -0500704 {
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500705 lg2::info(
Matt Spinlerb2abc042021-05-17 15:32:50 -0600706 "QuiesceOnHwError enabled, PEL severity not nonError or recovered, "
707 "and callout is present");
Andrew Geissler44fc3162020-07-09 09:21:31 -0500708
709 _logManager.quiesceOnError(pel->obmcLogID());
710 }
711}
712
Vijay Lobod354a392021-06-01 16:21:02 -0500713std::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 }
Matt Spinler0003af12022-06-08 10:46:17 -0500735 return sanitizeFieldForDBus(str);
Vijay Lobod354a392021-06-01 16:21:02 -0500736}
737
738void 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 {
Matt Spinlerb25e8a32023-06-07 16:05:36 -0500745 entryN->second->eventId(eventIdStr, true);
Vijay Lobod354a392021-06-01 16:21:02 -0500746 }
747}
748
Matt Spinler0003af12022-06-08 10:46:17 -0500749std::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
Vijay Lobo593a4c62021-06-16 14:25:26 -0500760std::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())
Patrick Williams2544b412022-10-04 08:41:06 -0500781 resolution += "Location Code: " + entry->locationCode() +
782 ", ";
Vijay Lobo593a4c62021-06-16 14:25:26 -0500783 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 }
Matt Spinler0003af12022-06-08 10:46:17 -0500823 return sanitizeFieldForDBus(resolution);
Vijay Lobo593a4c62021-06-16 14:25:26 -0500824}
825
Matt Spinler28d6ae22022-03-18 11:18:27 -0500826bool Manager::updateResolution(const openpower::pels::PEL& pel)
Vijay Lobo593a4c62021-06-16 14:25:26 -0500827{
Matt Spinler28d6ae22022-03-18 11:18:27 -0500828 std::string callouts = getResolution(pel);
829 auto entryN = _logManager.entries.find(pel.obmcLogID());
Vijay Lobo593a4c62021-06-16 14:25:26 -0500830 if (entryN != _logManager.entries.end())
831 {
Matt Spinler734ed2b2022-01-21 09:31:46 -0600832 entryN->second->resolution(callouts, true);
Vijay Lobo593a4c62021-06-16 14:25:26 -0500833 }
Matt Spinler28d6ae22022-03-18 11:18:27 -0500834
835 return false;
Vijay Lobo593a4c62021-06-16 14:25:26 -0500836}
837
Matt Spinler3387eac2023-07-06 14:56:02 -0500838void 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
Matt Spinler8b81ec02022-07-12 13:25:37 -0500847void 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 {
Patrick Williams2544b412022-10-04 08:41:06 -0500863 auto newSeverity = fixupLogSeverity(entryN->second->severity(),
864 sevType);
Matt Spinler8b81ec02022-07-12 13:25:37 -0500865 if (newSeverity)
866 {
Matt Spinlerfbdfc762023-06-30 15:15:44 -0500867 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));
Matt Spinler8b81ec02022-07-12 13:25:37 -0500872
873 entryN->second->severity(*newSeverity, true);
874 }
875 }
876}
877
Adriana Kobylake7d271a2020-12-07 14:32:44 -0600878void 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 {
Matt Spinler734ed2b2022-01-21 09:31:46 -0600887 entry->second->path(attr.path, true);
Adriana Kobylake7d271a2020-12-07 14:32:44 -0600888 }
889 }
890}
891
Vijay Lobocbc93a42021-05-20 19:04:07 -0500892void 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 {
Lakshmi Yadlapati7a3ede52022-11-18 13:26:17 -0600901 if (attr.actionFlags.test(callHomeFlagBit))
902 {
Matt Spinlerb25e8a32023-06-07 16:05:36 -0500903 entry->second->serviceProviderNotify(Entry::Notify::Notify,
904 true);
Lakshmi Yadlapati7a3ede52022-11-18 13:26:17 -0600905 }
906 else
907 {
Matt Spinlerb25e8a32023-06-07 16:05:36 -0500908 entry->second->serviceProviderNotify(Entry::Notify::Inhibit,
909 true);
Lakshmi Yadlapati7a3ede52022-11-18 13:26:17 -0600910 }
Vijay Lobocbc93a42021-05-20 19:04:07 -0500911 }
912 }
913}
914
Matt Spinler734ed2b2022-01-21 09:31:46 -0600915void Manager::createPELEntry(uint32_t obmcLogID, bool skipIaSignal)
Vijay Loboafb1b462021-07-21 23:29:13 -0500916{
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();
Vijay Lobob2e541e2021-08-31 23:12:47 -0500923
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);
Vijay Loboafb1b462021-07-21 23:29:13 -0500936 varData.emplace(
937 std::string("Subsystem"),
938 pv::getValue(attr.subsystem, pel_values::subsystemValues));
Vijay Lobo2fb10212021-08-22 23:24:16 -0500939
940 varData.emplace(
941 std::string("ManagementSystemAck"),
942 (attr.hmcState == TransmissionState::acked ? true : false));
943
Matt Spinler8e65f4e2023-05-02 13:40:08 -0500944 varData.emplace("PlatformLogID", attr.plid);
945 varData.emplace("Deconfig", attr.deconfig);
946 varData.emplace("Guard", attr.guard);
947 varData.emplace("Timestamp", attr.creationTime);
948
Vijay Loboafb1b462021-07-21 23:29:13 -0500949 // 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
Vijay Lobo2fb10212021-08-22 23:24:16 -0500952 auto pelEntry = std::make_unique<PELEntry>(_logManager.getBus(), path,
953 varData, obmcLogID, &_repo);
Matt Spinler734ed2b2022-01-21 09:31:46 -0600954 if (!skipIaSignal)
955 {
956 pelEntry->emit_added();
957 }
Vijay Loboafb1b462021-07-21 23:29:13 -0500958 _pelEntries.emplace(std::move(path), std::move(pelEntry));
959 }
960}
961
Ramesh Iyyarf4203c42021-06-24 06:09:23 -0500962uint32_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
Ramesh Iyyar530efbf2021-06-24 06:22:22 -0500975uint32_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
Sumit Kumar3e274432021-09-14 06:37:56 -0500988void 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 {
Patrick Williams2544b412022-10-04 08:41:06 -05001004 srcRefCode |= (static_cast<uint64_t>(asciiSRC[40 + i])
1005 << (8 * i));
Sumit Kumar3e274432021-09-14 06:37:56 -05001006 }
1007
1008 try
1009 {
1010 _dataIface->createProgressSRC(srcRefCode, asciiSRC);
1011 }
Matt Spinler87f39242023-05-01 11:36:18 -05001012 catch (const std::exception&)
Sumit Kumar3e274432021-09-14 06:37:56 -05001013 {
1014 // Exception - may be no boot progress interface on dbus
1015 }
1016 }
1017 }
1018}
1019
Matt Spinlerd8fb5ba2022-01-25 13:01:14 -06001020void 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
1027void Manager::deleteObmcLog(sdeventplus::source::EventBase&, uint32_t obmcLogID)
1028{
Matt Spinlerfbdfc762023-06-30 15:15:44 -05001029 lg2::info("Removing event log with no PEL: {BMCID}", "BMCID", obmcLogID);
Matt Spinlerd8fb5ba2022-01-25 13:01:14 -06001030 _logManager.erase(obmcLogID);
1031 _obmcLogDeleteEventSource.reset();
1032}
1033
Matt Spinler0dd22c82023-05-04 15:28:12 -05001034bool 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
Matt Spinlerfbdfc762023-06-30 15:15:44 -05001073 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);
Matt Spinler0dd22c82023-05-04 15:28:12 -05001077 (*src)->clearErrorStatusFlag(SRC::ErrorStatusFlags::deconfigured);
1078 return true;
1079 }
1080 return false;
1081}
1082
1083void 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 {
Matt Spinler1cb59f72023-07-20 09:49:50 -05001097 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 }
Matt Spinler0dd22c82023-05-04 15:28:12 -05001117 }
1118 }
1119}
1120
Matt Spinler4e8078c2019-07-09 13:22:32 -05001121} // namespace pels
1122} // namespace openpower