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"),
64 _maxRepoSize(repoSize), _maxNumPELs(maxNumPELs),
65 _archivePath(basePath / "logs" / "archive")
66 {
67 if (!fs::exists(_logPath))
68 {
69 fs::create_directories(_logPath);
70 }
71
72 if (!fs::exists(_archivePath))
73 {
74 fs::create_directories(_archivePath);
75 }
76
77 restore();
78 }
79
restore()80 void Repository::restore()
81 {
82 for (auto& dirEntry : fs::directory_iterator(_logPath))
83 {
84 try
85 {
86 if (!fs::is_regular_file(dirEntry.path()))
87 {
88 continue;
89 }
90
91 std::ifstream file{dirEntry.path()};
92 std::vector<uint8_t> data{std::istreambuf_iterator<char>(file),
93 std::istreambuf_iterator<char>()};
94 file.close();
95
96 PEL pel{data};
97 if (pel.valid())
98 {
99 // If the host hasn't acked it, reset the host state so
100 // it will get sent up again.
101 if (pel.hostTransmissionState() == TransmissionState::sent)
102 {
103 pel.setHostTransmissionState(TransmissionState::newPEL);
104 try
105 {
106 write(pel, dirEntry.path());
107 }
108 catch (const std::exception& e)
109 {
110 lg2::error(
111 "Failed to save PEL after updating host state, PEL ID = {ID}",
112 "ID", lg2::hex, pel.id());
113 }
114 }
115
116 PELAttributes attributes{
117 dirEntry.path(),
118 getFileDiskSize(dirEntry.path()),
119 pel.privateHeader().creatorID(),
120 pel.userHeader().subsystem(),
121 pel.userHeader().severity(),
122 pel.userHeader().actionFlags(),
123 pel.hostTransmissionState(),
124 pel.hmcTransmissionState(),
125 pel.plid(),
126 pel.getDeconfigFlag(),
127 pel.getGuardFlag(),
128 getMillisecondsSinceEpoch(
129 pel.privateHeader().createTimestamp())};
130
131 using pelID = LogID::Pel;
132 using obmcID = LogID::Obmc;
133 _pelAttributes.emplace(
134 LogID(pelID(pel.id()), obmcID(pel.obmcLogID())),
135 attributes);
136
137 updateRepoStats(attributes, true);
138 }
139 else
140 {
141 lg2::error(
142 "Found invalid PEL file {FILE} while restoring. Removing.",
143 "FILE", dirEntry.path());
144 fs::remove(dirEntry.path());
145 }
146 }
147 catch (const std::exception& e)
148 {
149 lg2::error("Hit exception while restoring PEL file {FILE}: {ERROR}",
150 "FILE", dirEntry.path(), "ERROR", e);
151 }
152 }
153
154 // Get size of archive folder
155 for (auto& dirEntry : fs::directory_iterator(_archivePath))
156 {
157 _archiveSize += getFileDiskSize(dirEntry);
158 }
159 }
160
getPELFilename(uint32_t pelID,const BCDTime & time)161 std::string Repository::getPELFilename(uint32_t pelID, const BCDTime& time)
162 {
163 char name[50];
164 sprintf(name, "%.2X%.2X%.2X%.2X%.2X%.2X%.2X%.2X_%.8X", time.yearMSB,
165 time.yearLSB, time.month, time.day, time.hour, time.minutes,
166 time.seconds, time.hundredths, pelID);
167 return std::string{name};
168 }
169
add(std::unique_ptr<PEL> & pel)170 void Repository::add(std::unique_ptr<PEL>& pel)
171 {
172 pel->setHostTransmissionState(TransmissionState::newPEL);
173 pel->setHMCTransmissionState(TransmissionState::newPEL);
174
175 auto path = _logPath / getPELFilename(pel->id(), pel->commitTime());
176
177 write(*(pel.get()), path);
178
179 PELAttributes attributes{
180 path,
181 getFileDiskSize(path),
182 pel->privateHeader().creatorID(),
183 pel->userHeader().subsystem(),
184 pel->userHeader().severity(),
185 pel->userHeader().actionFlags(),
186 pel->hostTransmissionState(),
187 pel->hmcTransmissionState(),
188 pel->plid(),
189 pel->getDeconfigFlag(),
190 pel->getGuardFlag(),
191 getMillisecondsSinceEpoch(pel->privateHeader().createTimestamp())};
192
193 using pelID = LogID::Pel;
194 using obmcID = LogID::Obmc;
195 _pelAttributes.emplace(LogID(pelID(pel->id()), obmcID(pel->obmcLogID())),
196 attributes);
197
198 _lastPelID = pel->id();
199
200 updateRepoStats(attributes, true);
201
202 processAddCallbacks(*pel);
203 }
204
write(const PEL & pel,const fs::path & path)205 void Repository::write(const PEL& pel, const fs::path& path)
206 {
207 std::ofstream file{path, std::ios::binary};
208
209 if (!file.good())
210 {
211 // If this fails, the filesystem is probably full so it isn't like
212 // we could successfully create yet another error log here.
213 auto e = errno;
214 fs::remove(path);
215 lg2::error(
216 "Unable to open PEL file {FILE} for writing, errno = {ERRNO}",
217 "FILE", path, "ERRNO", e);
218 throw file_error::Open();
219 }
220
221 auto data = pel.data();
222 file.write(reinterpret_cast<const char*>(data.data()), data.size());
223
224 if (file.fail())
225 {
226 // Same note as above about not being able to create an error log
227 // for this case even if we wanted.
228 auto e = errno;
229 file.close();
230 fs::remove(path);
231 lg2::error("Unable to write PEL file {FILE}, errno = {ERRNO}", "FILE",
232 path, "ERRNO", e);
233 throw file_error::Write();
234 }
235 }
236
remove(const LogID & id)237 std::optional<Repository::LogID> Repository::remove(const LogID& id)
238 {
239 auto pel = findPEL(id);
240 if (pel == _pelAttributes.end())
241 {
242 return std::nullopt;
243 }
244
245 LogID actualID = pel->first;
246 updateRepoStats(pel->second, false);
247
248 lg2::debug(
249 "Removing PEL from repository, PEL ID = {PEL_ID}, BMC log ID = {BMC_ID}",
250 "PEL_ID", lg2::hex, actualID.pelID.id, "BMC_ID", actualID.obmcID.id);
251
252 if (fs::exists(pel->second.path))
253 {
254 // Check for existense of new archive folder
255 if (!fs::exists(_archivePath))
256 {
257 fs::create_directories(_archivePath);
258 }
259
260 // Move log file to archive folder
261 auto fileName = _archivePath / pel->second.path.filename();
262 fs::rename(pel->second.path, fileName);
263
264 // Update size of file
265 _archiveSize += getFileDiskSize(fileName);
266 }
267
268 _pelAttributes.erase(pel);
269
270 processDeleteCallbacks(actualID.pelID.id);
271
272 return actualID;
273 }
274
getPELData(const LogID & id)275 std::optional<std::vector<uint8_t>> Repository::getPELData(const LogID& id)
276 {
277 auto pel = findPEL(id);
278 if (pel != _pelAttributes.end())
279 {
280 std::ifstream file{pel->second.path.c_str()};
281 if (!file.good())
282 {
283 auto e = errno;
284 lg2::error("Unable to open PEL file {FILE}, errno = {ERRNO}",
285 "FILE", pel->second.path, "ERRNO", e);
286 throw file_error::Open();
287 }
288
289 std::vector<uint8_t> data{std::istreambuf_iterator<char>(file),
290 std::istreambuf_iterator<char>()};
291 return data;
292 }
293
294 return std::nullopt;
295 }
296
getPELFD(const LogID & id)297 std::optional<sdbusplus::message::unix_fd> Repository::getPELFD(const LogID& id)
298 {
299 auto pel = findPEL(id);
300 if (pel != _pelAttributes.end())
301 {
302 int fd = open(pel->second.path.c_str(), O_RDONLY | O_NONBLOCK);
303 if (fd == -1)
304 {
305 auto e = errno;
306 lg2::error("Unable to open PEL file {FILE}, errno = {ERRNO}",
307 "FILE", pel->second.path, "ERRNO", e);
308 throw file_error::Open();
309 }
310
311 // Must leave the file open here. It will be closed by sdbusplus
312 // when it sends it back over D-Bus.
313 return fd;
314 }
315 return std::nullopt;
316 }
317
for_each(ForEachFunc func) const318 void Repository::for_each(ForEachFunc func) const
319 {
320 for (const auto& [id, attributes] : _pelAttributes)
321 {
322 std::ifstream file{attributes.path};
323
324 if (!file.good())
325 {
326 auto e = errno;
327 lg2::error(
328 "Repository::for_each: Unable to open PEL file {FILE}, errno = {ERRNO}",
329 "FILE", attributes.path, "ERRNO", e);
330 continue;
331 }
332
333 std::vector<uint8_t> data{std::istreambuf_iterator<char>(file),
334 std::istreambuf_iterator<char>()};
335 file.close();
336
337 PEL pel{data};
338
339 try
340 {
341 if (func(pel))
342 {
343 break;
344 }
345 }
346 catch (const std::exception& e)
347 {
348 lg2::error("Repository::for_each function exception: {ERROR}",
349 "ERROR", e);
350 }
351 }
352 }
353
processAddCallbacks(const PEL & pel) const354 void Repository::processAddCallbacks(const PEL& pel) const
355 {
356 for (auto& [name, func] : _addSubscriptions)
357 {
358 try
359 {
360 func(pel);
361 }
362 catch (const std::exception& e)
363 {
364 lg2::error(
365 "PEL Repository add callback exception. Name = {NAME}, Error = {ERROR}",
366 "NAME", name, "ERROR", e);
367 }
368 }
369 }
370
processDeleteCallbacks(uint32_t id) const371 void Repository::processDeleteCallbacks(uint32_t id) const
372 {
373 for (auto& [name, func] : _deleteSubscriptions)
374 {
375 try
376 {
377 func(id);
378 }
379 catch (const std::exception& e)
380 {
381 lg2::error(
382 "PEL Repository delete callback exception. Name = {NAME}, Error = {ERROR}",
383 "NAME", name, "ERROR", e);
384 }
385 }
386 }
387
388 std::optional<std::reference_wrapper<const Repository::PELAttributes>>
getPELAttributes(const LogID & id) const389 Repository::getPELAttributes(const LogID& id) const
390 {
391 auto pel = findPEL(id);
392 if (pel != _pelAttributes.end())
393 {
394 return pel->second;
395 }
396
397 return std::nullopt;
398 }
399
setPELHostTransState(uint32_t pelID,TransmissionState state)400 void Repository::setPELHostTransState(uint32_t pelID, TransmissionState state)
401 {
402 LogID id{LogID::Pel{pelID}};
403 auto attr = std::find_if(_pelAttributes.begin(), _pelAttributes.end(),
404 [&id](const auto& a) { return a.first == id; });
405
406 if ((attr != _pelAttributes.end()) && (attr->second.hostState != state))
407 {
408 PELUpdateFunc func = [state](PEL& pel) {
409 pel.setHostTransmissionState(state);
410 return true;
411 };
412
413 try
414 {
415 updatePEL(attr->second.path, func);
416 }
417 catch (const std::exception& e)
418 {
419 lg2::error(
420 "Unable to update PEL host transmission state. Path = {PATH}, Error = {ERROR}",
421 "PATH", attr->second.path, "ERROR", e);
422 }
423 }
424 }
425
setPELHMCTransState(uint32_t pelID,TransmissionState state)426 void Repository::setPELHMCTransState(uint32_t pelID, TransmissionState state)
427 {
428 LogID id{LogID::Pel{pelID}};
429 auto attr = std::find_if(_pelAttributes.begin(), _pelAttributes.end(),
430 [&id](const auto& a) { return a.first == id; });
431
432 if ((attr != _pelAttributes.end()) && (attr->second.hmcState != state))
433 {
434 PELUpdateFunc func = [state](PEL& pel) {
435 pel.setHMCTransmissionState(state);
436 return true;
437 };
438
439 try
440 {
441 updatePEL(attr->second.path, func);
442 }
443 catch (const std::exception& e)
444 {
445 lg2::error(
446 "Unable to update PEL HMC transmission state. Path = {PATH}, Error = {ERROR}",
447 "PATH", attr->second.path, "ERROR", e);
448 }
449 }
450 }
451
updatePEL(const fs::path & path,PELUpdateFunc updateFunc)452 bool Repository::updatePEL(const fs::path& path, PELUpdateFunc updateFunc)
453 {
454 std::ifstream file{path};
455 std::vector<uint8_t> data{std::istreambuf_iterator<char>(file),
456 std::istreambuf_iterator<char>()};
457 file.close();
458
459 PEL pel{data};
460
461 if (pel.valid())
462 {
463 if (updateFunc(pel))
464 {
465 // Three attribute fields can change post creation from
466 // an updatePEL call:
467 // - hmcTransmissionState - When HMC acks a PEL
468 // - hostTransmissionState - When host acks a PEL
469 // - deconfig flag - Can be cleared for PELs that call out
470 // hotplugged FRUs.
471 // Make sure they're up to date.
472 LogID id{LogID::Pel(pel.id())};
473 auto attr =
474 std::find_if(_pelAttributes.begin(), _pelAttributes.end(),
475 [&id](const auto& a) { return a.first == id; });
476 if (attr != _pelAttributes.end())
477 {
478 attr->second.hmcState = pel.hmcTransmissionState();
479 attr->second.hostState = pel.hostTransmissionState();
480 attr->second.deconfig = pel.getDeconfigFlag();
481 }
482
483 write(pel, path);
484 return true;
485 }
486 }
487 else
488 {
489 throw std::runtime_error(
490 "Unable to read a valid PEL when trying to update it");
491 }
492 return false;
493 }
494
isServiceableSev(const PELAttributes & pel)495 bool Repository::isServiceableSev(const PELAttributes& pel)
496 {
497 auto sevType = static_cast<SeverityType>(pel.severity & 0xF0);
498 auto sevPVEntry = pel_values::findByValue(pel.severity,
499 pel_values::severityValues);
500 std::string sevName = std::get<pel_values::registryNamePos>(*sevPVEntry);
501
502 bool check1 = (sevType == SeverityType::predictive) ||
503 (sevType == SeverityType::unrecoverable) ||
504 (sevType == SeverityType::critical);
505
506 bool check2 = ((sevType == SeverityType::recovered) ||
507 (sevName == "symptom_recovered")) &&
508 !pel.actionFlags.test(hiddenFlagBit);
509
510 bool check3 = (sevName == "symptom_predictive") ||
511 (sevName == "symptom_unrecoverable") ||
512 (sevName == "symptom_critical");
513
514 return check1 || check2 || check3;
515 }
516
updateRepoStats(const PELAttributes & pel,bool pelAdded)517 void Repository::updateRepoStats(const PELAttributes& pel, bool pelAdded)
518 {
519 auto isServiceable = Repository::isServiceableSev(pel);
520 auto bmcPEL = CreatorID::openBMC == static_cast<CreatorID>(pel.creator);
521
522 auto adjustSize = [pelAdded, &pel](auto& runningSize) {
523 if (pelAdded)
524 {
525 runningSize += pel.sizeOnDisk;
526 }
527 else
528 {
529 runningSize = std::max(static_cast<int64_t>(runningSize) -
530 static_cast<int64_t>(pel.sizeOnDisk),
531 static_cast<int64_t>(0));
532 }
533 };
534
535 adjustSize(_sizes.total);
536
537 if (bmcPEL)
538 {
539 adjustSize(_sizes.bmc);
540 if (isServiceable)
541 {
542 adjustSize(_sizes.bmcServiceable);
543 }
544 else
545 {
546 adjustSize(_sizes.bmcInfo);
547 }
548 }
549 else
550 {
551 adjustSize(_sizes.nonBMC);
552 if (isServiceable)
553 {
554 adjustSize(_sizes.nonBMCServiceable);
555 }
556 else
557 {
558 adjustSize(_sizes.nonBMCInfo);
559 }
560 }
561 }
562
sizeWarning()563 bool Repository::sizeWarning()
564 {
565 std::error_code ec;
566
567 if ((_archiveSize > 0) && ((_sizes.total + _archiveSize) >
568 ((_maxRepoSize * warningPercentage) / 100)))
569 {
570 lg2::info(
571 "Repository::sizeWarning function:Deleting the files in archive");
572
573 for (const auto& dirEntry : fs::directory_iterator(_archivePath))
574 {
575 fs::remove(dirEntry.path(), ec);
576 if (ec)
577 {
578 lg2::info("Repository::sizeWarning: Could not delete "
579 "file {FILE} in PEL archive",
580 "FILE", dirEntry.path());
581 }
582 }
583
584 _archiveSize = 0;
585 }
586
587 return (_sizes.total > (_maxRepoSize * warningPercentage / 100)) ||
588 (_pelAttributes.size() > _maxNumPELs);
589 }
590
591 std::vector<Repository::AttributesReference>
getAllPELAttributes(SortOrder order) const592 Repository::getAllPELAttributes(SortOrder order) const
593 {
594 std::vector<Repository::AttributesReference> attributes;
595
596 std::for_each(
597 _pelAttributes.begin(), _pelAttributes.end(),
598 [&attributes](auto& pelEntry) { attributes.push_back(pelEntry); });
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