xref: /openbmc/phosphor-logging/extensions/openpower-pels/repository.hpp (revision d0ccda3c2a36625d30a6c3b70ed0216694102fed)
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