1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
#pragma once
#include "additional_data.hpp"
#include "elog_entry.hpp"
#include <phosphor-logging/log.hpp>
#include <queue>
#include <sdeventplus/event.hpp>
#include <sdeventplus/source/event.hpp>
#include <tuple>
namespace openpower::pels
{
/**
* @class EventLogger
*
* This class handles creating OpenBMC event logs (and thus PELs) from
* within the PEL extension code.
*
* The function to actually create the event log is passed in via the
* constructor so that different functions can be used when testing.
*
* To create the event log, call log() with the appropriate arguments
* and the log will be created as soon as the flow gets back to the event
* loop. If the queue isn't empty after a log is created, the next
* one will be scheduled to be created from the event loop again.
*
* This class does not allow new events to be added while inside the
* creation function, because if the code added an event log every time
* it tried to create one, it would do so infinitely.
*/
class EventLogger
{
public:
using ADMap = std::map<std::string, std::string>;
using LogFunction = std::function<void(
const std::string&, phosphor::logging::Entry::Level, const ADMap&)>;
static constexpr size_t msgPos = 0;
static constexpr size_t levelPos = 1;
static constexpr size_t adPos = 2;
using EventEntry = std::tuple<std::string, phosphor::logging::Entry::Level,
AdditionalData>;
EventLogger() = delete;
~EventLogger() = default;
EventLogger(const EventLogger&) = delete;
EventLogger& operator=(const EventLogger&) = delete;
EventLogger(EventLogger&&) = delete;
EventLogger& operator=(EventLogger&&) = delete;
/**
* @brief Constructor
*
* @param[in] event - The sd_event object
* @param[in] creator - The function to use to create the event log
*/
EventLogger(sd_event* event, LogFunction creator) :
_event(event), _creator(creator)
{
}
/**
* @brief Adds an event to the queue so that it will be created
* as soon as the code makes it back to the event loop.
*
* Won't add it to the queue if already inside the create()
* callback.
*
* @param[in] message - The message property of the event log
* @param[in] severity - The severity level of the event log
* @param[in] ad - The additional data property of the event log
*/
void log(const std::string& message,
phosphor::logging::Entry::Level severity, const AdditionalData& ad)
{
if (!_inEventCreation)
{
_eventsToCreate.emplace(message, severity, ad);
if (!_eventSource)
{
scheduleCreate();
}
}
else
{
phosphor::logging::log<phosphor::logging::level::INFO>(
"Already in event create callback, skipping new create",
phosphor::logging::entry("ERROR_NAME=%s", message.c_str()));
}
}
/**
* @brief Returns the event log queue size.
*
* @return size_t - The queue size
*/
size_t queueSize() const
{
return _eventsToCreate.size();
}
/**
* @brief Schedules the create() function to run using the
* 'defer' sd_event source.
*/
void scheduleCreate()
{
_eventSource = std::make_unique<sdeventplus::source::Defer>(
_event, std::bind(std::mem_fn(&EventLogger::create), this,
std::placeholders::_1));
}
private:
/**
* @brief Creates an event log and schedules the next one if
* there is one.
*
* This gets called from the event loop by the sd_event code.
*
* @param[in] source - The event source object used
*/
void create(sdeventplus::source::EventBase& source)
{
_eventSource.reset();
if (_eventsToCreate.empty())
{
return;
}
auto event = _eventsToCreate.front();
_eventsToCreate.pop();
_inEventCreation = true;
try
{
_creator(std::get<msgPos>(event), std::get<levelPos>(event),
std::get<adPos>(event).getData());
}
catch (std::exception& e)
{
phosphor::logging::log<phosphor::logging::level::ERR>(
"EventLogger's create function threw an exception",
phosphor::logging::entry("ERROR=%s", e.what()));
}
_inEventCreation = false;
if (!_eventsToCreate.empty())
{
scheduleCreate();
}
}
/**
* @brief The sd_event object.
*/
sdeventplus::Event _event;
/**
* @brief The user supplied function to create the event log.
*/
LogFunction _creator;
/**
* @brief Keeps track of if an event is currently being created.
*
* Guards against creating new events while creating events.
*/
bool _inEventCreation = false;
/**
* @brief The event source object used for scheduling.
*/
std::unique_ptr<sdeventplus::source::Defer> _eventSource;
/**
* @brief The queue of event logs to create.
*/
std::queue<EventEntry> _eventsToCreate;
};
} // namespace openpower::pels
|
