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 "repository.hpp"
17
18 #include <fcntl.h>
19 #include <sys/stat.h>
20
21 #include <phosphor-logging/lg2.hpp>
22 #include <xyz/openbmc_project/Common/File/error.hpp>
23
24 #include <fstream>
25
26 namespace openpower
27 {
28 namespace pels
29 {
30
31 namespace fs = std::filesystem;
32 namespace file_error = sdbusplus::xyz::openbmc_project::Common::File::Error;
33
34 constexpr size_t warningPercentage = 95;
35
36 /**
37 * @brief Returns the amount of space the file uses on disk.
38 *
39 * This is different than just the regular size of the file.
40 *
41 * @param[in] file - The file to get the size of
42 *
43 * @return size_t The disk space the file uses
44 */
getFileDiskSize(const std::filesystem::path & file)45 size_t getFileDiskSize(const std::filesystem::path& file)
46 {
47 constexpr size_t statBlockSize = 512;
48 struct stat statData;
49 auto rc = stat(file.c_str(), &statData);
50 if (rc != 0)
51 {
52 auto e = errno;
53 lg2::error("Call to stat() failed on {FILE} with errno {ERRNO}", "FILE",
54 file.native(), "ERRNO", e);
55 abort();
56 }
57
58 return statData.st_blocks * statBlockSize;
59 }
60
Repository(const std::filesystem::path & basePath,size_t repoSize,size_t maxNumPELs)61 Repository::Repository(const std::filesystem::path& basePath, size_t repoSize,
62 size_t maxNumPELs) :
63 _logPath(basePath / "logs"), _maxRepoSize(repoSize),
64 _maxNumPELs(maxNumPELs), _archivePath(basePath / "logs" / "archive")
65 {
66 if (!fs::exists(_logPath))
67 {
68 fs::create_directories(_logPath);
69 }
70
71 if (!fs::exists(_archivePath))
72 {
73 fs::create_directories(_archivePath);
74 }
75
76 restore();
77 }
78
restore()79 void Repository::restore()
80 {
81 for (auto& dirEntry : fs::directory_iterator(_logPath))
82 {
83 try
84 {
85 if (!fs::is_regular_file(dirEntry.path()))
86 {
87 continue;
88 }
89
90 std::ifstream file{dirEntry.path()};
91 std::vector<uint8_t> data{std::istreambuf_iterator<char>(file),
92 std::istreambuf_iterator<char>()};
93 file.close();
94
95 PEL pel{data};
96 if (pel.valid())
97 {
98 // If the host hasn't acked it, reset the host state so
99 // it will get sent up again.
100 if (pel.hostTransmissionState() == TransmissionState::sent)
101 {
102 pel.setHostTransmissionState(TransmissionState::newPEL);
103 try
104 {
105 write(pel, dirEntry.path());
106 }
107 catch (const std::exception& e)
108 {
109 lg2::error(
110 "Failed to save PEL after updating host state, PEL ID = {ID}",
111 "ID", lg2::hex, pel.id());
112 }
113 }
114
115 PELAttributes attributes{
116 dirEntry.path(),
117 getFileDiskSize(dirEntry.path()),
118 pel.privateHeader().creatorID(),
119 pel.userHeader().subsystem(),
120 pel.userHeader().severity(),
121 pel.userHeader().actionFlags(),
122 pel.hostTransmissionState(),
123 pel.hmcTransmissionState(),
124 pel.plid(),
125 pel.getDeconfigFlag(),
126 pel.getGuardFlag(),
127 getMillisecondsSinceEpoch(
128 pel.privateHeader().createTimestamp())};
129
130 using pelID = LogID::Pel;
131 using obmcID = LogID::Obmc;
132 _pelAttributes.emplace(
133 LogID(pelID(pel.id()), obmcID(pel.obmcLogID())),
134 attributes);
135
136 updateRepoStats(attributes, true);
137 }
138 else
139 {
140 lg2::error(
141 "Found invalid PEL file {FILE} while restoring. Removing.",
142 "FILE", dirEntry.path());
143 fs::remove(dirEntry.path());
144 }
145 }
146 catch (const std::exception& e)
147 {
148 lg2::error("Hit exception while restoring PEL file {FILE}: {ERROR}",
149 "FILE", dirEntry.path(), "ERROR", e);
150 }
151 }
152
153 // Get size of archive folder
154 for (auto& dirEntry : fs::directory_iterator(_archivePath))
155 {
156 _archiveSize += getFileDiskSize(dirEntry);
157 }
158 }
159
getPELFilename(uint32_t pelID,const BCDTime & time)160 std::string Repository::getPELFilename(uint32_t pelID, const BCDTime& time)
161 {
162 char name[50];
163 sprintf(name, "%.2X%.2X%.2X%.2X%.2X%.2X%.2X%.2X_%.8X", time.yearMSB,
164 time.yearLSB, time.month, time.day, time.hour, time.minutes,
165 time.seconds, time.hundredths, pelID);
166 return std::string{name};
167 }
168
add(std::unique_ptr<PEL> & pel)169 void Repository::add(std::unique_ptr<PEL>& pel)
170 {
171 pel->setHostTransmissionState(TransmissionState::newPEL);
172 pel->setHMCTransmissionState(TransmissionState::newPEL);
173
174 auto path = _logPath / getPELFilename(pel->id(), pel->commitTime());
175
176 write(*(pel.get()), path);
177
178 PELAttributes attributes{
179 path,
180 getFileDiskSize(path),
181 pel->privateHeader().creatorID(),
182 pel->userHeader().subsystem(),
183 pel->userHeader().severity(),
184 pel->userHeader().actionFlags(),
185 pel->hostTransmissionState(),
186 pel->hmcTransmissionState(),
187 pel->plid(),
188 pel->getDeconfigFlag(),
189 pel->getGuardFlag(),
190 getMillisecondsSinceEpoch(pel->privateHeader().createTimestamp())};
191
192 using pelID = LogID::Pel;
193 using obmcID = LogID::Obmc;
194 _pelAttributes.emplace(LogID(pelID(pel->id()), obmcID(pel->obmcLogID())),
195 attributes);
196
197 _lastPelID = pel->id();
198
199 updateRepoStats(attributes, true);
200
201 processAddCallbacks(*pel);
202 }
203
write(const PEL & pel,const fs::path & path)204 void Repository::write(const PEL& pel, const fs::path& path)
205 {
206 std::ofstream file{path, std::ios::binary};
207
208 if (!file.good())
209 {
210 // If this fails, the filesystem is probably full so it isn't like
211 // we could successfully create yet another error log here.
212 auto e = errno;
213 fs::remove(path);
214 lg2::error(
215 "Unable to open PEL file {FILE} for writing, errno = {ERRNO}",
216 "FILE", path, "ERRNO", e);
217 throw file_error::Open();
218 }
219
220 auto data = pel.data();
221 file.write(reinterpret_cast<const char*>(data.data()), data.size());
222
223 if (file.fail())
224 {
225 // Same note as above about not being able to create an error log
226 // for this case even if we wanted.
227 auto e = errno;
228 file.close();
229 fs::remove(path);
230 lg2::error("Unable to write PEL file {FILE}, errno = {ERRNO}", "FILE",
231 path, "ERRNO", e);
232 throw file_error::Write();
233 }
234 }
235
remove(const LogID & id)236 std::optional<Repository::LogID> Repository::remove(const LogID& id)
237 {
238 auto pel = findPEL(id);
239 if (pel == _pelAttributes.end())
240 {
241 return std::nullopt;
242 }
243
244 LogID actualID = pel->first;
245 updateRepoStats(pel->second, false);
246
247 lg2::debug(
248 "Removing PEL from repository, PEL ID = {PEL_ID}, BMC log ID = {BMC_ID}",
249 "PEL_ID", lg2::hex, actualID.pelID.id, "BMC_ID", actualID.obmcID.id);
250
251 if (fs::exists(pel->second.path))
252 {
253 // Check for existense of new archive folder
254 if (!fs::exists(_archivePath))
255 {
256 fs::create_directories(_archivePath);
257 }
258
259 // Move log file to archive folder
260 auto fileName = _archivePath / pel->second.path.filename();
261 fs::rename(pel->second.path, fileName);
262
263 // Update size of file
264 _archiveSize += getFileDiskSize(fileName);
265 }
266
267 _pelAttributes.erase(pel);
268
269 processDeleteCallbacks(actualID.pelID.id);
270
271 return actualID;
272 }
273
getPELData(const LogID & id)274 std::optional<std::vector<uint8_t>> Repository::getPELData(const LogID& id)
275 {
276 auto pel = findPEL(id);
277 if (pel != _pelAttributes.end())
278 {
279 std::ifstream file{pel->second.path.c_str()};
280 if (!file.good())
281 {
282 auto e = errno;
283 lg2::error("Unable to open PEL file {FILE}, errno = {ERRNO}",
284 "FILE", pel->second.path, "ERRNO", e);
285 throw file_error::Open();
286 }
287
288 std::vector<uint8_t> data{std::istreambuf_iterator<char>(file),
289 std::istreambuf_iterator<char>()};
290 return data;
291 }
292
293 return std::nullopt;
294 }
295
getPELFD(const LogID & id)296 std::optional<sdbusplus::message::unix_fd> Repository::getPELFD(const LogID& id)
297 {
298 auto pel = findPEL(id);
299 if (pel != _pelAttributes.end())
300 {
301 int fd = open(pel->second.path.c_str(), O_RDONLY | O_NONBLOCK);
302 if (fd == -1)
303 {
304 auto e = errno;
305 lg2::error("Unable to open PEL file {FILE}, errno = {ERRNO}",
306 "FILE", pel->second.path, "ERRNO", e);
307 throw file_error::Open();
308 }
309
310 // Must leave the file open here. It will be closed by sdbusplus
311 // when it sends it back over D-Bus.
312 return fd;
313 }
314 return std::nullopt;
315 }
316
for_each(ForEachFunc func) const317 void Repository::for_each(ForEachFunc func) const
318 {
319 for (const auto& [id, attributes] : _pelAttributes)
320 {
321 std::ifstream file{attributes.path};
322
323 if (!file.good())
324 {
325 auto e = errno;
326 lg2::error(
327 "Repository::for_each: Unable to open PEL file {FILE}, errno = {ERRNO}",
328 "FILE", attributes.path, "ERRNO", e);
329 continue;
330 }
331
332 std::vector<uint8_t> data{std::istreambuf_iterator<char>(file),
333 std::istreambuf_iterator<char>()};
334 file.close();
335
336 PEL pel{data};
337
338 try
339 {
340 if (func(pel))
341 {
342 break;
343 }
344 }
345 catch (const std::exception& e)
346 {
347 lg2::error("Repository::for_each function exception: {ERROR}",
348 "ERROR", e);
349 }
350 }
351 }
352
processAddCallbacks(const PEL & pel) const353 void Repository::processAddCallbacks(const PEL& pel) const
354 {
355 for (auto& [name, func] : _addSubscriptions)
356 {
357 try
358 {
359 func(pel);
360 }
361 catch (const std::exception& e)
362 {
363 lg2::error(
364 "PEL Repository add callback exception. Name = {NAME}, Error = {ERROR}",
365 "NAME", name, "ERROR", e);
366 }
367 }
368 }
369
processDeleteCallbacks(uint32_t id) const370 void Repository::processDeleteCallbacks(uint32_t id) const
371 {
372 for (auto& [name, func] : _deleteSubscriptions)
373 {
374 try
375 {
376 func(id);
377 }
378 catch (const std::exception& e)
379 {
380 lg2::error(
381 "PEL Repository delete callback exception. Name = {NAME}, Error = {ERROR}",
382 "NAME", name, "ERROR", e);
383 }
384 }
385 }
386
387 std::optional<std::reference_wrapper<const Repository::PELAttributes>>
getPELAttributes(const LogID & id) const388 Repository::getPELAttributes(const LogID& id) const
389 {
390 auto pel = findPEL(id);
391 if (pel != _pelAttributes.end())
392 {
393 return pel->second;
394 }
395
396 return std::nullopt;
397 }
398
setPELHostTransState(uint32_t pelID,TransmissionState state)399 void Repository::setPELHostTransState(uint32_t pelID, TransmissionState state)
400 {
401 LogID id{LogID::Pel{pelID}};
402 auto attr = std::find_if(_pelAttributes.begin(), _pelAttributes.end(),
403 [&id](const auto& a) { return a.first == id; });
404
405 if ((attr != _pelAttributes.end()) && (attr->second.hostState != state))
406 {
407 PELUpdateFunc func = [state](PEL& pel) {
408 pel.setHostTransmissionState(state);
409 return true;
410 };
411
412 try
413 {
414 updatePEL(attr->second.path, func);
415 }
416 catch (const std::exception& e)
417 {
418 lg2::error(
419 "Unable to update PEL host transmission state. Path = {PATH}, Error = {ERROR}",
420 "PATH", attr->second.path, "ERROR", e);
421 }
422 }
423 }
424
setPELHMCTransState(uint32_t pelID,TransmissionState state)425 void Repository::setPELHMCTransState(uint32_t pelID, TransmissionState state)
426 {
427 LogID id{LogID::Pel{pelID}};
428 auto attr = std::find_if(_pelAttributes.begin(), _pelAttributes.end(),
429 [&id](const auto& a) { return a.first == id; });
430
431 if ((attr != _pelAttributes.end()) && (attr->second.hmcState != state))
432 {
433 PELUpdateFunc func = [state](PEL& pel) {
434 pel.setHMCTransmissionState(state);
435 return true;
436 };
437
438 try
439 {
440 updatePEL(attr->second.path, func);
441 }
442 catch (const std::exception& e)
443 {
444 lg2::error(
445 "Unable to update PEL HMC transmission state. Path = {PATH}, Error = {ERROR}",
446 "PATH", attr->second.path, "ERROR", e);
447 }
448 }
449 }
450
updatePEL(const fs::path & path,PELUpdateFunc updateFunc)451 bool Repository::updatePEL(const fs::path& path, PELUpdateFunc updateFunc)
452 {
453 std::ifstream file{path};
454 std::vector<uint8_t> data{std::istreambuf_iterator<char>(file),
455 std::istreambuf_iterator<char>()};
456 file.close();
457
458 PEL pel{data};
459
460 if (pel.valid())
461 {
462 if (updateFunc(pel))
463 {
464 // Three attribute fields can change post creation from
465 // an updatePEL call:
466 // - hmcTransmissionState - When HMC acks a PEL
467 // - hostTransmissionState - When host acks a PEL
468 // - deconfig flag - Can be cleared for PELs that call out
469 // hotplugged FRUs.
470 // Make sure they're up to date.
471 LogID id{LogID::Pel(pel.id())};
472 auto attr =
473 std::find_if(_pelAttributes.begin(), _pelAttributes.end(),
474 [&id](const auto& a) { return a.first == id; });
475 if (attr != _pelAttributes.end())
476 {
477 attr->second.hmcState = pel.hmcTransmissionState();
478 attr->second.hostState = pel.hostTransmissionState();
479 attr->second.deconfig = pel.getDeconfigFlag();
480 }
481
482 write(pel, path);
483 return true;
484 }
485 }
486 else
487 {
488 throw std::runtime_error(
489 "Unable to read a valid PEL when trying to update it");
490 }
491 return false;
492 }
493
isServiceableSev(const PELAttributes & pel)494 bool Repository::isServiceableSev(const PELAttributes& pel)
495 {
496 auto sevType = static_cast<SeverityType>(pel.severity & 0xF0);
497 auto sevPVEntry =
498 pel_values::findByValue(pel.severity, pel_values::severityValues);
499 std::string sevName = std::get<pel_values::registryNamePos>(*sevPVEntry);
500
501 bool check1 = (sevType == SeverityType::predictive) ||
502 (sevType == SeverityType::unrecoverable) ||
503 (sevType == SeverityType::critical);
504
505 bool check2 = ((sevType == SeverityType::recovered) ||
506 (sevName == "symptom_recovered")) &&
507 !pel.actionFlags.test(hiddenFlagBit);
508
509 bool check3 = (sevName == "symptom_predictive") ||
510 (sevName == "symptom_unrecoverable") ||
511 (sevName == "symptom_critical");
512
513 return check1 || check2 || check3;
514 }
515
updateRepoStats(const PELAttributes & pel,bool pelAdded)516 void Repository::updateRepoStats(const PELAttributes& pel, bool pelAdded)
517 {
518 auto isServiceable = Repository::isServiceableSev(pel);
519 auto bmcPEL = CreatorID::openBMC == static_cast<CreatorID>(pel.creator);
520
521 auto adjustSize = [pelAdded, &pel](auto& runningSize) {
522 if (pelAdded)
523 {
524 runningSize += pel.sizeOnDisk;
525 }
526 else
527 {
528 runningSize = std::max(static_cast<int64_t>(runningSize) -
529 static_cast<int64_t>(pel.sizeOnDisk),
530 static_cast<int64_t>(0));
531 }
532 };
533
534 adjustSize(_sizes.total);
535
536 if (bmcPEL)
537 {
538 adjustSize(_sizes.bmc);
539 if (isServiceable)
540 {
541 adjustSize(_sizes.bmcServiceable);
542 }
543 else
544 {
545 adjustSize(_sizes.bmcInfo);
546 }
547 }
548 else
549 {
550 adjustSize(_sizes.nonBMC);
551 if (isServiceable)
552 {
553 adjustSize(_sizes.nonBMCServiceable);
554 }
555 else
556 {
557 adjustSize(_sizes.nonBMCInfo);
558 }
559 }
560 }
561
sizeWarning()562 bool Repository::sizeWarning()
563 {
564 std::error_code ec;
565
566 if ((_archiveSize > 0) && ((_sizes.total + _archiveSize) >
567 ((_maxRepoSize * warningPercentage) / 100)))
568 {
569 lg2::info(
570 "Repository::sizeWarning function:Deleting the files in archive");
571
572 for (const auto& dirEntry : fs::directory_iterator(_archivePath))
573 {
574 fs::remove(dirEntry.path(), ec);
575 if (ec)
576 {
577 lg2::info("Repository::sizeWarning: Could not delete "
578 "file {FILE} in PEL archive",
579 "FILE", dirEntry.path());
580 }
581 }
582
583 _archiveSize = 0;
584 }
585
586 return (_sizes.total > (_maxRepoSize * warningPercentage / 100)) ||
587 (_pelAttributes.size() > _maxNumPELs);
588 }
589
590 std::vector<Repository::AttributesReference>
getAllPELAttributes(SortOrder order) const591 Repository::getAllPELAttributes(SortOrder order) const
592 {
593 std::vector<Repository::AttributesReference> attributes;
594
595 std::for_each(_pelAttributes.begin(), _pelAttributes.end(),
596 [&attributes](auto& pelEntry) {
597 attributes.push_back(pelEntry);
598 });
599
600 std::sort(attributes.begin(), attributes.end(),
601 [order](const auto& left, const auto& right) {
602 if (order == SortOrder::ascending)
603 {
604 return left.get().second.path < right.get().second.path;
605 }
606 return left.get().second.path > right.get().second.path;
607 });
608
609 return attributes;
610 }
611
612 std::vector<uint32_t>
prune(const std::vector<uint32_t> & idsWithHwIsoEntry)613 Repository::prune(const std::vector<uint32_t>& idsWithHwIsoEntry)
614 {
615 std::vector<uint32_t> obmcLogIDs;
616 lg2::info("Pruning PEL repository that takes up {TOTAL} bytes and has "
617 "{NUM_PELS} PELs",
618 "TOTAL", _sizes.total, "NUM_PELS", _pelAttributes.size());
619
620 // Set up the 5 functions to check if the PEL category
621 // is still over its limits.
622
623 // BMC informational PELs should only take up 15%
624 IsOverLimitFunc overBMCInfoLimit = [this]() {
625 return _sizes.bmcInfo > _maxRepoSize * 15 / 100;
626 };
627
628 // BMC non informational PELs should only take up 30%
629 IsOverLimitFunc overBMCNonInfoLimit = [this]() {
630 return _sizes.bmcServiceable > _maxRepoSize * 30 / 100;
631 };
632
633 // Non BMC informational PELs should only take up 15%
634 IsOverLimitFunc overNonBMCInfoLimit = [this]() {
635 return _sizes.nonBMCInfo > _maxRepoSize * 15 / 100;
636 };
637
638 // Non BMC non informational PELs should only take up 15%
639 IsOverLimitFunc overNonBMCNonInfoLimit = [this]() {
640 return _sizes.nonBMCServiceable > _maxRepoSize * 30 / 100;
641 };
642
643 // Bring the total number of PELs down to 80% of the max
644 IsOverLimitFunc tooManyPELsLimit = [this]() {
645 return _pelAttributes.size() > _maxNumPELs * 80 / 100;
646 };
647
648 // Set up the functions to determine which category a PEL is in.
649 // TODO: Return false in these functions if a PEL caused a guard record.
650
651 // A BMC informational PEL
652 IsPELTypeFunc isBMCInfo = [](const PELAttributes& pel) {
653 return (CreatorID::openBMC == static_cast<CreatorID>(pel.creator)) &&
654 !Repository::isServiceableSev(pel);
655 };
656
657 // A BMC non informational PEL
658 IsPELTypeFunc isBMCNonInfo = [](const PELAttributes& pel) {
659 return (CreatorID::openBMC == static_cast<CreatorID>(pel.creator)) &&
660 Repository::isServiceableSev(pel);
661 };
662
663 // A non BMC informational PEL
664 IsPELTypeFunc isNonBMCInfo = [](const PELAttributes& pel) {
665 return (CreatorID::openBMC != static_cast<CreatorID>(pel.creator)) &&
666 !Repository::isServiceableSev(pel);
667 };
668
669 // A non BMC non informational PEL
670 IsPELTypeFunc isNonBMCNonInfo = [](const PELAttributes& pel) {
671 return (CreatorID::openBMC != static_cast<CreatorID>(pel.creator)) &&
672 Repository::isServiceableSev(pel);
673 };
674
675 // When counting PELs, count every PEL
676 IsPELTypeFunc isAnyPEL = [](const PELAttributes& /*pel*/) { return true; };
677
678 // Check all 4 categories, which will result in at most 90%
679 // usage (15 + 30 + 15 + 30).
680 removePELs(overBMCInfoLimit, isBMCInfo, idsWithHwIsoEntry, obmcLogIDs);
681 removePELs(overBMCNonInfoLimit, isBMCNonInfo, idsWithHwIsoEntry,
682 obmcLogIDs);
683 removePELs(overNonBMCInfoLimit, isNonBMCInfo, idsWithHwIsoEntry,
684 obmcLogIDs);
685 removePELs(overNonBMCNonInfoLimit, isNonBMCNonInfo, idsWithHwIsoEntry,
686 obmcLogIDs);
687
688 // After the above pruning check if there are still too many PELs,
689 // which can happen depending on PEL sizes.
690 if (_pelAttributes.size() > _maxNumPELs)
691 {
692 removePELs(tooManyPELsLimit, isAnyPEL, idsWithHwIsoEntry, obmcLogIDs);
693 }
694
695 if (!obmcLogIDs.empty())
696 {
697 lg2::info("Number of PELs removed to save space: {NUM_PELS}",
698 "NUM_PELS", obmcLogIDs.size());
699 }
700
701 return obmcLogIDs;
702 }
703
removePELs(const IsOverLimitFunc & isOverLimit,const IsPELTypeFunc & isPELType,const std::vector<uint32_t> & idsWithHwIsoEntry,std::vector<uint32_t> & removedBMCLogIDs)704 void Repository::removePELs(const IsOverLimitFunc& isOverLimit,
705 const IsPELTypeFunc& isPELType,
706 const std::vector<uint32_t>& idsWithHwIsoEntry,
707 std::vector<uint32_t>& removedBMCLogIDs)
708 {
709 if (!isOverLimit())
710 {
711 return;
712 }
713
714 auto attributes = getAllPELAttributes(SortOrder::ascending);
715
716 // Make 4 passes on the PELs, stopping as soon as isOverLimit
717 // returns false.
718 // Pass 1: only delete HMC acked PELs
719 // Pass 2: only delete OS acked PELs
720 // Pass 3: only delete PHYP sent PELs
721 // Pass 4: delete all PELs
722 static const std::vector<std::function<bool(const PELAttributes& pel)>>
723 stateChecks{[](const auto& pel) {
724 return pel.hmcState == TransmissionState::acked;
725 },
726
727 [](const auto& pel) {
728 return pel.hostState == TransmissionState::acked;
729 },
730
731 [](const auto& pel) {
732 return pel.hostState == TransmissionState::sent;
733 },
734
735 [](const auto& /*pel*/) { return true; }};
736
737 for (const auto& stateCheck : stateChecks)
738 {
739 for (auto it = attributes.begin(); it != attributes.end();)
740 {
741 const auto& pel = it->get();
742 if (isPELType(pel.second) && stateCheck(pel.second))
743 {
744 auto removedID = pel.first.obmcID.id;
745
746 auto idFound = std::find(idsWithHwIsoEntry.begin(),
747 idsWithHwIsoEntry.end(), removedID);
748 if (idFound != idsWithHwIsoEntry.end())
749 {
750 ++it;
751 continue;
752 }
753
754 remove(pel.first);
755
756 removedBMCLogIDs.push_back(removedID);
757
758 attributes.erase(it);
759
760 if (!isOverLimit())
761 {
762 break;
763 }
764 }
765 else
766 {
767 ++it;
768 }
769 }
770
771 if (!isOverLimit())
772 {
773 break;
774 }
775 }
776 }
777
archivePEL(const PEL & pel)778 void Repository::archivePEL(const PEL& pel)
779 {
780 if (pel.valid())
781 {
782 auto path = _archivePath / getPELFilename(pel.id(), pel.commitTime());
783
784 write(pel, path);
785
786 _archiveSize += getFileDiskSize(path);
787 }
788 }
789
790 } // namespace pels
791 } // namespace openpower
792