xref: /openbmc/phosphor-logging/extensions/openpower-pels/repository.hpp (revision 8e65f4ea9ca7ce1045a4e001571b5ef9b57732c5)
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<void(PEL&)>;
449 
450     /**
451      * @brief Lets a function modify a PEL and saves the results
452      *
453      * Runs updateFunc (a void(PEL&) function) on the PEL data
454      * on the file specified, and writes the results back to the file.
455      *
456      * @param[in] path - The file path to use
457      * @param[in] updateFunc - The function to run to update the PEL.
458      */
459     void updatePEL(const std::filesystem::path& path, PELUpdateFunc updateFunc);
460 
461     /**
462      * @brief Finds an entry in the _pelAttributes map.
463      *
464      * @param[in] id - the ID (either the pel ID, OBMC ID, or both)
465      *
466      * @return an iterator to the entry
467      */
468     std::map<LogID, PELAttributes>::const_iterator
469         findPEL(const LogID& id) const
470     {
471         return std::find_if(_pelAttributes.begin(), _pelAttributes.end(),
472                             [&id](const auto& a) { return a.first == id; });
473     }
474 
475     /**
476      * @brief Call any subscribed functions for new PELs
477      *
478      * @param[in] pel - The new PEL
479      */
480     void processAddCallbacks(const PEL& pel) const;
481 
482     /**
483      * @brief Call any subscribed functions for deleted PELs
484      *
485      * @param[in] id - The ID of the deleted PEL
486      */
487     void processDeleteCallbacks(uint32_t id) const;
488 
489     /**
490      * @brief Restores the _pelAttributes map on startup based on the existing
491      *        PEL data files.
492      */
493     void restore();
494 
495     /**
496      * @brief Stores a PEL object in the filesystem.
497      *
498      * @param[in] pel - The PEL to write
499      * @param[in] path - The file to write to
500      *
501      * Throws exceptions on failures.
502      */
503     void write(const PEL& pel, const std::filesystem::path& path);
504 
505     /**
506      * @brief Updates the repository statistics after a PEL is
507      *        added or removed.
508      *
509      * @param[in] pel - The PELAttributes entry for the PEL
510      * @param[in] pelAdded - true if the PEL was added, false if removed
511      */
512     void updateRepoStats(const PELAttributes& pel, bool pelAdded);
513 
514     enum class SortOrder
515     {
516         ascending,
517         descending
518     };
519 
520     /**
521      * @brief Returns a vector of all the _pelAttributes entries sorted
522      *        as specified
523      *
524      * @param[in] order - If the PELs should be returned in ascending
525      *                    (oldest first) or descending order.
526      *
527      * @return std::vector<AttributesReference> - The sorted vector of
528      *         references to the pair<LogID, PELAttributes> entries of
529      *         _pelAttributes.
530      */
531     std::vector<AttributesReference> getAllPELAttributes(SortOrder order) const;
532 
533     using IsOverLimitFunc = std::function<bool()>;
534     using IsPELTypeFunc = std::function<bool(const PELAttributes&)>;
535 
536     /**
537      * @brief Makes 4 passes on the PELs that meet the IsPELTypeFunc
538      *        criteria removing PELs until IsOverLimitFunc returns false.
539      *
540      *   Pass 1: only delete HMC acked PELs
541      *   Pass 2: only delete Os acked PELs
542      *   Pass 3: only delete PHYP sent PELs
543      *   Pass 4: delete all PELs
544      *
545      * @param[in] isOverLimit - The bool(void) function that should
546      *                          return true if PELs still need to be
547      *                           removed.
548      * @param[in] isPELType - The bool(const PELAttributes&) function
549      *                         used to select the PELs to operate on.
550      * @param[in] ids - The OpenBMC event log Ids with hardware isolation
551      *                   entry.
552      *
553      * @param[out] removedBMCLogIDs - The OpenBMC event log IDs of the
554      *                                removed PELs.
555      */
556     void removePELs(const IsOverLimitFunc& isOverLimit,
557                     const IsPELTypeFunc& isPELType,
558                     const std::vector<uint32_t>& idsWithHwIsoEntry,
559                     std::vector<uint32_t>& removedBMCLogIDs);
560     /**
561      * @brief The filesystem path to the PEL logs.
562      */
563     const std::filesystem::path _logPath;
564 
565     /**
566      * @brief A map of the PEL/OBMC IDs to PEL attributes.
567      */
568     std::map<LogID, PELAttributes> _pelAttributes;
569 
570     /**
571      * @brief Subcriptions for new PELs.
572      */
573     std::map<std::string, AddCallback> _addSubscriptions;
574 
575     /**
576      * @brief Subscriptions for deleted PELs.
577      */
578     std::map<std::string, DeleteCallback> _deleteSubscriptions;
579 
580     /**
581      * @brief The maximum amount of space that the PELs in the
582      *        repository can occupy.
583      */
584     const uint64_t _maxRepoSize;
585 
586     /**
587      * @brief The maximum number of PELs to allow in the repo
588      *        before pruning.
589      */
590     const size_t _maxNumPELs;
591 
592     /**
593      * @brief Statistics on the sizes of the stored PELs.
594      */
595     SizeStats _sizes;
596 
597     /**
598      * @brief The ID of the most recently added PEL.
599      */
600     uint32_t _lastPelID = 0;
601 
602     /**
603      * @brief The filesystem path to the archive PEL logs.
604      */
605     const std::filesystem::path _archivePath;
606 
607     /**
608      * @brief The size of archive folder.
609      */
610     uint64_t _archiveSize = 0;
611 };
612 
613 } // namespace pels
614 } // namespace openpower
615