1 #pragma once 2 #include "bcd_time.hpp" 3 #include "paths.hpp" 4 #include "pel.hpp" 5 6 #include <algorithm> 7 #include <bitset> 8 #include <filesystem> 9 #include <map> 10 11 namespace openpower 12 { 13 namespace pels 14 { 15 16 /** 17 * @class Repository 18 * 19 * The class handles saving and retrieving PELs on the BMC. 20 */ 21 class Repository 22 { 23 public: 24 /** 25 * @brief Structure of commonly used PEL attributes. 26 */ 27 struct PELAttributes 28 { 29 std::filesystem::path path; 30 size_t sizeOnDisk; 31 uint8_t creator; 32 uint8_t subsystem; 33 uint8_t severity; 34 std::bitset<16> actionFlags; 35 TransmissionState hostState; 36 TransmissionState hmcState; 37 uint32_t plid; 38 bool deconfig; 39 bool guard; 40 uint64_t creationTime; 41 42 PELAttributes() = delete; 43 44 PELAttributes(const std::filesystem::path& p, size_t size, 45 uint8_t creator, uint8_t subsystem, uint8_t sev, 46 uint16_t flags, TransmissionState hostState, 47 TransmissionState hmcState, uint32_t plid, bool deconfig, 48 bool guard, uint64_t creationTime) : 49 path(p), 50 sizeOnDisk(size), creator(creator), subsystem(subsystem), 51 severity(sev), actionFlags(flags), hostState(hostState), 52 hmcState(hmcState), plid(plid), deconfig(deconfig), guard(guard), 53 creationTime(creationTime) 54 {} 55 }; 56 57 /** 58 * @brief A structure that holds both the PEL and corresponding 59 * OpenBMC IDs. 60 * Used for correlating the IDs with their data files for quick 61 * lookup. To find a PEL based on just one of the IDs, just use 62 * the constructor that takes that ID. 63 */ 64 struct LogID 65 { 66 struct Pel 67 { 68 uint32_t id; 69 explicit Pel(uint32_t i) : id(i) {} 70 }; 71 struct Obmc 72 { 73 uint32_t id; 74 explicit Obmc(uint32_t i) : id(i) {} 75 }; 76 77 Pel pelID; 78 79 Obmc obmcID; 80 81 LogID(Pel pel, Obmc obmc) : pelID(pel), obmcID(obmc) {} 82 83 explicit LogID(Pel id) : pelID(id), obmcID(0) {} 84 85 explicit LogID(Obmc id) : pelID(0), obmcID(id) {} 86 87 LogID() = delete; 88 89 /** 90 * @brief A == operator that will match on either ID 91 * being equal if the other is zero, so that 92 * one can look up a PEL with just one of the IDs. 93 */ 94 bool operator==(const LogID& id) const 95 { 96 if (id.pelID.id != 0) 97 { 98 return id.pelID.id == pelID.id; 99 } 100 if (id.obmcID.id != 0) 101 { 102 return id.obmcID.id == obmcID.id; 103 } 104 return false; 105 } 106 107 bool operator<(const LogID& id) const 108 { 109 return pelID.id < id.pelID.id; 110 } 111 }; 112 113 using AttributesReference = 114 std::reference_wrapper<const std::pair<const LogID, PELAttributes>>; 115 116 /** 117 * @brief A structure for keeping a breakdown of the sizes of PELs 118 * of different types in the repository. 119 */ 120 struct SizeStats 121 { 122 uint64_t total; 123 uint64_t bmc; 124 uint64_t nonBMC; 125 uint64_t bmcServiceable; 126 uint64_t bmcInfo; 127 uint64_t nonBMCServiceable; 128 uint64_t nonBMCInfo; 129 130 SizeStats() : 131 total(0), bmc(0), nonBMC(0), bmcServiceable(0), bmcInfo(0), 132 nonBMCServiceable(0), nonBMCInfo(0) 133 {} 134 }; 135 136 Repository() = delete; 137 ~Repository() = default; 138 Repository(const Repository&) = default; 139 Repository& operator=(const Repository&) = default; 140 Repository(Repository&&) = default; 141 Repository& operator=(Repository&&) = default; 142 143 /** 144 * @brief Constructor 145 * 146 * @param[in] basePath - the base filesystem path for the repository 147 */ 148 explicit Repository(const std::filesystem::path& basePath) : 149 Repository(basePath, getPELRepoSize(), getMaxNumPELs()) 150 {} 151 152 /** 153 * @brief Constructor that takes the repository size 154 * 155 * @param[in] basePath - the base filesystem path for the repository 156 * @param[in] repoSize - The maximum amount of space to use for PELs, 157 * in bytes 158 * @param[in] maxNumPELs - The maximum number of PELs to allow 159 */ 160 Repository(const std::filesystem::path& basePath, size_t repoSize, 161 size_t maxNumPELs); 162 163 /** 164 * @brief Adds a PEL to the repository 165 * 166 * Throws File.Error.Open or File.Error.Write exceptions on failure 167 * 168 * @param[in] pel - the PEL to add 169 */ 170 void add(std::unique_ptr<PEL>& pel); 171 172 /** 173 * @brief Removes a PEL from the repository 174 * 175 * Note that the returned LogID is the fully filled in LogID, i.e. 176 * it has both the PEL and OpenBMC IDs, unlike the passed in LogID 177 * which can just have one or the other. 178 * 179 * @param[in] id - the ID (either the pel ID, OBMC ID, or both) to remove 180 * 181 * @return std::optional<LogID> - The LogID of the removed PEL 182 */ 183 std::optional<LogID> remove(const LogID& id); 184 185 /** 186 * @brief Generates the filename to use for the PEL ID and BCDTime. 187 * 188 * @param[in] pelID - the PEL ID 189 * @param[in] time - the BCD time 190 * 191 * @return string - A filename string of <BCD_time>_<pelID> 192 */ 193 static std::string getPELFilename(uint32_t pelID, const BCDTime& time); 194 195 /** 196 * @brief Returns true if the PEL with the specified ID is in the repo. 197 * 198 * @param[in] id - the ID (either the pel ID, OBMC ID, or both) 199 * @return bool - true if that PEL is present 200 */ 201 inline bool hasPEL(const LogID& id) 202 { 203 return findPEL(id) != _pelAttributes.end(); 204 } 205 206 /** 207 * @brief Returns the PEL data based on its ID. 208 * 209 * If the data can't be found for that ID, then the optional object 210 * will be empty. 211 * 212 * @param[in] id - the LogID to get the PEL for, which can be either a 213 * PEL ID or OpenBMC log ID. 214 * @return std::optional<std::vector<uint8_t>> - the PEL data 215 */ 216 std::optional<std::vector<uint8_t>> getPELData(const LogID& id); 217 218 /** 219 * @brief Get a file descriptor to the PEL data 220 * 221 * @param[in] id - The ID to get the FD for 222 * 223 * @return std::optional<sdbusplus::message::unix_fd> - 224 * The FD, or an empty optional object. 225 */ 226 std::optional<sdbusplus::message::unix_fd> getPELFD(const LogID& id); 227 228 using ForEachFunc = std::function<bool(const PEL&)>; 229 230 /** 231 * @brief Run a user defined function on every PEL in the repository. 232 * 233 * ForEachFunc takes a const PEL reference, and should return 234 * true to stop iterating and return out of for_each. 235 * 236 * For example, to save up to 100 IDs in the repo into a vector: 237 * 238 * std::vector<uint32_t> ids; 239 * ForEachFunc f = [&ids](const PEL& pel) { 240 * ids.push_back(pel.id()); 241 * return ids.size() == 100 ? true : false; 242 * }; 243 * 244 * @param[in] func - The function to run. 245 */ 246 void for_each(ForEachFunc func) const; 247 248 using AddCallback = std::function<void(const PEL&)>; 249 250 /** 251 * @brief Subscribe to PELs being added to the repository. 252 * 253 * Every time a PEL is added to the repository, the provided 254 * function will be called with the new PEL as the argument. 255 * 256 * The function must be of type void(const PEL&). 257 * 258 * @param[in] name - The subscription name 259 * @param[in] func - The callback function 260 */ 261 void subscribeToAdds(const std::string& name, AddCallback func) 262 { 263 _addSubscriptions.emplace(name, func); 264 } 265 266 /** 267 * @brief Unsubscribe from new PELs. 268 * 269 * @param[in] name - The subscription name 270 */ 271 void unsubscribeFromAdds(const std::string& name) 272 { 273 _addSubscriptions.erase(name); 274 } 275 276 using DeleteCallback = std::function<void(uint32_t)>; 277 278 /** 279 * @brief Subscribe to PELs being deleted from the repository. 280 * 281 * Every time a PEL is deleted from the repository, the provided 282 * function will be called with the PEL ID as the argument. 283 * 284 * The function must be of type void(const uint32_t). 285 * 286 * @param[in] name - The subscription name 287 * @param[in] func - The callback function 288 */ 289 void subscribeToDeletes(const std::string& name, DeleteCallback func) 290 { 291 _deleteSubscriptions.emplace(name, func); 292 } 293 294 /** 295 * @brief Unsubscribe from deleted PELs. 296 * 297 * @param[in] name - The subscription name 298 */ 299 void unsubscribeFromDeletes(const std::string& name) 300 { 301 _deleteSubscriptions.erase(name); 302 } 303 304 /** 305 * @brief Get the PEL attributes for a PEL 306 * 307 * @param[in] id - The ID to find the attributes for 308 * 309 * @return The attributes or an empty optional if not found 310 */ 311 std::optional<std::reference_wrapper<const PELAttributes>> 312 getPELAttributes(const LogID& id) const; 313 314 /** 315 * @brief Sets the host transmission state on a PEL file 316 * 317 * Writes the host transmission state field in the User Header 318 * section in the PEL data specified by the ID. 319 * 320 * @param[in] pelID - The PEL ID 321 * @param[in] state - The state to write 322 */ 323 void setPELHostTransState(uint32_t pelID, TransmissionState state); 324 325 /** 326 * @brief Sets the HMC transmission state on a PEL file 327 * 328 * Writes the HMC transmission state field in the User Header 329 * section in the PEL data specified by the ID. 330 * 331 * @param[in] pelID - The PEL ID 332 * @param[in] state - The state to write 333 */ 334 void setPELHMCTransState(uint32_t pelID, TransmissionState state); 335 336 /** 337 * @brief Returns the size stats structure 338 * 339 * @return const SizeStats& - The stats structure 340 */ 341 const SizeStats& getSizeStats() const 342 { 343 return _sizes; 344 } 345 346 /** 347 * @brief Says if the PEL is considered serviceable (not just 348 * informational) as determined by its severity. 349 * 350 * @param[in] pel - The PELAttributes entry for the PEL 351 * @return bool - If serviceable or not 352 */ 353 static bool isServiceableSev(const PELAttributes& pel); 354 355 /** 356 * @brief Returns true if the total amount of disk space occupied 357 * by the PELs in the repo is over 95% of the maximum 358 * size, or if there are over the maximum number of 359 * PELs allowed. 360 * 361 * @return bool - true if repo is > 95% full or too many PELs 362 */ 363 bool sizeWarning(); 364 365 /** 366 * @brief Deletes PELs to bring the repository size down 367 * to at most 90% full by placing PELs into 4 different 368 * catogories and then removing PELs until those catogories 369 * only take up certain percentages of the allowed space. 370 * 371 * This does not delete the corresponding OpenBMC event logs, which 372 * is why those IDs are returned, so they can be deleted later. 373 * 374 * The categories and their rules are: 375 * 1) Informational BMC PELs cannot take up more than 15% of 376 * the allocated space. 377 * 2) Non-informational BMC PELs cannot take up more than 30% 378 * of the allocated space. 379 * 3) Informational non-BMC PELs cannot take up more than 15% of 380 * the allocated space. 381 * 4) Non-informational non-BMC PELs cannot take up more than 30% 382 * of the allocated space. 383 * 384 * While removing PELs in a category, 4 passes will be made, with 385 * PELs being removed oldest first during each pass. 386 * 387 * Pass 1: only delete HMC acked PELs 388 * Pass 2: only delete OS acked PELs 389 * Pass 3: only delete PHYP sent PELs 390 * Pass 4: delete all PELs 391 * 392 * @param[in] ids - The OpenBMC event log Ids with hardware isolation entry. 393 * 394 * @return std::vector<uint32_t> - The OpenBMC event log IDs of 395 * the PELs that were deleted. 396 */ 397 std::vector<uint32_t> prune(const std::vector<uint32_t>& idsWithHwIsoEntry); 398 399 /** 400 * @brief Returns the path to the directory where the PEL 401 * files are stored. 402 * 403 * @return std::filesystem::path - The directory path 404 */ 405 const std::filesystem::path& repoPath() const 406 { 407 return _logPath; 408 } 409 410 /** 411 * @brief Returns the ID of the most recently added PEL. 412 * 413 * @return uint32_t - The PEL ID 414 */ 415 uint32_t lastPelID() const 416 { 417 return _lastPelID; 418 } 419 420 /** 421 * @brief Get the LogID based on the given ObmcLogId or PelId. 422 * 423 * @param[in] id - The ID to find the LogID. 424 * 425 * @return The LogID or an empty optional if not found. 426 * 427 * @note The returned LogID is the fully filled in LogID, i.e. 428 * it has both the PEL and OpenBMC Log IDs, unlike the passed in LogID 429 * which can just have one or the other. 430 */ 431 std::optional<LogID> getLogID(const LogID& id) const 432 { 433 if (auto logID = findPEL(id); logID != _pelAttributes.end()) 434 { 435 return logID->first; 436 } 437 return std::nullopt; 438 } 439 440 /** 441 * @brief Save the PEL to archive folder 442 * 443 * @param[in] pel - The PEL data 444 */ 445 void archivePEL(const PEL& pel); 446 447 private: 448 using PELUpdateFunc = std::function<bool(PEL&)>; 449 450 /** 451 * @brief Lets a function modify a PEL and saves the results 452 * 453 * Runs updateFunc (a bool(PEL&) function) on the PEL data 454 * on the file specified, and writes the results back to the file 455 * if the function returned true. 456 * 457 * @param[in] path - The file path to use 458 * @param[in] updateFunc - The function to run to update the PEL. 459 */ 460 void updatePEL(const std::filesystem::path& path, PELUpdateFunc updateFunc); 461 462 /** 463 * @brief Finds an entry in the _pelAttributes map. 464 * 465 * @param[in] id - the ID (either the pel ID, OBMC ID, or both) 466 * 467 * @return an iterator to the entry 468 */ 469 std::map<LogID, PELAttributes>::const_iterator 470 findPEL(const LogID& id) const 471 { 472 return std::find_if(_pelAttributes.begin(), _pelAttributes.end(), 473 [&id](const auto& a) { return a.first == id; }); 474 } 475 476 /** 477 * @brief Call any subscribed functions for new PELs 478 * 479 * @param[in] pel - The new PEL 480 */ 481 void processAddCallbacks(const PEL& pel) const; 482 483 /** 484 * @brief Call any subscribed functions for deleted PELs 485 * 486 * @param[in] id - The ID of the deleted PEL 487 */ 488 void processDeleteCallbacks(uint32_t id) const; 489 490 /** 491 * @brief Restores the _pelAttributes map on startup based on the existing 492 * PEL data files. 493 */ 494 void restore(); 495 496 /** 497 * @brief Stores a PEL object in the filesystem. 498 * 499 * @param[in] pel - The PEL to write 500 * @param[in] path - The file to write to 501 * 502 * Throws exceptions on failures. 503 */ 504 void write(const PEL& pel, const std::filesystem::path& path); 505 506 /** 507 * @brief Updates the repository statistics after a PEL is 508 * added or removed. 509 * 510 * @param[in] pel - The PELAttributes entry for the PEL 511 * @param[in] pelAdded - true if the PEL was added, false if removed 512 */ 513 void updateRepoStats(const PELAttributes& pel, bool pelAdded); 514 515 enum class SortOrder 516 { 517 ascending, 518 descending 519 }; 520 521 /** 522 * @brief Returns a vector of all the _pelAttributes entries sorted 523 * as specified 524 * 525 * @param[in] order - If the PELs should be returned in ascending 526 * (oldest first) or descending order. 527 * 528 * @return std::vector<AttributesReference> - The sorted vector of 529 * references to the pair<LogID, PELAttributes> entries of 530 * _pelAttributes. 531 */ 532 std::vector<AttributesReference> getAllPELAttributes(SortOrder order) const; 533 534 using IsOverLimitFunc = std::function<bool()>; 535 using IsPELTypeFunc = std::function<bool(const PELAttributes&)>; 536 537 /** 538 * @brief Makes 4 passes on the PELs that meet the IsPELTypeFunc 539 * criteria removing PELs until IsOverLimitFunc returns false. 540 * 541 * Pass 1: only delete HMC acked PELs 542 * Pass 2: only delete Os acked PELs 543 * Pass 3: only delete PHYP sent PELs 544 * Pass 4: delete all PELs 545 * 546 * @param[in] isOverLimit - The bool(void) function that should 547 * return true if PELs still need to be 548 * removed. 549 * @param[in] isPELType - The bool(const PELAttributes&) function 550 * used to select the PELs to operate on. 551 * @param[in] ids - The OpenBMC event log Ids with hardware isolation 552 * entry. 553 * 554 * @param[out] removedBMCLogIDs - The OpenBMC event log IDs of the 555 * removed PELs. 556 */ 557 void removePELs(const IsOverLimitFunc& isOverLimit, 558 const IsPELTypeFunc& isPELType, 559 const std::vector<uint32_t>& idsWithHwIsoEntry, 560 std::vector<uint32_t>& removedBMCLogIDs); 561 /** 562 * @brief The filesystem path to the PEL logs. 563 */ 564 const std::filesystem::path _logPath; 565 566 /** 567 * @brief A map of the PEL/OBMC IDs to PEL attributes. 568 */ 569 std::map<LogID, PELAttributes> _pelAttributes; 570 571 /** 572 * @brief Subcriptions for new PELs. 573 */ 574 std::map<std::string, AddCallback> _addSubscriptions; 575 576 /** 577 * @brief Subscriptions for deleted PELs. 578 */ 579 std::map<std::string, DeleteCallback> _deleteSubscriptions; 580 581 /** 582 * @brief The maximum amount of space that the PELs in the 583 * repository can occupy. 584 */ 585 const uint64_t _maxRepoSize; 586 587 /** 588 * @brief The maximum number of PELs to allow in the repo 589 * before pruning. 590 */ 591 const size_t _maxNumPELs; 592 593 /** 594 * @brief Statistics on the sizes of the stored PELs. 595 */ 596 SizeStats _sizes; 597 598 /** 599 * @brief The ID of the most recently added PEL. 600 */ 601 uint32_t _lastPelID = 0; 602 603 /** 604 * @brief The filesystem path to the archive PEL logs. 605 */ 606 const std::filesystem::path _archivePath; 607 608 /** 609 * @brief The size of archive folder. 610 */ 611 uint64_t _archiveSize = 0; 612 }; 613 614 } // namespace pels 615 } // namespace openpower 616