blob: a40305d95bb9ec49c4ca9d9325b218d4ac355046 [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 Spinler05c2c6c2019-12-18 14:02:09 -060019#include "json_utils.hpp"
Matt Spinler89fa0822019-07-17 13:54:30 -050020#include "pel.hpp"
Vijay Lobo2fb10212021-08-22 23:24:16 -050021#include "pel_entry.hpp"
Matt Spinler1962e082020-08-05 13:44:53 -050022#include "service_indicators.hpp"
Matt Spinler89fa0822019-07-17 13:54:30 -050023
Matt Spinler22421b92020-07-17 09:41:08 -050024#include <fmt/format.h>
Matt Spinlerff9cec22020-07-15 13:06:35 -050025#include <sys/inotify.h>
Matt Spinler6b1a5c82020-01-07 08:48:53 -060026#include <unistd.h>
27
Matt Spinler89fa0822019-07-17 13:54:30 -050028#include <filesystem>
29#include <fstream>
Matt Spinlera34ab722019-12-16 10:39:32 -060030#include <xyz/openbmc_project/Common/error.hpp>
Matt Spinler56ad2a02020-03-26 14:00:52 -050031#include <xyz/openbmc_project/Logging/Create/server.hpp>
Matt Spinler4e8078c2019-07-09 13:22:32 -050032
33namespace openpower
34{
35namespace pels
36{
37
38using namespace phosphor::logging;
Matt Spinler89fa0822019-07-17 13:54:30 -050039namespace fs = std::filesystem;
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +080040namespace rg = openpower::pels::message;
Matt Spinler4e8078c2019-07-09 13:22:32 -050041
Matt Spinlera34ab722019-12-16 10:39:32 -060042namespace common_error = sdbusplus::xyz::openbmc_project::Common::Error;
43
Matt Spinler56ad2a02020-03-26 14:00:52 -050044using Create = sdbusplus::xyz::openbmc_project::Logging::server::Create;
45
Matt Spinler4e8078c2019-07-09 13:22:32 -050046namespace additional_data
47{
48constexpr auto rawPEL = "RAWPEL";
Matt Spinler19e72902020-01-24 11:05:20 -060049constexpr auto esel = "ESEL";
Matt Spinler30ddc9f2020-07-16 15:39:59 -050050constexpr auto error = "ERROR_NAME";
Matt Spinler19e72902020-01-24 11:05:20 -060051} // namespace additional_data
Matt Spinler4e8078c2019-07-09 13:22:32 -050052
Matt Spinler30ddc9f2020-07-16 15:39:59 -050053constexpr auto defaultLogMessage = "xyz.openbmc_project.Logging.Error.Default";
54
Matt Spinlerff9cec22020-07-15 13:06:35 -050055Manager::~Manager()
56{
57 if (_pelFileDeleteFD != -1)
58 {
59 if (_pelFileDeleteWatchFD != -1)
60 {
61 inotify_rm_watch(_pelFileDeleteFD, _pelFileDeleteWatchFD);
62 }
63 close(_pelFileDeleteFD);
64 }
65}
66
Matt Spinler4e8078c2019-07-09 13:22:32 -050067void Manager::create(const std::string& message, uint32_t obmcLogID,
68 uint64_t timestamp, Entry::Level severity,
69 const std::vector<std::string>& additionalData,
Matt Spinler56ad2a02020-03-26 14:00:52 -050070 const std::vector<std::string>& associations,
71 const FFDCEntries& ffdc)
Matt Spinler4e8078c2019-07-09 13:22:32 -050072{
73 AdditionalData ad{additionalData};
74
Matt Spinler19e72902020-01-24 11:05:20 -060075 // If a PEL was passed in via a filename or in an ESEL,
76 // use that. Otherwise, create one.
Matt Spinler4e8078c2019-07-09 13:22:32 -050077 auto rawPelPath = ad.getValue(additional_data::rawPEL);
78 if (rawPelPath)
79 {
80 addRawPEL(*rawPelPath, obmcLogID);
81 }
82 else
83 {
Matt Spinler19e72902020-01-24 11:05:20 -060084 auto esel = ad.getValue(additional_data::esel);
85 if (esel)
86 {
87 addESELPEL(*esel, obmcLogID);
88 }
89 else
90 {
91 createPEL(message, obmcLogID, timestamp, severity, additionalData,
Matt Spinler56ad2a02020-03-26 14:00:52 -050092 associations, ffdc);
Matt Spinler19e72902020-01-24 11:05:20 -060093 }
Matt Spinler4e8078c2019-07-09 13:22:32 -050094 }
Adriana Kobylake7d271a2020-12-07 14:32:44 -060095
96 setEntryPath(obmcLogID);
Vijay Lobocbc93a42021-05-20 19:04:07 -050097 setServiceProviderNotifyFlag(obmcLogID);
Matt Spinler4e8078c2019-07-09 13:22:32 -050098}
99
100void Manager::addRawPEL(const std::string& rawPelPath, uint32_t obmcLogID)
101{
Matt Spinler89fa0822019-07-17 13:54:30 -0500102 if (fs::exists(rawPelPath))
103 {
104 std::ifstream file(rawPelPath, std::ios::in | std::ios::binary);
105
106 auto data = std::vector<uint8_t>(std::istreambuf_iterator<char>(file),
107 std::istreambuf_iterator<char>());
108 if (file.fail())
109 {
110 log<level::ERR>("Filesystem error reading a raw PEL",
111 entry("PELFILE=%s", rawPelPath.c_str()),
112 entry("OBMCLOGID=%d", obmcLogID));
113 // TODO, Decide what to do here. Maybe nothing.
114 return;
115 }
116
117 file.close();
118
Matt Spinler19e72902020-01-24 11:05:20 -0600119 addPEL(data, obmcLogID);
Matt Spinler67416922021-07-19 12:34:57 -0600120
121 std::error_code ec;
122 fs::remove(rawPelPath, ec);
Matt Spinler89fa0822019-07-17 13:54:30 -0500123 }
124 else
125 {
126 log<level::ERR>("Raw PEL file from BMC event log does not exist",
127 entry("PELFILE=%s", (rawPelPath).c_str()),
128 entry("OBMCLOGID=%d", obmcLogID));
129 }
Matt Spinler4e8078c2019-07-09 13:22:32 -0500130}
131
Matt Spinler19e72902020-01-24 11:05:20 -0600132void Manager::addPEL(std::vector<uint8_t>& pelData, uint32_t obmcLogID)
133{
Matt Spinler19e72902020-01-24 11:05:20 -0600134 auto pel = std::make_unique<openpower::pels::PEL>(pelData, obmcLogID);
135 if (pel->valid())
136 {
Sumit Kumar8ec41562021-10-29 05:39:37 -0500137 // PELs created by others still need this field set by us.
138 pel->setCommitTime();
139
Sumit Kumara1e40842021-06-23 09:52:25 -0500140 // Assign Id other than to Hostbot PEL
141 if ((pel->privateHeader()).creatorID() !=
142 static_cast<uint8_t>(CreatorID::hostboot))
143 {
144 pel->assignID();
145 }
Sumit Kumar2ccdcef2021-07-31 10:04:58 -0500146 else
147 {
148 const Repository::LogID id{Repository::LogID::Pel(pel->id())};
149 auto result = _repo.hasPEL(id);
150 if (result)
151 {
152 log<level::WARNING>(
153 fmt::format("Duplicate HostBoot PEL Id {:#X} found; "
154 "moving it to archive folder",
155 pel->id())
156 .c_str());
157
158 _repo.archivePEL(*pel);
Matt Spinlerd8fb5ba2022-01-25 13:01:14 -0600159
160 // No need to keep around the openBMC event log entry
161 scheduleObmcLogDelete(obmcLogID);
Sumit Kumar2ccdcef2021-07-31 10:04:58 -0500162 return;
163 }
164 }
Sumit Kumara1e40842021-06-23 09:52:25 -0500165
Sumit Kumar3160a542021-04-26 08:07:04 -0500166 // Update System Info to Extended User Data
167 pel->updateSysInfoInExtendedUserDataSection(*_dataIface);
168
Sumit Kumar3e274432021-09-14 06:37:56 -0500169 // Check for severity 0x51 and update boot progress SRC
170 updateProgressSRC(pel);
171
Matt Spinler19e72902020-01-24 11:05:20 -0600172 try
173 {
Matt Spinlerd0ab1cf2021-02-10 13:26:18 -0600174 log<level::DEBUG>(
Matt Spinler6321ba32020-07-17 09:58:19 -0500175 fmt::format("Adding external PEL {:#x} (BMC ID {}) to repo",
176 pel->id(), obmcLogID)
177 .c_str());
Matt Spinler5f5352e2020-03-05 16:23:27 -0600178
Matt Spinler19e72902020-01-24 11:05:20 -0600179 _repo.add(pel);
Matt Spinler7e727a32020-07-07 15:00:17 -0500180
181 if (_repo.sizeWarning())
182 {
183 scheduleRepoPrune();
184 }
Matt Spinler1962e082020-08-05 13:44:53 -0500185
186 // Activate any resulting service indicators if necessary
187 auto policy = service_indicators::getPolicy(*_dataIface);
188 policy->activate(*pel);
Matt Spinler19e72902020-01-24 11:05:20 -0600189 }
Patrick Williams66491c62021-10-06 12:23:37 -0500190 catch (const std::exception& e)
Matt Spinler19e72902020-01-24 11:05:20 -0600191 {
192 // Probably a full or r/o filesystem, not much we can do.
193 log<level::ERR>("Unable to add PEL to Repository",
194 entry("PEL_ID=0x%X", pel->id()));
195 }
Andrew Geissler44fc3162020-07-09 09:21:31 -0500196
197 // Check if firmware should quiesce system due to error
198 checkPelAndQuiesce(pel);
Vijay Lobod354a392021-06-01 16:21:02 -0500199 updateEventId(pel);
Vijay Lobo593a4c62021-06-16 14:25:26 -0500200 updateResolution(pel);
Vijay Loboafb1b462021-07-21 23:29:13 -0500201 createPELEntry(obmcLogID);
Matt Spinler19e72902020-01-24 11:05:20 -0600202 }
203 else
204 {
205 log<level::ERR>("Invalid PEL received from the host",
206 entry("OBMCLOGID=%d", obmcLogID));
207
208 AdditionalData ad;
209 ad.add("PLID", getNumberString("0x%08X", pel->plid()));
210 ad.add("OBMC_LOG_ID", std::to_string(obmcLogID));
211 ad.add("PEL_SIZE", std::to_string(pelData.size()));
212
213 std::string asciiString;
214 auto src = pel->primarySRC();
215 if (src)
216 {
217 asciiString = (*src)->asciiString();
218 }
219
220 ad.add("SRC", asciiString);
221
222 _eventLogger.log("org.open_power.Logging.Error.BadHostPEL",
223 Entry::Level::Error, ad);
Matt Spinlerfe721892020-04-02 10:28:08 -0500224
225 // Save it to a file for debug in the lab. Just keep the latest.
226 // Not adding it to the PEL because it could already be max size
227 // and don't want to truncate an already invalid PEL.
228 std::ofstream pelFile{getPELRepoPath() / "badPEL"};
229 pelFile.write(reinterpret_cast<const char*>(pelData.data()),
230 pelData.size());
Matt Spinlerd8fb5ba2022-01-25 13:01:14 -0600231
232 // No need to keep around the openBMC event log entry
233 scheduleObmcLogDelete(obmcLogID);
Matt Spinler19e72902020-01-24 11:05:20 -0600234 }
235}
236
237void Manager::addESELPEL(const std::string& esel, uint32_t obmcLogID)
238{
239 std::vector<uint8_t> data;
240
Matt Spinler5f5352e2020-03-05 16:23:27 -0600241 log<level::DEBUG>("Adding PEL from ESEL",
242 entry("OBMC_LOG_ID=%d", obmcLogID));
243
Matt Spinler19e72902020-01-24 11:05:20 -0600244 try
245 {
246 data = std::move(eselToRawData(esel));
247 }
Patrick Williams66491c62021-10-06 12:23:37 -0500248 catch (const std::exception& e)
Matt Spinler19e72902020-01-24 11:05:20 -0600249 {
250 // Try to add it below anyway, so it follows the usual bad data path.
251 log<level::ERR>("Problems converting ESEL string to a byte vector");
252 }
253
254 addPEL(data, obmcLogID);
255}
256
257std::vector<uint8_t> Manager::eselToRawData(const std::string& esel)
258{
259 std::vector<uint8_t> data;
260 std::string byteString;
261
262 // As the eSEL string looks like: "50 48 00 ab ..." there are 3
263 // characters per raw byte, and since the actual PEL data starts
264 // at the 16th byte, the code will grab the PEL data starting at
265 // offset 48 in the string.
266 static constexpr size_t pelStart = 16 * 3;
267
268 if (esel.size() <= pelStart)
269 {
270 log<level::ERR>("ESEL data too short",
271 entry("ESEL_SIZE=%d", esel.size()));
272
273 throw std::length_error("ESEL data too short");
274 }
275
276 for (size_t i = pelStart; i < esel.size(); i += 3)
277 {
278 if (i + 1 < esel.size())
279 {
280 byteString = esel.substr(i, 2);
281 data.push_back(std::stoi(byteString, nullptr, 16));
282 }
283 else
284 {
285 log<level::ERR>("ESEL data too short",
286 entry("ESEL_SIZE=%d", esel.size()));
287 throw std::length_error("ESEL data too short");
288 }
289 }
290
291 return data;
292}
293
Matt Spinler4e8078c2019-07-09 13:22:32 -0500294void Manager::erase(uint32_t obmcLogID)
295{
Matt Spinler475e5742019-07-18 16:09:49 -0500296 Repository::LogID id{Repository::LogID::Obmc(obmcLogID)};
297
Vijay Loboafb1b462021-07-21 23:29:13 -0500298 auto path = std::string(OBJ_ENTRY) + '/' + std::to_string(obmcLogID);
299 _pelEntries.erase(path);
Matt Spinler475e5742019-07-18 16:09:49 -0500300 _repo.remove(id);
Matt Spinler4e8078c2019-07-09 13:22:32 -0500301}
302
Patrick Williamsd26fa3e2021-04-21 15:22:23 -0500303bool Manager::isDeleteProhibited(uint32_t /*obmcLogID*/)
Matt Spinler4e8078c2019-07-09 13:22:32 -0500304{
305 return false;
306}
307
Matt Spinler56ad2a02020-03-26 14:00:52 -0500308PelFFDC Manager::convertToPelFFDC(const FFDCEntries& ffdc)
309{
310 PelFFDC pelFFDC;
311
312 std::for_each(ffdc.begin(), ffdc.end(), [&pelFFDC](const auto& f) {
313 PelFFDCfile pf;
314 pf.subType = std::get<ffdcSubtypePos>(f);
315 pf.version = std::get<ffdcVersionPos>(f);
316 pf.fd = std::get<ffdcFDPos>(f);
317
318 switch (std::get<ffdcFormatPos>(f))
319 {
320 case Create::FFDCFormat::JSON:
321 pf.format = UserDataFormat::json;
322 break;
323 case Create::FFDCFormat::CBOR:
324 pf.format = UserDataFormat::cbor;
325 break;
326 case Create::FFDCFormat::Text:
327 pf.format = UserDataFormat::text;
328 break;
329 case Create::FFDCFormat::Custom:
330 pf.format = UserDataFormat::custom;
331 break;
332 }
333
334 pelFFDC.push_back(pf);
335 });
336
337 return pelFFDC;
338}
339
Matt Spinler4e8078c2019-07-09 13:22:32 -0500340void Manager::createPEL(const std::string& message, uint32_t obmcLogID,
341 uint64_t timestamp,
342 phosphor::logging::Entry::Level severity,
343 const std::vector<std::string>& additionalData,
Patrick Williamsd26fa3e2021-04-21 15:22:23 -0500344 const std::vector<std::string>& /*associations*/,
Matt Spinler56ad2a02020-03-26 14:00:52 -0500345 const FFDCEntries& ffdc)
Matt Spinler4e8078c2019-07-09 13:22:32 -0500346{
Harisuddin Mohamed Isa0f717e12020-01-15 20:05:33 +0800347 auto entry = _registry.lookup(message, rg::LookupType::name);
Matt Spinler30ddc9f2020-07-16 15:39:59 -0500348 auto pelFFDC = convertToPelFFDC(ffdc);
349 AdditionalData ad{additionalData};
Matt Spinler1d4c74a2019-12-16 14:40:21 -0600350 std::string msg;
Matt Spinler67456c22019-10-21 12:22:49 -0500351
Matt Spinler30ddc9f2020-07-16 15:39:59 -0500352 if (!entry)
Matt Spinler67456c22019-10-21 12:22:49 -0500353 {
Matt Spinler30ddc9f2020-07-16 15:39:59 -0500354 // Instead, get the default entry that means there is no
355 // other matching entry. This error will still use the
356 // AdditionalData values of the original error, and this
357 // code will add the error message value that wasn't found
358 // to this AD. This way, there will at least be a PEL,
359 // possibly with callouts, to allow users to debug the
360 // issue that caused the error even without its own PEL.
Matt Spinler1d4c74a2019-12-16 14:40:21 -0600361 msg = "Event not found in PEL message registry: " + message;
362 log<level::INFO>(msg.c_str());
Matt Spinler30ddc9f2020-07-16 15:39:59 -0500363
364 entry = _registry.lookup(defaultLogMessage, rg::LookupType::name);
365 if (!entry)
366 {
367 log<level::ERR>("Default event not found in PEL message registry");
368 return;
369 }
370
371 ad.add(additional_data::error, message);
372 }
373
374 auto pel = std::make_unique<openpower::pels::PEL>(
375 *entry, obmcLogID, timestamp, severity, ad, pelFFDC, *_dataIface);
376
377 _repo.add(pel);
378
379 if (_repo.sizeWarning())
380 {
381 scheduleRepoPrune();
382 }
383
384 auto src = pel->primarySRC();
385 if (src)
386 {
Matt Spinler22421b92020-07-17 09:41:08 -0500387 auto msg =
388 fmt::format("Created PEL {:#x} (BMC ID {}) with SRC {}", pel->id(),
389 pel->obmcLogID(), (*src)->asciiString());
Matt Spinler30ddc9f2020-07-16 15:39:59 -0500390 while (msg.back() == ' ')
391 {
392 msg.pop_back();
393 }
394 log<level::INFO>(msg.c_str());
Matt Spinler1d4c74a2019-12-16 14:40:21 -0600395 }
Matt Spinler1962e082020-08-05 13:44:53 -0500396
Sumit Kumar3e274432021-09-14 06:37:56 -0500397 // Check for severity 0x51 and update boot progress SRC
398 updateProgressSRC(pel);
399
Matt Spinler1962e082020-08-05 13:44:53 -0500400 // Activate any resulting service indicators if necessary
401 auto policy = service_indicators::getPolicy(*_dataIface);
402 policy->activate(*pel);
Andrew Geissler44fc3162020-07-09 09:21:31 -0500403
404 // Check if firmware should quiesce system due to error
405 checkPelAndQuiesce(pel);
Vijay Lobod354a392021-06-01 16:21:02 -0500406 updateEventId(pel);
Vijay Lobo593a4c62021-06-16 14:25:26 -0500407 updateResolution(pel);
Vijay Loboafb1b462021-07-21 23:29:13 -0500408 createPELEntry(obmcLogID);
Matt Spinler4e8078c2019-07-09 13:22:32 -0500409}
410
Matt Spinlera34ab722019-12-16 10:39:32 -0600411sdbusplus::message::unix_fd Manager::getPEL(uint32_t pelID)
412{
413 Repository::LogID id{Repository::LogID::Pel(pelID)};
414 std::optional<int> fd;
415
Matt Spinler5f5352e2020-03-05 16:23:27 -0600416 log<level::DEBUG>("getPEL", entry("PEL_ID=0x%X", pelID));
417
Matt Spinlera34ab722019-12-16 10:39:32 -0600418 try
419 {
420 fd = _repo.getPELFD(id);
421 }
Patrick Williams66491c62021-10-06 12:23:37 -0500422 catch (const std::exception& e)
Matt Spinlera34ab722019-12-16 10:39:32 -0600423 {
424 throw common_error::InternalFailure();
425 }
426
427 if (!fd)
428 {
429 throw common_error::InvalidArgument();
430 }
431
Matt Spinler6b1a5c82020-01-07 08:48:53 -0600432 scheduleFDClose(*fd);
433
Matt Spinlera34ab722019-12-16 10:39:32 -0600434 return *fd;
435}
436
Matt Spinler6b1a5c82020-01-07 08:48:53 -0600437void Manager::scheduleFDClose(int fd)
438{
439 _fdCloserEventSource = std::make_unique<sdeventplus::source::Defer>(
Matt Spinlerff9cec22020-07-15 13:06:35 -0500440 _event, std::bind(std::mem_fn(&Manager::closeFD), this, fd,
441 std::placeholders::_1));
Matt Spinler6b1a5c82020-01-07 08:48:53 -0600442}
443
Patrick Williamsd26fa3e2021-04-21 15:22:23 -0500444void Manager::closeFD(int fd, sdeventplus::source::EventBase& /*source*/)
Matt Spinler6b1a5c82020-01-07 08:48:53 -0600445{
446 close(fd);
447 _fdCloserEventSource.reset();
448}
449
Matt Spinlera34ab722019-12-16 10:39:32 -0600450std::vector<uint8_t> Manager::getPELFromOBMCID(uint32_t obmcLogID)
451{
452 Repository::LogID id{Repository::LogID::Obmc(obmcLogID)};
453 std::optional<std::vector<uint8_t>> data;
454
Matt Spinler5f5352e2020-03-05 16:23:27 -0600455 log<level::DEBUG>("getPELFromOBMCID", entry("OBMC_LOG_ID=%d", obmcLogID));
456
Matt Spinlera34ab722019-12-16 10:39:32 -0600457 try
458 {
459 data = _repo.getPELData(id);
460 }
Patrick Williams66491c62021-10-06 12:23:37 -0500461 catch (const std::exception& e)
Matt Spinlera34ab722019-12-16 10:39:32 -0600462 {
463 throw common_error::InternalFailure();
464 }
465
466 if (!data)
467 {
468 throw common_error::InvalidArgument();
469 }
470
471 return *data;
472}
473
474void Manager::hostAck(uint32_t pelID)
475{
476 Repository::LogID id{Repository::LogID::Pel(pelID)};
477
Matt Spinler5f5352e2020-03-05 16:23:27 -0600478 log<level::DEBUG>("HostAck", entry("PEL_ID=0x%X", pelID));
479
Matt Spinlera34ab722019-12-16 10:39:32 -0600480 if (!_repo.hasPEL(id))
481 {
482 throw common_error::InvalidArgument();
483 }
484
485 if (_hostNotifier)
486 {
487 _hostNotifier->ackPEL(pelID);
488 }
489}
490
491void Manager::hostReject(uint32_t pelID, RejectionReason reason)
492{
493 Repository::LogID id{Repository::LogID::Pel(pelID)};
494
Matt Spinler5f5352e2020-03-05 16:23:27 -0600495 log<level::DEBUG>("HostReject", entry("PEL_ID=0x%X", pelID),
496 entry("REASON=%d", static_cast<int>(reason)));
497
Matt Spinlera34ab722019-12-16 10:39:32 -0600498 if (!_repo.hasPEL(id))
499 {
500 throw common_error::InvalidArgument();
501 }
502
Matt Spinler05c2c6c2019-12-18 14:02:09 -0600503 if (reason == RejectionReason::BadPEL)
Matt Spinlera34ab722019-12-16 10:39:32 -0600504 {
Matt Spinler05c2c6c2019-12-18 14:02:09 -0600505 AdditionalData data;
506 data.add("BAD_ID", getNumberString("0x%08X", pelID));
507 _eventLogger.log("org.open_power.Logging.Error.SentBadPELToHost",
508 Entry::Level::Informational, data);
509 if (_hostNotifier)
Matt Spinlera34ab722019-12-16 10:39:32 -0600510 {
511 _hostNotifier->setBadPEL(pelID);
512 }
Matt Spinler05c2c6c2019-12-18 14:02:09 -0600513 }
514 else if ((reason == RejectionReason::HostFull) && _hostNotifier)
515 {
516 _hostNotifier->setHostFull(pelID);
Matt Spinlera34ab722019-12-16 10:39:32 -0600517 }
518}
519
Matt Spinler7e727a32020-07-07 15:00:17 -0500520void Manager::scheduleRepoPrune()
521{
Matt Spinler7e727a32020-07-07 15:00:17 -0500522 _repoPrunerEventSource = std::make_unique<sdeventplus::source::Defer>(
Matt Spinlerff9cec22020-07-15 13:06:35 -0500523 _event, std::bind(std::mem_fn(&Manager::pruneRepo), this,
524 std::placeholders::_1));
Matt Spinler7e727a32020-07-07 15:00:17 -0500525}
526
Patrick Williamsd26fa3e2021-04-21 15:22:23 -0500527void Manager::pruneRepo(sdeventplus::source::EventBase& /*source*/)
Matt Spinler7e727a32020-07-07 15:00:17 -0500528{
Sumit Kumar027bf282022-01-24 11:25:19 -0600529 auto idsWithHwIsoEntry = _dataIface->getLogIDWithHwIsolation();
530
531 auto idsToDelete = _repo.prune(idsWithHwIsoEntry);
Matt Spinler7e727a32020-07-07 15:00:17 -0500532
533 // Remove the OpenBMC event logs for the PELs that were just removed.
534 std::for_each(idsToDelete.begin(), idsToDelete.end(),
535 [this](auto id) { this->_logManager.erase(id); });
536
537 _repoPrunerEventSource.reset();
538}
539
Matt Spinlerff9cec22020-07-15 13:06:35 -0500540void Manager::setupPELDeleteWatch()
541{
542 _pelFileDeleteFD = inotify_init1(IN_NONBLOCK);
543 if (-1 == _pelFileDeleteFD)
544 {
545 auto e = errno;
546 std::string msg =
547 "inotify_init1 failed with errno " + std::to_string(e);
548 log<level::ERR>(msg.c_str());
549 abort();
550 }
551
552 _pelFileDeleteWatchFD = inotify_add_watch(
553 _pelFileDeleteFD, _repo.repoPath().c_str(), IN_DELETE);
554 if (-1 == _pelFileDeleteWatchFD)
555 {
556 auto e = errno;
557 std::string msg =
558 "inotify_add_watch failed with error " + std::to_string(e);
559 log<level::ERR>(msg.c_str());
560 abort();
561 }
562
563 _pelFileDeleteEventSource = std::make_unique<sdeventplus::source::IO>(
564 _event, _pelFileDeleteFD, EPOLLIN,
565 std::bind(std::mem_fn(&Manager::pelFileDeleted), this,
566 std::placeholders::_1, std::placeholders::_2,
567 std::placeholders::_3));
568}
569
Patrick Williamsd26fa3e2021-04-21 15:22:23 -0500570void Manager::pelFileDeleted(sdeventplus::source::IO& /*io*/, int /*fd*/,
Matt Spinlerff9cec22020-07-15 13:06:35 -0500571 uint32_t revents)
572{
573 if (!(revents & EPOLLIN))
574 {
575 return;
576 }
577
578 // An event for 1 PEL uses 48B. When all PELs are deleted at once,
579 // as many events as there is room for can be handled in one callback.
580 // A size of 2000 will allow 41 to be processed, with additional
581 // callbacks being needed to process the remaining ones.
Matt Spinler9d59d582021-05-19 07:57:10 -0600582 std::array<uint8_t, 2000> data{};
Matt Spinlerff9cec22020-07-15 13:06:35 -0500583 auto bytesRead = read(_pelFileDeleteFD, data.data(), data.size());
584 if (bytesRead < 0)
585 {
586 auto e = errno;
587 std::string msg = "Failed reading data from inotify event, errno = " +
588 std::to_string(e);
589 log<level::ERR>(msg.c_str());
590 abort();
591 }
592
593 auto offset = 0;
594 while (offset < bytesRead)
595 {
596 auto event = reinterpret_cast<inotify_event*>(&data[offset]);
597 if (event->mask & IN_DELETE)
598 {
599 std::string filename{event->name};
600
601 // Get the PEL ID from the filename and tell the
602 // repo it's been removed, and then delete the BMC
603 // event log if it's there.
604 auto pos = filename.find_first_of('_');
605 if (pos != std::string::npos)
606 {
607 try
608 {
609 auto idString = filename.substr(pos + 1);
610 auto pelID = std::stoul(idString, nullptr, 16);
611
612 Repository::LogID id{Repository::LogID::Pel(pelID)};
613 auto removedLogID = _repo.remove(id);
614 if (removedLogID)
615 {
616 _logManager.erase(removedLogID->obmcID.id);
617 }
618 }
619 catch (const std::exception& e)
620 {
621 log<level::INFO>("Could not find PEL ID from its filename",
622 entry("FILENAME=%s", filename.c_str()));
623 }
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<
635 sdbusplus::xyz::openbmc_project::Logging::server::Create::FFDCFormat,
636 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
Andrew Geissler44fc3162020-07-09 09:21:31 -0500644void Manager::checkPelAndQuiesce(std::unique_ptr<openpower::pels::PEL>& pel)
645{
Matt Spinlerb2abc042021-05-17 15:32:50 -0600646 if ((pel->userHeader().severity() ==
647 static_cast<uint8_t>(SeverityType::nonError)) ||
648 (pel->userHeader().severity() ==
649 static_cast<uint8_t>(SeverityType::recovered)))
Andrew Geissler44fc3162020-07-09 09:21:31 -0500650 {
Matt Spinlerb2abc042021-05-17 15:32:50 -0600651 log<level::DEBUG>(
652 "PEL severity informational or recovered. no quiesce needed");
Andrew Geissler44fc3162020-07-09 09:21:31 -0500653 return;
654 }
655 if (!_logManager.isQuiesceOnErrorEnabled())
656 {
657 log<level::DEBUG>("QuiesceOnHwError not enabled, no quiesce needed");
658 return;
659 }
660
Matt Spinler845c6242022-03-01 16:45:08 -0600661 CreatorID creatorID{pel->privateHeader().creatorID()};
662
663 if ((creatorID != CreatorID::openBMC) &&
664 (creatorID != CreatorID::hostboot) &&
665 (creatorID != CreatorID::ioDrawer) && (creatorID != CreatorID::occ) &&
666 (creatorID != CreatorID::phyp))
667 {
668 return;
669 }
670
Andrew Geissler44fc3162020-07-09 09:21:31 -0500671 // Now check if it has any type of callout
Andrew Geisslerf8e750d2022-01-14 14:56:13 -0600672 if (pel->isHwCalloutPresent())
Andrew Geissler44fc3162020-07-09 09:21:31 -0500673 {
Matt Spinlerb2abc042021-05-17 15:32:50 -0600674 log<level::INFO>(
675 "QuiesceOnHwError enabled, PEL severity not nonError or recovered, "
676 "and callout is present");
Andrew Geissler44fc3162020-07-09 09:21:31 -0500677
678 _logManager.quiesceOnError(pel->obmcLogID());
679 }
680}
681
Vijay Lobod354a392021-06-01 16:21:02 -0500682std::string Manager::getEventId(const openpower::pels::PEL& pel) const
683{
684 std::string str;
685 auto src = pel.primarySRC();
686 if (src)
687 {
688 const auto& hexwords = (*src)->hexwordData();
689
690 std::string refcode = (*src)->asciiString();
691 size_t pos = refcode.find_last_not_of(0x20);
692 if (pos != std::string::npos)
693 {
694 refcode.erase(pos + 1);
695 }
696 str = refcode;
697
698 for (auto& value : hexwords)
699 {
700 str += " ";
701 str += getNumberString("%08X", value);
702 }
703 }
704 return str;
705}
706
707void Manager::updateEventId(std::unique_ptr<openpower::pels::PEL>& pel)
708{
709 std::string eventIdStr = getEventId(*pel);
710
711 auto entryN = _logManager.entries.find(pel->obmcLogID());
712 if (entryN != _logManager.entries.end())
713 {
714 entryN->second->eventId(eventIdStr);
715 }
716}
717
Vijay Lobo593a4c62021-06-16 14:25:26 -0500718std::string Manager::getResolution(const openpower::pels::PEL& pel) const
719{
720 std::string str;
721 std::string resolution;
722 auto src = pel.primarySRC();
723 if (src)
724 {
725 // First extract the callout pointer and then go through
726 const auto& callouts = (*src)->callouts();
727 namespace pv = openpower::pels::pel_values;
728 // All PELs dont have callout, check before parsing callout data
729 if (callouts)
730 {
731 const auto& entries = callouts->callouts();
732 // Entry starts with index 1
733 uint8_t index = 1;
734 for (auto& entry : entries)
735 {
736 resolution += std::to_string(index) + ". ";
737 // Adding Location code to resolution
738 if (!entry->locationCode().empty())
739 resolution +=
740 "Location Code: " + entry->locationCode() + ", ";
741 if (entry->fruIdentity())
742 {
743 // Get priority and set the resolution string
744 str = pv::getValue(entry->priority(),
745 pel_values::calloutPriorityValues,
746 pel_values::registryNamePos);
747 str[0] = toupper(str[0]);
748 resolution += "Priority: " + str + ", ";
749 if (entry->fruIdentity()->getPN().has_value())
750 {
751 resolution +=
752 "PN: " + entry->fruIdentity()->getPN().value() +
753 ", ";
754 }
755 if (entry->fruIdentity()->getSN().has_value())
756 {
757 resolution +=
758 "SN: " + entry->fruIdentity()->getSN().value() +
759 ", ";
760 }
761 if (entry->fruIdentity()->getCCIN().has_value())
762 {
763 resolution +=
764 "CCIN: " + entry->fruIdentity()->getCCIN().value() +
765 ", ";
766 }
767 // Add the maintenance procedure
768 if (entry->fruIdentity()->getMaintProc().has_value())
769 {
770 resolution +=
771 "Procedure: " +
772 entry->fruIdentity()->getMaintProc().value() + ", ";
773 }
774 }
775 resolution.resize(resolution.size() - 2);
776 resolution += "\n";
777 index++;
778 }
779 }
780 }
781 return resolution;
782}
783
784void Manager::updateResolution(std::unique_ptr<openpower::pels::PEL>& pel)
785{
786 std::string callouts = getResolution(*pel);
787 auto entryN = _logManager.entries.find(pel->obmcLogID());
788 if (entryN != _logManager.entries.end())
789 {
Matt Spinler734ed2b2022-01-21 09:31:46 -0600790 entryN->second->resolution(callouts, true);
Vijay Lobo593a4c62021-06-16 14:25:26 -0500791 }
792}
793
Adriana Kobylake7d271a2020-12-07 14:32:44 -0600794void Manager::setEntryPath(uint32_t obmcLogID)
795{
796 Repository::LogID id{Repository::LogID::Obmc(obmcLogID)};
797 if (auto attributes = _repo.getPELAttributes(id); attributes)
798 {
799 auto& attr = attributes.value().get();
800 auto entry = _logManager.entries.find(obmcLogID);
801 if (entry != _logManager.entries.end())
802 {
Matt Spinler734ed2b2022-01-21 09:31:46 -0600803 entry->second->path(attr.path, true);
Adriana Kobylake7d271a2020-12-07 14:32:44 -0600804 }
805 }
806}
807
Vijay Lobocbc93a42021-05-20 19:04:07 -0500808void Manager::setServiceProviderNotifyFlag(uint32_t obmcLogID)
809{
810 Repository::LogID id{Repository::LogID::Obmc(obmcLogID)};
811 if (auto attributes = _repo.getPELAttributes(id); attributes)
812 {
813 auto& attr = attributes.value().get();
814 auto entry = _logManager.entries.find(obmcLogID);
815 if (entry != _logManager.entries.end())
816 {
Vijay Loboafb1b462021-07-21 23:29:13 -0500817 entry->second->serviceProviderNotify(
Matt Spinler734ed2b2022-01-21 09:31:46 -0600818 attr.actionFlags.test(callHomeFlagBit), true);
Vijay Lobocbc93a42021-05-20 19:04:07 -0500819 }
820 }
821}
822
Matt Spinler734ed2b2022-01-21 09:31:46 -0600823void Manager::createPELEntry(uint32_t obmcLogID, bool skipIaSignal)
Vijay Loboafb1b462021-07-21 23:29:13 -0500824{
825 std::map<std::string, PropertiesVariant> varData;
826 Repository::LogID id{Repository::LogID::Obmc(obmcLogID)};
827 if (auto attributes = _repo.getPELAttributes(id); attributes)
828 {
829 namespace pv = openpower::pels::pel_values;
830 auto& attr = attributes.value().get();
Vijay Lobob2e541e2021-08-31 23:12:47 -0500831
832 // get the hidden flag values
833 auto sevType = static_cast<SeverityType>(attr.severity & 0xF0);
834 auto isHidden = true;
835 if (((sevType != SeverityType::nonError) &&
836 attr.actionFlags.test(reportFlagBit) &&
837 !attr.actionFlags.test(hiddenFlagBit)) ||
838 ((sevType == SeverityType::nonError) &&
839 attr.actionFlags.test(serviceActionFlagBit)))
840 {
841 isHidden = false;
842 }
843 varData.emplace(std::string("Hidden"), isHidden);
Vijay Loboafb1b462021-07-21 23:29:13 -0500844 varData.emplace(
845 std::string("Subsystem"),
846 pv::getValue(attr.subsystem, pel_values::subsystemValues));
Vijay Lobo2fb10212021-08-22 23:24:16 -0500847
848 varData.emplace(
849 std::string("ManagementSystemAck"),
850 (attr.hmcState == TransmissionState::acked ? true : false));
851
Vijay Loboafb1b462021-07-21 23:29:13 -0500852 // Path to create PELEntry Interface is same as PEL
853 auto path = std::string(OBJ_ENTRY) + '/' + std::to_string(obmcLogID);
854 // Create Interface for PELEntry and set properties
Vijay Lobo2fb10212021-08-22 23:24:16 -0500855 auto pelEntry = std::make_unique<PELEntry>(_logManager.getBus(), path,
856 varData, obmcLogID, &_repo);
Matt Spinler734ed2b2022-01-21 09:31:46 -0600857 if (!skipIaSignal)
858 {
859 pelEntry->emit_added();
860 }
Vijay Loboafb1b462021-07-21 23:29:13 -0500861 _pelEntries.emplace(std::move(path), std::move(pelEntry));
862 }
863}
864
Ramesh Iyyarf4203c42021-06-24 06:09:23 -0500865uint32_t Manager::getPELIdFromBMCLogId(uint32_t bmcLogId)
866{
867 Repository::LogID id{Repository::LogID::Obmc(bmcLogId)};
868 if (auto logId = _repo.getLogID(id); !logId.has_value())
869 {
870 throw common_error::InvalidArgument();
871 }
872 else
873 {
874 return logId->pelID.id;
875 }
876}
877
Ramesh Iyyar530efbf2021-06-24 06:22:22 -0500878uint32_t Manager::getBMCLogIdFromPELId(uint32_t pelId)
879{
880 Repository::LogID id{Repository::LogID::Pel(pelId)};
881 if (auto logId = _repo.getLogID(id); !logId.has_value())
882 {
883 throw common_error::InvalidArgument();
884 }
885 else
886 {
887 return logId->obmcID.id;
888 }
889}
890
Sumit Kumar3e274432021-09-14 06:37:56 -0500891void Manager::updateProgressSRC(
892 std::unique_ptr<openpower::pels::PEL>& pel) const
893{
894 // Check for pel severity of type - 0x51 = critical error, system
895 // termination
896 if (pel->userHeader().severity() == 0x51)
897 {
898 auto src = pel->primarySRC();
899 if (src)
900 {
901 std::vector<uint8_t> asciiSRC = (*src)->getSrcStruct();
902 uint64_t srcRefCode = 0;
903
904 // Read bytes from offset [40-47] e.g. BD8D1001
905 for (int i = 0; i < 8; i++)
906 {
907 srcRefCode |=
908 (static_cast<uint64_t>(asciiSRC[40 + i]) << (8 * i));
909 }
910
911 try
912 {
913 _dataIface->createProgressSRC(srcRefCode, asciiSRC);
914 }
915 catch (std::exception& e)
916 {
917 // Exception - may be no boot progress interface on dbus
918 }
919 }
920 }
921}
922
Matt Spinlerd8fb5ba2022-01-25 13:01:14 -0600923void Manager::scheduleObmcLogDelete(uint32_t obmcLogID)
924{
925 _obmcLogDeleteEventSource = std::make_unique<sdeventplus::source::Defer>(
926 _event, std::bind(std::mem_fn(&Manager::deleteObmcLog), this,
927 std::placeholders::_1, obmcLogID));
928}
929
930void Manager::deleteObmcLog(sdeventplus::source::EventBase&, uint32_t obmcLogID)
931{
932 log<level::INFO>(
933 fmt::format("Removing event log with no PEL: {}", obmcLogID).c_str());
934 _logManager.erase(obmcLogID);
935 _obmcLogDeleteEventSource.reset();
936}
937
Matt Spinler4e8078c2019-07-09 13:22:32 -0500938} // namespace pels
939} // namespace openpower