blob: b225e30fb46f0d34d750796fe4de7cc7655876ac [file] [log] [blame]
Patrick Venture3a5071a2018-09-12 13:27:42 -07001#include "storagehandler.hpp"
2
3#include "fruread.hpp"
4#include "read_fru_data.hpp"
5#include "selutility.hpp"
6#include "sensorhandler.hpp"
7#include "storageaddsel.hpp"
Patrick Venture3a5071a2018-09-12 13:27:42 -07008
Lei YU52d91242017-10-17 22:52:28 +08009#include <arpa/inet.h>
Patrick Venture3a5071a2018-09-12 13:27:42 -070010#include <mapper.h>
11#include <systemd/sd-bus.h>
Patrick Venture0b02be92018-08-31 11:55:55 -070012
13#include <algorithm>
Lei YU52d91242017-10-17 22:52:28 +080014#include <chrono>
15#include <cstdio>
Patrick Ventureb51bf9c2018-09-10 15:53:14 -070016#include <cstring>
Vernon Mauerybdda8002019-02-26 10:18:51 -080017#include <filesystem>
Vernon Mauerye08fbff2019-04-03 09:19:34 -070018#include <ipmid/api.hpp>
Vernon Mauery6a98fe72019-03-11 15:57:48 -070019#include <ipmid/utils.hpp>
Lei YUa0bb2a32021-09-24 11:03:56 +080020#include <optional>
Patrick Venture3a5071a2018-09-12 13:27:42 -070021#include <phosphor-logging/elog-errors.hpp>
Lotus Xu57d35572021-01-24 11:13:13 +080022#include <phosphor-logging/elog.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070023#include <phosphor-logging/log.hpp>
24#include <sdbusplus/server.hpp>
25#include <string>
Vernon Mauery16b86932019-05-01 08:36:11 -070026#include <variant>
Patrick Venture3a5071a2018-09-12 13:27:42 -070027#include <xyz/openbmc_project/Common/error.hpp>
Lotus Xu57d35572021-01-24 11:13:13 +080028#include <xyz/openbmc_project/Logging/SEL/error.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070029
Chris Austenb4f5b922015-10-13 12:44:43 -050030void register_netfn_storage_functions() __attribute__((constructor));
31
Patrick Venture0b02be92018-08-31 11:55:55 -070032unsigned int g_sel_time = 0xFFFFFFFF;
Patrick Venturedb0cbe62019-09-09 14:47:22 -070033namespace ipmi
34{
35namespace sensor
36{
37extern const IdInfoMap sensors;
38} // namespace sensor
39} // namespace ipmi
Lotus Xu57d35572021-01-24 11:13:13 +080040extern const ipmi::sensor::InvObjectIDMap invSensors;
Dhruvaraj Subhashchandrane66c3b02018-02-07 01:21:56 -060041extern const FruMap frus;
anil kumar appana2c7db1d2019-05-28 11:20:19 +000042constexpr uint8_t eventDataSize = 3;
Patrick Venture0b02be92018-08-31 11:55:55 -070043namespace
44{
Lei YUe8939392017-06-15 10:45:05 +080045constexpr auto TIME_INTERFACE = "xyz.openbmc_project.Time.EpochTime";
George Liu4d623e92020-05-25 16:51:57 +080046constexpr auto BMC_TIME_PATH = "/xyz/openbmc_project/time/bmc";
Lei YUe8939392017-06-15 10:45:05 +080047constexpr auto DBUS_PROPERTIES = "org.freedesktop.DBus.Properties";
Patrick Venture0b02be92018-08-31 11:55:55 -070048constexpr auto PROPERTY_ELAPSED = "Elapsed";
Lei YUe8939392017-06-15 10:45:05 +080049
Lei YUd9555252021-09-14 20:30:41 +080050constexpr auto logWatchPath = "/xyz/openbmc_project/logging";
Lei YUd9e57662021-09-14 18:06:28 +080051constexpr auto logBasePath = "/xyz/openbmc_project/logging/entry";
52constexpr auto logEntryIntf = "xyz.openbmc_project.Logging.Entry";
53constexpr auto logDeleteIntf = "xyz.openbmc_project.Object.Delete";
Patrick Venture0b02be92018-08-31 11:55:55 -070054} // namespace
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +053055
Tom Joseph6f7deaa2017-06-30 19:03:54 +053056using InternalFailure =
Patrick Venture0b02be92018-08-31 11:55:55 -070057 sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
Tom Joseph6f7deaa2017-06-30 19:03:54 +053058using namespace phosphor::logging;
Marri Devender Raocac383b2017-07-03 13:24:27 -050059using namespace ipmi::fru;
Lotus Xu57d35572021-01-24 11:13:13 +080060using namespace xyz::openbmc_project::Logging::SEL;
61using SELCreated =
62 sdbusplus::xyz::openbmc_project::Logging::SEL::Error::Created;
Marri Devender Raocac383b2017-07-03 13:24:27 -050063
Lei YUd9e57662021-09-14 18:06:28 +080064using SELRecordID = uint16_t;
65using SELEntry = ipmi::sel::SELEventRecordFormat;
66using SELCacheMap = std::map<SELRecordID, SELEntry>;
67
68SELCacheMap selCacheMap __attribute__((init_priority(101)));
Lei YU3df36612021-09-15 11:41:11 +080069bool selCacheMapInitialized;
Lei YUd9555252021-09-14 20:30:41 +080070std::unique_ptr<sdbusplus::bus::match::match> selAddedMatch
71 __attribute__((init_priority(101)));
Lei YUb6b72b02021-09-14 21:06:05 +080072std::unique_ptr<sdbusplus::bus::match::match> selRemovedMatch
73 __attribute__((init_priority(101)));
Lei YU4106e422021-09-15 10:55:51 +080074std::unique_ptr<sdbusplus::bus::match::match> selUpdatedMatch
75 __attribute__((init_priority(101)));
Lei YUd9e57662021-09-14 18:06:28 +080076
Lei YUb6b72b02021-09-14 21:06:05 +080077static inline uint16_t getLoggingId(const std::string& p)
Lei YUd9e57662021-09-14 18:06:28 +080078{
79 namespace fs = std::filesystem;
80 fs::path entryPath(p);
Lei YUb6b72b02021-09-14 21:06:05 +080081 return std::stoul(entryPath.filename().string());
82}
83
Lei YUeba8e9a2021-09-15 13:16:17 +080084static inline std::string getLoggingObjPath(uint16_t id)
85{
86 return std::string(ipmi::sel::logBasePath) + "/" + std::to_string(id);
87}
88
Lei YUa0bb2a32021-09-24 11:03:56 +080089std::optional<std::pair<uint16_t, SELEntry>>
90 parseLoggingEntry(const std::string& p)
Lei YUb6b72b02021-09-14 21:06:05 +080091{
Lei YU3df36612021-09-15 11:41:11 +080092 try
93 {
Lei YUa0bb2a32021-09-24 11:03:56 +080094 auto id = getLoggingId(p);
95 ipmi::sel::GetSELEntryResponse record{};
Lei YU3df36612021-09-15 11:41:11 +080096 record = ipmi::sel::convertLogEntrytoSEL(p);
Lei YUa0bb2a32021-09-24 11:03:56 +080097 return std::pair<uint16_t, SELEntry>({id, std::move(record.event)});
Lei YU3df36612021-09-15 11:41:11 +080098 }
99 catch (const std::exception& e)
100 {
101 fprintf(stderr, "Failed to convert %s to SEL: %s\n", p.c_str(),
102 e.what());
103 }
Lei YUa0bb2a32021-09-24 11:03:56 +0800104 return std::nullopt;
Lei YUd9e57662021-09-14 18:06:28 +0800105}
106
Lei YUd9555252021-09-14 20:30:41 +0800107static void selAddedCallback(sdbusplus::message::message& m)
108{
109 sdbusplus::message::object_path objPath;
110 try
111 {
112 m.read(objPath);
113 }
114 catch (const sdbusplus::exception::exception& e)
115 {
116 log<level::ERR>("Failed to read object path");
117 return;
118 }
119 std::string p = objPath;
Lei YUa0bb2a32021-09-24 11:03:56 +0800120 auto entry = parseLoggingEntry(p);
121 if (entry)
122 {
123 selCacheMap.insert(std::move(*entry));
124 }
Lei YUd9555252021-09-14 20:30:41 +0800125}
126
Lei YUb6b72b02021-09-14 21:06:05 +0800127static void selRemovedCallback(sdbusplus::message::message& m)
128{
129 sdbusplus::message::object_path objPath;
130 try
131 {
132 m.read(objPath);
133 }
134 catch (const sdbusplus::exception::exception& e)
135 {
136 log<level::ERR>("Failed to read object path");
Lei YUb6b72b02021-09-14 21:06:05 +0800137 }
Lei YUa0bb2a32021-09-24 11:03:56 +0800138 try
139 {
140 std::string p = objPath;
141 selCacheMap.erase(getLoggingId(p));
142 }
143 catch (const std::invalid_argument& e)
144 {
145 log<level::ERR>("Invalid logging entry ID");
146 }
Lei YUb6b72b02021-09-14 21:06:05 +0800147}
148
Lei YU4106e422021-09-15 10:55:51 +0800149static void selUpdatedCallback(sdbusplus::message::message& m)
150{
151 std::string p = m.get_path();
152 auto entry = parseLoggingEntry(p);
Lei YUa0bb2a32021-09-24 11:03:56 +0800153 if (entry)
154 {
155 selCacheMap.insert_or_assign(entry->first, std::move(entry->second));
156 }
Lei YU4106e422021-09-15 10:55:51 +0800157}
158
Lei YUd9555252021-09-14 20:30:41 +0800159void registerSelCallbackHandler()
160{
161 using namespace sdbusplus::bus::match::rules;
162 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
163 if (!selAddedMatch)
164 {
165 selAddedMatch = std::make_unique<sdbusplus::bus::match::match>(
166 bus, interfacesAdded(logWatchPath),
167 std::bind(selAddedCallback, std::placeholders::_1));
168 }
Lei YUb6b72b02021-09-14 21:06:05 +0800169 if (!selRemovedMatch)
170 {
171 selRemovedMatch = std::make_unique<sdbusplus::bus::match::match>(
172 bus, interfacesRemoved(logWatchPath),
173 std::bind(selRemovedCallback, std::placeholders::_1));
174 }
Lei YU4106e422021-09-15 10:55:51 +0800175 if (!selUpdatedMatch)
176 {
177 selUpdatedMatch = std::make_unique<sdbusplus::bus::match::match>(
178 bus,
179 type::signal() + member("PropertiesChanged"s) +
180 interface("org.freedesktop.DBus.Properties"s) +
181 argN(0, logEntryIntf),
182 std::bind(selUpdatedCallback, std::placeholders::_1));
183 }
Lei YUd9555252021-09-14 20:30:41 +0800184}
185
Lei YUd9e57662021-09-14 18:06:28 +0800186void initSELCache()
187{
Lei YUeba8e9a2021-09-15 13:16:17 +0800188 ipmi::sel::ObjectPaths paths;
Lei YUd9e57662021-09-14 18:06:28 +0800189 try
190 {
Lei YUeba8e9a2021-09-15 13:16:17 +0800191 ipmi::sel::readLoggingObjectPaths(paths);
Lei YUd9e57662021-09-14 18:06:28 +0800192 }
193 catch (const sdbusplus::exception::exception& e)
194 {
195 log<level::ERR>("Failed to get logging object paths");
196 return;
197 }
Lei YUeba8e9a2021-09-15 13:16:17 +0800198 for (const auto& p : paths)
Lei YUd9e57662021-09-14 18:06:28 +0800199 {
Lei YUa0bb2a32021-09-24 11:03:56 +0800200 auto entry = parseLoggingEntry(p);
201 if (entry)
202 {
203 selCacheMap.insert(std::move(*entry));
204 }
Lei YUd9e57662021-09-14 18:06:28 +0800205 }
Lei YUd9555252021-09-14 20:30:41 +0800206 registerSelCallbackHandler();
Lei YU3df36612021-09-15 11:41:11 +0800207 selCacheMapInitialized = true;
Lei YUd9e57662021-09-14 18:06:28 +0800208}
209
Marri Devender Raocac383b2017-07-03 13:24:27 -0500210/**
211 * @enum Device access mode
212 */
213enum class AccessMode
214{
215 bytes, ///< Device is accessed by bytes
216 words ///< Device is accessed by words
217};
218
jayaprakash Mutyalab7557722019-05-02 21:13:30 +0000219/** @brief implements the get SEL Info command
220 * @returns IPMI completion code plus response data
221 * - selVersion - SEL revision
222 * - entries - Number of log entries in SEL.
223 * - freeSpace - Free Space in bytes.
224 * - addTimeStamp - Most recent addition timestamp
225 * - eraseTimeStamp - Most recent erase timestamp
226 * - operationSupport - Reserve & Delete SEL operations supported
227 */
228
229ipmi::RspType<uint8_t, // SEL revision.
230 uint16_t, // number of log entries in SEL.
231 uint16_t, // free Space in bytes.
232 uint32_t, // most recent addition timestamp
233 uint32_t, // most recent erase timestamp.
234
235 bool, // SEL allocation info supported
236 bool, // reserve SEL supported
237 bool, // partial Add SEL Entry supported
238 bool, // delete SEL supported
239 uint3_t, // reserved
240 bool // overflow flag
241 >
242 ipmiStorageGetSelInfo()
Tom Joseph6f7deaa2017-06-30 19:03:54 +0530243{
jayaprakash Mutyalab7557722019-05-02 21:13:30 +0000244 uint16_t entries = 0;
245 // Most recent addition timestamp.
246 uint32_t addTimeStamp = ipmi::sel::invalidTimeStamp;
Tom Joseph6f7deaa2017-06-30 19:03:54 +0530247
Lei YUeba8e9a2021-09-15 13:16:17 +0800248 if (!selCacheMapInitialized)
Tom Josephe59abfb2018-08-06 18:46:27 +0530249 {
Lei YUeba8e9a2021-09-15 13:16:17 +0800250 // In case the initSELCache() fails, try it again
251 initSELCache();
Tom Josephe59abfb2018-08-06 18:46:27 +0530252 }
Lei YUeba8e9a2021-09-15 13:16:17 +0800253 if (!selCacheMap.empty())
Tom Josephe59abfb2018-08-06 18:46:27 +0530254 {
Lei YUeba8e9a2021-09-15 13:16:17 +0800255 entries = static_cast<uint16_t>(selCacheMap.size());
Tom Joseph6f7deaa2017-06-30 19:03:54 +0530256
257 try
258 {
Lei YUeba8e9a2021-09-15 13:16:17 +0800259 auto objPath = getLoggingObjPath(selCacheMap.rbegin()->first);
jayaprakash Mutyalab7557722019-05-02 21:13:30 +0000260 addTimeStamp = static_cast<uint32_t>(
Lei YUeba8e9a2021-09-15 13:16:17 +0800261 (ipmi::sel::getEntryTimeStamp(objPath).count()));
Tom Joseph6f7deaa2017-06-30 19:03:54 +0530262 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -0500263 catch (const InternalFailure& e)
Tom Joseph6f7deaa2017-06-30 19:03:54 +0530264 {
265 }
266 catch (const std::runtime_error& e)
267 {
268 log<level::ERR>(e.what());
269 }
270 }
271
jayaprakash Mutyalab7557722019-05-02 21:13:30 +0000272 constexpr uint8_t selVersion = ipmi::sel::selVersion;
273 constexpr uint16_t freeSpace = 0xFFFF;
274 constexpr uint32_t eraseTimeStamp = ipmi::sel::invalidTimeStamp;
275 constexpr uint3_t reserved{0};
Tom Joseph6f7deaa2017-06-30 19:03:54 +0530276
jayaprakash Mutyalab7557722019-05-02 21:13:30 +0000277 return ipmi::responseSuccess(
278 selVersion, entries, freeSpace, addTimeStamp, eraseTimeStamp,
279 ipmi::sel::operationSupport::getSelAllocationInfo,
280 ipmi::sel::operationSupport::reserveSel,
281 ipmi::sel::operationSupport::partialAddSelEntry,
282 ipmi::sel::operationSupport::deleteSel, reserved,
283 ipmi::sel::operationSupport::overflow);
Tom Joseph6f7deaa2017-06-30 19:03:54 +0530284}
285
Tom Josepha4953392017-06-30 19:09:47 +0530286ipmi_ret_t getSELEntry(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
287 ipmi_request_t request, ipmi_response_t response,
288 ipmi_data_len_t data_len, ipmi_context_t context)
289{
Jason M. Bills851acb12019-02-04 14:06:57 -0800290 if (*data_len != sizeof(ipmi::sel::GetSELEntryRequest))
291 {
292 *data_len = 0;
293 return IPMI_CC_REQ_DATA_LEN_INVALID;
294 }
295
Patrick Venture0b02be92018-08-31 11:55:55 -0700296 auto requestData =
297 reinterpret_cast<const ipmi::sel::GetSELEntryRequest*>(request);
Tom Josepha4953392017-06-30 19:09:47 +0530298
299 if (requestData->reservationID != 0)
300 {
Jason M. Bills13e67c82018-09-10 14:12:16 -0700301 if (!checkSELReservation(requestData->reservationID))
Tom Josepha4953392017-06-30 19:09:47 +0530302 {
303 *data_len = 0;
304 return IPMI_CC_INVALID_RESERVATION_ID;
305 }
306 }
307
Lei YU3df36612021-09-15 11:41:11 +0800308 if (!selCacheMapInitialized)
309 {
310 // In case the initSELCache() fails, try it again
311 initSELCache();
312 }
313
314 if (selCacheMap.empty())
Tom Josepha4953392017-06-30 19:09:47 +0530315 {
316 *data_len = 0;
317 return IPMI_CC_SENSOR_INVALID;
318 }
319
Lei YU3df36612021-09-15 11:41:11 +0800320 SELCacheMap::const_iterator iter;
Tom Josepha4953392017-06-30 19:09:47 +0530321
322 // Check for the requested SEL Entry.
323 if (requestData->selRecordID == ipmi::sel::firstEntry)
324 {
Lei YU3df36612021-09-15 11:41:11 +0800325 iter = selCacheMap.begin();
Tom Josepha4953392017-06-30 19:09:47 +0530326 }
327 else if (requestData->selRecordID == ipmi::sel::lastEntry)
328 {
Lei YU3df36612021-09-15 11:41:11 +0800329 if (selCacheMap.size() > 1)
330 {
331 iter = selCacheMap.end();
332 --iter;
333 }
334 else
335 {
336 // Only one entry exists, return the first
337 iter = selCacheMap.begin();
338 }
Tom Josepha4953392017-06-30 19:09:47 +0530339 }
340 else
341 {
Lei YU3df36612021-09-15 11:41:11 +0800342 iter = selCacheMap.find(requestData->selRecordID);
343 if (iter == selCacheMap.end())
Tom Josepha4953392017-06-30 19:09:47 +0530344 {
345 *data_len = 0;
346 return IPMI_CC_SENSOR_INVALID;
347 }
348 }
349
Lei YU3df36612021-09-15 11:41:11 +0800350 ipmi::sel::GetSELEntryResponse record{0, iter->second};
Tom Josepha4953392017-06-30 19:09:47 +0530351 // Identify the next SEL record ID
Lei YU3df36612021-09-15 11:41:11 +0800352 ++iter;
353 if (iter == selCacheMap.end())
Tom Josepha4953392017-06-30 19:09:47 +0530354 {
Lei YU3df36612021-09-15 11:41:11 +0800355 record.nextRecordID = ipmi::sel::lastEntry;
Tom Josepha4953392017-06-30 19:09:47 +0530356 }
357 else
358 {
Lei YU3df36612021-09-15 11:41:11 +0800359 record.nextRecordID = iter->first;
Tom Josepha4953392017-06-30 19:09:47 +0530360 }
361
362 if (requestData->readLength == ipmi::sel::entireRecord)
363 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700364 std::memcpy(response, &record, sizeof(record));
Tom Josepha4953392017-06-30 19:09:47 +0530365 *data_len = sizeof(record);
366 }
367 else
368 {
369 if (requestData->offset >= ipmi::sel::selRecordSize ||
370 requestData->readLength > ipmi::sel::selRecordSize)
371 {
372 *data_len = 0;
373 return IPMI_CC_INVALID_FIELD_REQUEST;
374 }
375
376 auto diff = ipmi::sel::selRecordSize - requestData->offset;
Patrick Venture0b02be92018-08-31 11:55:55 -0700377 auto readLength =
378 std::min(diff, static_cast<int>(requestData->readLength));
Tom Josepha4953392017-06-30 19:09:47 +0530379
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700380 std::memcpy(response, &record.nextRecordID,
381 sizeof(record.nextRecordID));
382 std::memcpy(static_cast<uint8_t*>(response) +
383 sizeof(record.nextRecordID),
Lei YUaf378fa2020-12-02 16:28:57 +0800384 &record.event.eventRecord.recordID + requestData->offset,
385 readLength);
Tom Josepha4953392017-06-30 19:09:47 +0530386 *data_len = sizeof(record.nextRecordID) + readLength;
387 }
388
389 return IPMI_CC_OK;
390}
391
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000392/** @brief implements the delete SEL entry command
393 * @request
394 * - reservationID; // reservation ID.
395 * - selRecordID; // SEL record ID.
396 *
397 * @returns ipmi completion code plus response data
398 * - Record ID of the deleted record
399 */
400ipmi::RspType<uint16_t // deleted record ID
401 >
402 deleteSELEntry(uint16_t reservationID, uint16_t selRecordID)
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530403{
Jason M. Bills851acb12019-02-04 14:06:57 -0800404
Brad Bishop1a4117b2018-11-21 15:48:18 -0500405 namespace fs = std::filesystem;
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530406
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000407 if (!checkSELReservation(reservationID))
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530408 {
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000409 return ipmi::responseInvalidReservationId();
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530410 }
411
Jason M. Bills13e67c82018-09-10 14:12:16 -0700412 // Per the IPMI spec, need to cancel the reservation when a SEL entry is
413 // deleted
414 cancelSELReservation();
415
Lei YUeba8e9a2021-09-15 13:16:17 +0800416 if (!selCacheMapInitialized)
Tom Josephe59abfb2018-08-06 18:46:27 +0530417 {
Lei YUeba8e9a2021-09-15 13:16:17 +0800418 // In case the initSELCache() fails, try it again
419 initSELCache();
Tom Josephe59abfb2018-08-06 18:46:27 +0530420 }
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530421
Lei YUeba8e9a2021-09-15 13:16:17 +0800422 if (selCacheMap.empty())
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530423 {
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000424 return ipmi::responseSensorInvalid();
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530425 }
426
Lei YUeba8e9a2021-09-15 13:16:17 +0800427 SELCacheMap::const_iterator iter;
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530428 uint16_t delRecordID = 0;
429
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000430 if (selRecordID == ipmi::sel::firstEntry)
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530431 {
Lei YUeba8e9a2021-09-15 13:16:17 +0800432 delRecordID = selCacheMap.begin()->first;
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530433 }
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000434 else if (selRecordID == ipmi::sel::lastEntry)
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530435 {
Lei YUeba8e9a2021-09-15 13:16:17 +0800436 delRecordID = selCacheMap.rbegin()->first;
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530437 }
438 else
439 {
Lei YUeba8e9a2021-09-15 13:16:17 +0800440 iter = selCacheMap.find(selRecordID);
441 if (iter == selCacheMap.end())
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530442 {
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000443 return ipmi::responseSensorInvalid();
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530444 }
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000445 delRecordID = selRecordID;
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530446 }
447
448 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
449 std::string service;
450
Lei YUeba8e9a2021-09-15 13:16:17 +0800451 auto objPath = getLoggingObjPath(iter->first);
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530452 try
453 {
Lei YUeba8e9a2021-09-15 13:16:17 +0800454 service = ipmi::getService(bus, ipmi::sel::logDeleteIntf, objPath);
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530455 }
456 catch (const std::runtime_error& e)
457 {
458 log<level::ERR>(e.what());
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000459 return ipmi::responseUnspecifiedError();
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530460 }
461
Lei YUeba8e9a2021-09-15 13:16:17 +0800462 auto methodCall = bus.new_method_call(service.c_str(), objPath.c_str(),
Patrick Venture0b02be92018-08-31 11:55:55 -0700463 ipmi::sel::logDeleteIntf, "Delete");
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530464 auto reply = bus.call(methodCall);
465 if (reply.is_method_error())
466 {
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000467 return ipmi::responseUnspecifiedError();
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530468 }
469
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000470 return ipmi::responseSuccess(delRecordID);
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530471}
472
Pradeep Kumar4a5a99a2019-04-26 15:22:39 +0000473/** @brief implements the Clear SEL command
474 * @request
475 * - reservationID // Reservation ID.
476 * - clr // char array { 'C'(0x43h), 'L'(0x4Ch), 'R'(0x52h) }
477 * - eraseOperation; // requested operation.
478 *
479 * @returns ipmi completion code plus response data
480 * - erase status
481 */
482
483ipmi::RspType<uint8_t // erase status
484 >
485 clearSEL(uint16_t reservationID, const std::array<char, 3>& clr,
486 uint8_t eraseOperation)
Tom Joseph2f05bb52017-06-30 19:14:49 +0530487{
Pradeep Kumar4a5a99a2019-04-26 15:22:39 +0000488 static constexpr std::array<char, 3> clrOk = {'C', 'L', 'R'};
489 if (clr != clrOk)
Jason M. Bills851acb12019-02-04 14:06:57 -0800490 {
Pradeep Kumar4a5a99a2019-04-26 15:22:39 +0000491 return ipmi::responseInvalidFieldRequest();
Jason M. Bills851acb12019-02-04 14:06:57 -0800492 }
493
Pradeep Kumar4a5a99a2019-04-26 15:22:39 +0000494 if (!checkSELReservation(reservationID))
Tom Joseph2f05bb52017-06-30 19:14:49 +0530495 {
Pradeep Kumar4a5a99a2019-04-26 15:22:39 +0000496 return ipmi::responseInvalidReservationId();
Tom Joseph2f05bb52017-06-30 19:14:49 +0530497 }
498
Tom Joseph2f05bb52017-06-30 19:14:49 +0530499 /*
500 * Erasure status cannot be fetched from DBUS, so always return erasure
501 * status as `erase completed`.
502 */
Pradeep Kumar4a5a99a2019-04-26 15:22:39 +0000503 if (eraseOperation == ipmi::sel::getEraseStatus)
Tom Joseph2f05bb52017-06-30 19:14:49 +0530504 {
Pradeep Kumar4a5a99a2019-04-26 15:22:39 +0000505 return ipmi::responseSuccess(
506 static_cast<uint8_t>(ipmi::sel::eraseComplete));
Tom Joseph2f05bb52017-06-30 19:14:49 +0530507 }
508
Jason M. Bills13e67c82018-09-10 14:12:16 -0700509 // Per the IPMI spec, need to cancel any reservation when the SEL is cleared
510 cancelSELReservation();
511
Tom Joseph2f05bb52017-06-30 19:14:49 +0530512 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
Lotus Xu78fe1b12021-05-23 17:26:56 +0800513 auto service = ipmi::getService(bus, ipmi::sel::logIntf, ipmi::sel::logObj);
514 auto method =
515 bus.new_method_call(service.c_str(), ipmi::sel::logObj,
516 ipmi::sel::logIntf, ipmi::sel::logDeleteAllMethod);
Tom Josephe59abfb2018-08-06 18:46:27 +0530517 try
Tom Joseph2f05bb52017-06-30 19:14:49 +0530518 {
Lotus Xu78fe1b12021-05-23 17:26:56 +0800519 bus.call_noreply(method);
Tom Josephe59abfb2018-08-06 18:46:27 +0530520 }
Patrick Williamsef1259b2021-09-02 09:12:33 -0500521 catch (const sdbusplus::exception::exception& e)
Tom Joseph2f05bb52017-06-30 19:14:49 +0530522 {
Lotus Xu78fe1b12021-05-23 17:26:56 +0800523 log<level::ERR>("Error eraseAll ", entry("ERROR=%s", e.what()));
Pradeep Kumar4a5a99a2019-04-26 15:22:39 +0000524 return ipmi::responseUnspecifiedError();
Tom Joseph2f05bb52017-06-30 19:14:49 +0530525 }
526
Pradeep Kumar4a5a99a2019-04-26 15:22:39 +0000527 return ipmi::responseSuccess(
528 static_cast<uint8_t>(ipmi::sel::eraseComplete));
Tom Joseph2f05bb52017-06-30 19:14:49 +0530529}
530
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000531/** @brief implements the get SEL time command
532 * @returns IPMI completion code plus response data
533 * -current time
534 */
535ipmi::RspType<uint32_t> // current time
536 ipmiStorageGetSelTime()
Adriana Kobylak8e30f2a2015-10-20 10:23:51 -0500537{
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530538 using namespace std::chrono;
George Liu4d623e92020-05-25 16:51:57 +0800539 uint64_t bmc_time_usec = 0;
540 std::stringstream bmcTime;
Adriana Kobylak8e30f2a2015-10-20 10:23:51 -0500541
Lei YUe8939392017-06-15 10:45:05 +0800542 try
543 {
544 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
George Liu4d623e92020-05-25 16:51:57 +0800545 auto service = ipmi::getService(bus, TIME_INTERFACE, BMC_TIME_PATH);
Vernon Mauery16b86932019-05-01 08:36:11 -0700546 std::variant<uint64_t> value;
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530547
George Liu4d623e92020-05-25 16:51:57 +0800548 // Get bmc time
549 auto method = bus.new_method_call(service.c_str(), BMC_TIME_PATH,
Patrick Venture0b02be92018-08-31 11:55:55 -0700550 DBUS_PROPERTIES, "Get");
Lei YUe8939392017-06-15 10:45:05 +0800551
552 method.append(TIME_INTERFACE, PROPERTY_ELAPSED);
553 auto reply = bus.call(method);
554 if (reply.is_method_error())
555 {
556 log<level::ERR>("Error getting time",
557 entry("SERVICE=%s", service.c_str()),
George Liu4d623e92020-05-25 16:51:57 +0800558 entry("PATH=%s", BMC_TIME_PATH));
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000559 return ipmi::responseUnspecifiedError();
Lei YUe8939392017-06-15 10:45:05 +0800560 }
561 reply.read(value);
George Liu4d623e92020-05-25 16:51:57 +0800562 bmc_time_usec = std::get<uint64_t>(value);
Lei YUe8939392017-06-15 10:45:05 +0800563 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -0500564 catch (const InternalFailure& e)
Lei YUe8939392017-06-15 10:45:05 +0800565 {
566 log<level::ERR>(e.what());
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000567 return ipmi::responseUnspecifiedError();
Lei YUe8939392017-06-15 10:45:05 +0800568 }
Tom Joseph30fd0a12019-09-24 06:53:22 +0530569 catch (const std::exception& e)
Lei YUe8939392017-06-15 10:45:05 +0800570 {
571 log<level::ERR>(e.what());
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000572 return ipmi::responseUnspecifiedError();
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530573 }
574
George Liu4d623e92020-05-25 16:51:57 +0800575 bmcTime << "BMC time:"
576 << duration_cast<seconds>(microseconds(bmc_time_usec)).count();
577 log<level::DEBUG>(bmcTime.str().c_str());
Nagaraju Goruganti8960b7c2018-04-29 22:38:40 -0500578
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530579 // Time is really long int but IPMI wants just uint32. This works okay until
580 // the number of seconds since 1970 overflows uint32 size.. Still a whole
581 // lot of time here to even think about that.
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000582 return ipmi::responseSuccess(
George Liu4d623e92020-05-25 16:51:57 +0800583 duration_cast<seconds>(microseconds(bmc_time_usec)).count());
Adriana Kobylak8e30f2a2015-10-20 10:23:51 -0500584}
585
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000586/** @brief implements the set SEL time command
587 * @param selDeviceTime - epoch time
588 * -local time as the number of seconds from 00:00:00, January 1, 1970
589 * @returns IPMI completion code
590 */
591ipmi::RspType<> ipmiStorageSetSelTime(uint32_t selDeviceTime)
Chris Austenb4f5b922015-10-13 12:44:43 -0500592{
Lei YUe8939392017-06-15 10:45:05 +0800593 using namespace std::chrono;
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000594 microseconds usec{seconds(selDeviceTime)};
Norman James82330442015-11-19 16:53:26 -0600595
Lei YUe8939392017-06-15 10:45:05 +0800596 try
597 {
598 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
George Liu4d623e92020-05-25 16:51:57 +0800599 auto service = ipmi::getService(bus, TIME_INTERFACE, BMC_TIME_PATH);
Andrew Geissler6467ed22020-05-16 16:03:53 -0500600 std::variant<uint64_t> value{(uint64_t)usec.count()};
Lei YUe8939392017-06-15 10:45:05 +0800601
George Liu4d623e92020-05-25 16:51:57 +0800602 // Set bmc time
603 auto method = bus.new_method_call(service.c_str(), BMC_TIME_PATH,
Patrick Venture0b02be92018-08-31 11:55:55 -0700604 DBUS_PROPERTIES, "Set");
Lei YUe8939392017-06-15 10:45:05 +0800605
606 method.append(TIME_INTERFACE, PROPERTY_ELAPSED, value);
607 auto reply = bus.call(method);
608 if (reply.is_method_error())
609 {
610 log<level::ERR>("Error setting time",
611 entry("SERVICE=%s", service.c_str()),
George Liu4d623e92020-05-25 16:51:57 +0800612 entry("PATH=%s", BMC_TIME_PATH));
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000613 return ipmi::responseUnspecifiedError();
Lei YUe8939392017-06-15 10:45:05 +0800614 }
Norman James82330442015-11-19 16:53:26 -0600615 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -0500616 catch (const InternalFailure& e)
Lei YUe8939392017-06-15 10:45:05 +0800617 {
618 log<level::ERR>(e.what());
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000619 return ipmi::responseUnspecifiedError();
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530620 }
Tom Joseph30fd0a12019-09-24 06:53:22 +0530621 catch (const std::exception& e)
Lei YUe8939392017-06-15 10:45:05 +0800622 {
623 log<level::ERR>(e.what());
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000624 return ipmi::responseUnspecifiedError();
Norman James82330442015-11-19 16:53:26 -0600625 }
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530626
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000627 return ipmi::responseSuccess();
Chris Austenb4f5b922015-10-13 12:44:43 -0500628}
629
jayaprakash Mutyalab7557722019-05-02 21:13:30 +0000630/** @brief implements the reserve SEL command
631 * @returns IPMI completion code plus response data
632 * - SEL reservation ID.
633 */
634ipmi::RspType<uint16_t> ipmiStorageReserveSel()
Chris Austenb4f5b922015-10-13 12:44:43 -0500635{
jayaprakash Mutyalab7557722019-05-02 21:13:30 +0000636 return ipmi::responseSuccess(reserveSel());
Chris Austenb4f5b922015-10-13 12:44:43 -0500637}
638
anil kumar appana2c7db1d2019-05-28 11:20:19 +0000639/** @brief implements the Add SEL entry command
640 * @request
641 *
642 * - recordID ID used for SEL Record access
643 * - recordType Record Type
644 * - timeStamp Time when event was logged. LS byte first
645 * - generatorID software ID if event was generated from
646 * system software
647 * - evmRev event message format version
648 * - sensorType sensor type code for service that generated
649 * the event
650 * - sensorNumber number of sensors that generated the event
651 * - eventDir event dir
652 * - eventData event data field contents
653 *
654 * @returns ipmi completion code plus response data
655 * - RecordID of the Added SEL entry
656 */
657ipmi::RspType<uint16_t // recordID of the Added SEL entry
658 >
659 ipmiStorageAddSEL(uint16_t recordID, uint8_t recordType, uint32_t timeStamp,
660 uint16_t generatorID, uint8_t evmRev, uint8_t sensorType,
661 uint8_t sensorNumber, uint8_t eventDir,
662 std::array<uint8_t, eventDataSize> eventData)
Chris Austenb4f5b922015-10-13 12:44:43 -0500663{
Lotus Xu57d35572021-01-24 11:13:13 +0800664 std::string objpath;
665 static constexpr auto systemRecordType = 0x02;
Tom Josephb647d5b2017-10-31 17:25:33 +0530666 // Hostboot sends SEL with OEM record type 0xDE to indicate that there is
667 // a maintenance procedure associated with eSEL record.
668 static constexpr auto procedureType = 0xDE;
Lotus Xu57d35572021-01-24 11:13:13 +0800669 cancelSELReservation();
670 if (recordType == systemRecordType)
671 {
672
673 for (const auto& it : invSensors)
674 {
675 if (it.second.sensorID == sensorNumber)
676 {
677 objpath = it.first;
678 break;
679 }
680 }
681 auto selDataStr = ipmi::sel::toHexStr(eventData);
682
683 bool assert = (eventDir & 0x80) ? false : true;
684
685 recordID = report<SELCreated>(Created::RECORD_TYPE(recordType),
686 Created::GENERATOR_ID(generatorID),
687 Created::SENSOR_DATA(selDataStr.c_str()),
688 Created::EVENT_DIR(assert),
689 Created::SENSOR_PATH(objpath.c_str()));
690 }
691 else if (recordType == procedureType)
Tom Josephb647d5b2017-10-31 17:25:33 +0530692 {
693 // In the OEM record type 0xDE, byte 11 in the SEL record indicate the
694 // procedure number.
anil kumar appana2c7db1d2019-05-28 11:20:19 +0000695 createProcedureLogEntry(sensorType);
Tom Josephb647d5b2017-10-31 17:25:33 +0530696 }
Chris Austenb4f5b922015-10-13 12:44:43 -0500697
anil kumar appana2c7db1d2019-05-28 11:20:19 +0000698 return ipmi::responseSuccess(recordID);
Chris Austenb4f5b922015-10-13 12:44:43 -0500699}
700
Kirill Pakhomovfa6e2092020-04-24 18:57:15 +0300701bool isFruPresent(const std::string& fruPath)
702{
703 using namespace ipmi::fru;
704
705 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
706
707 auto propValue =
708 ipmi::getDbusProperty(bus, invMgrInterface, invObjPath + fruPath,
709 invItemInterface, itemPresentProp);
710
711 return std::get<bool>(propValue);
712}
713
Pradeep Kumarb0c794d2019-05-02 13:09:14 +0000714/** @brief implements the get FRU Inventory Area Info command
715 *
716 * @returns IPMI completion code plus response data
717 * - FRU Inventory area size in bytes,
718 * - access bit
719 **/
720ipmi::RspType<uint16_t, // FRU Inventory area size in bytes,
721 uint8_t // access size (bytes / words)
722 >
723 ipmiStorageGetFruInvAreaInfo(uint8_t fruID)
Marri Devender Raofa7b4e22017-07-03 00:52:20 -0500724{
Tom Joseph187f5642018-03-29 13:49:06 +0530725
Pradeep Kumarb0c794d2019-05-02 13:09:14 +0000726 auto iter = frus.find(fruID);
Tom Joseph187f5642018-03-29 13:49:06 +0530727 if (iter == frus.end())
728 {
Pradeep Kumarb0c794d2019-05-02 13:09:14 +0000729 return ipmi::responseSensorInvalid();
Tom Joseph187f5642018-03-29 13:49:06 +0530730 }
731
Kirill Pakhomovfa6e2092020-04-24 18:57:15 +0300732 auto path = iter->second[0].path;
733 if (!isFruPresent(path))
734 {
735 return ipmi::responseSensorInvalid();
736 }
737
Marri Devender Raocac383b2017-07-03 13:24:27 -0500738 try
739 {
Pradeep Kumarb0c794d2019-05-02 13:09:14 +0000740 return ipmi::responseSuccess(
741 static_cast<uint16_t>(getFruAreaData(fruID).size()),
742 static_cast<uint8_t>(AccessMode::bytes));
Marri Devender Raocac383b2017-07-03 13:24:27 -0500743 }
Patrick Venture0b02be92018-08-31 11:55:55 -0700744 catch (const InternalFailure& e)
Marri Devender Raocac383b2017-07-03 13:24:27 -0500745 {
Marri Devender Raocac383b2017-07-03 13:24:27 -0500746 log<level::ERR>(e.what());
Pradeep Kumarb0c794d2019-05-02 13:09:14 +0000747 return ipmi::responseUnspecifiedError();
Marri Devender Raocac383b2017-07-03 13:24:27 -0500748 }
Marri Devender Raofa7b4e22017-07-03 00:52:20 -0500749}
750
anil kumar appana5b7c3262019-05-27 18:10:23 +0000751/**@brief implements the Read FRU Data command
752 * @param fruDeviceId - FRU device ID. FFh = reserved
753 * @param offset - FRU inventory offset to read
754 * @param readCount - count to read
755 *
756 * @return IPMI completion code plus response data
757 * - returnCount - response data count.
758 * - data - response data
759 */
760ipmi::RspType<uint8_t, // count returned
761 std::vector<uint8_t>> // FRU data
762 ipmiStorageReadFruData(uint8_t fruDeviceId, uint16_t offset,
763 uint8_t readCount)
Marri Devender Raofa7b4e22017-07-03 00:52:20 -0500764{
anil kumar appana5b7c3262019-05-27 18:10:23 +0000765 if (fruDeviceId == 0xFF)
Tom Joseph187f5642018-03-29 13:49:06 +0530766 {
anil kumar appana5b7c3262019-05-27 18:10:23 +0000767 return ipmi::responseInvalidFieldRequest();
Tom Joseph187f5642018-03-29 13:49:06 +0530768 }
769
anil kumar appana5b7c3262019-05-27 18:10:23 +0000770 auto iter = frus.find(fruDeviceId);
771 if (iter == frus.end())
772 {
773 return ipmi::responseSensorInvalid();
774 }
775
Marri Devender Raocac383b2017-07-03 13:24:27 -0500776 try
777 {
anil kumar appana5b7c3262019-05-27 18:10:23 +0000778 const auto& fruArea = getFruAreaData(fruDeviceId);
Marri Devender Raocac383b2017-07-03 13:24:27 -0500779 auto size = fruArea.size();
Nagaraju Goruganti7f2d7c92018-03-21 11:18:30 -0500780
Tom Josephefcd68b2018-04-26 18:46:27 +0530781 if (offset >= size)
782 {
anil kumar appana5b7c3262019-05-27 18:10:23 +0000783 return ipmi::responseParmOutOfRange();
Tom Josephefcd68b2018-04-26 18:46:27 +0530784 }
785
Nagaraju Goruganti7f2d7c92018-03-21 11:18:30 -0500786 // Write the count of response data.
anil kumar appana5b7c3262019-05-27 18:10:23 +0000787 uint8_t returnCount;
788 if ((offset + readCount) <= size)
Marri Devender Raocac383b2017-07-03 13:24:27 -0500789 {
anil kumar appana5b7c3262019-05-27 18:10:23 +0000790 returnCount = readCount;
Nagaraju Goruganti7f2d7c92018-03-21 11:18:30 -0500791 }
792 else
793 {
anil kumar appana5b7c3262019-05-27 18:10:23 +0000794 returnCount = size - offset;
Marri Devender Raocac383b2017-07-03 13:24:27 -0500795 }
Ratan Gupta2848d602018-01-31 20:39:20 +0530796
anil kumar appana5b7c3262019-05-27 18:10:23 +0000797 std::vector<uint8_t> fruData((fruArea.begin() + offset),
798 (fruArea.begin() + offset + returnCount));
Ratan Gupta2848d602018-01-31 20:39:20 +0530799
anil kumar appana5b7c3262019-05-27 18:10:23 +0000800 return ipmi::responseSuccess(returnCount, fruData);
Marri Devender Raocac383b2017-07-03 13:24:27 -0500801 }
802 catch (const InternalFailure& e)
803 {
Marri Devender Raocac383b2017-07-03 13:24:27 -0500804 log<level::ERR>(e.what());
anil kumar appana5b7c3262019-05-27 18:10:23 +0000805 return ipmi::responseUnspecifiedError();
Marri Devender Raocac383b2017-07-03 13:24:27 -0500806 }
Marri Devender Raofa7b4e22017-07-03 00:52:20 -0500807}
808
Pradeep Kumarb60e8402019-05-06 15:17:01 +0000809ipmi::RspType<uint8_t, // SDR version
810 uint16_t, // record count LS first
811 uint16_t, // free space in bytes, LS first
812 uint32_t, // addition timestamp LS first
813 uint32_t, // deletion timestamp LS first
814 uint8_t> // operation Support
815 ipmiGetRepositoryInfo()
Dhruvaraj Subhashchandrane66c3b02018-02-07 01:21:56 -0600816{
Dhruvaraj Subhashchandrane66c3b02018-02-07 01:21:56 -0600817
Pradeep Kumarb60e8402019-05-06 15:17:01 +0000818 constexpr uint8_t sdrVersion = 0x51;
819 constexpr uint16_t freeSpace = 0xFFFF;
820 constexpr uint32_t additionTimestamp = 0x0;
821 constexpr uint32_t deletionTimestamp = 0x0;
822 constexpr uint8_t operationSupport = 0;
Dhruvaraj Subhashchandrane66c3b02018-02-07 01:21:56 -0600823
Patrick Venturedb0cbe62019-09-09 14:47:22 -0700824 uint16_t records = frus.size() + ipmi::sensor::sensors.size();
Dhruvaraj Subhashchandrane66c3b02018-02-07 01:21:56 -0600825
Pradeep Kumarb60e8402019-05-06 15:17:01 +0000826 return ipmi::responseSuccess(sdrVersion, records, freeSpace,
827 additionTimestamp, deletionTimestamp,
828 operationSupport);
Dhruvaraj Subhashchandrane66c3b02018-02-07 01:21:56 -0600829}
Chris Austenb4f5b922015-10-13 12:44:43 -0500830
Chris Austenb4f5b922015-10-13 12:44:43 -0500831void register_netfn_storage_functions()
832{
Lei YU3df36612021-09-15 11:41:11 +0800833 selCacheMapInitialized = false;
Lei YUd9e57662021-09-14 18:06:28 +0800834 initSELCache();
Willy Tud351a722021-08-12 14:33:40 -0700835 // Handlers with dbus-sdr handler implementation.
836 // Do not register the hander if it dynamic sensors stack is used.
837
838#ifndef FEATURE_DYNAMIC_SENSORS
Tom Joseph6f7deaa2017-06-30 19:03:54 +0530839 // <Get SEL Info>
jayaprakash Mutyalab7557722019-05-02 21:13:30 +0000840 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
841 ipmi::storage::cmdGetSelInfo, ipmi::Privilege::User,
842 ipmiStorageGetSelInfo);
Tom Joseph6f7deaa2017-06-30 19:03:54 +0530843
Tom05732372016-09-06 17:21:23 +0530844 // <Get SEL Time>
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000845 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
846 ipmi::storage::cmdGetSelTime, ipmi::Privilege::User,
847 ipmiStorageGetSelTime);
Adriana Kobylak8e30f2a2015-10-20 10:23:51 -0500848
Tom05732372016-09-06 17:21:23 +0530849 // <Set SEL Time>
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000850 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
851 ipmi::storage::cmdSetSelTime,
852 ipmi::Privilege::Operator, ipmiStorageSetSelTime);
Chris Austenb4f5b922015-10-13 12:44:43 -0500853
Tom Josepha4953392017-06-30 19:09:47 +0530854 // <Get SEL Entry>
Patrick Venture0b02be92018-08-31 11:55:55 -0700855 ipmi_register_callback(NETFUN_STORAGE, IPMI_CMD_GET_SEL_ENTRY, NULL,
856 getSELEntry, PRIVILEGE_USER);
Tom Josepha4953392017-06-30 19:09:47 +0530857
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530858 // <Delete SEL Entry>
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000859 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
860 ipmi::storage::cmdDeleteSelEntry,
861 ipmi::Privilege::Operator, deleteSELEntry);
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530862
Tom05732372016-09-06 17:21:23 +0530863 // <Add SEL Entry>
anil kumar appana2c7db1d2019-05-28 11:20:19 +0000864 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
865 ipmi::storage::cmdAddSelEntry,
866 ipmi::Privilege::Operator, ipmiStorageAddSEL);
867
Tom Joseph2f05bb52017-06-30 19:14:49 +0530868 // <Clear SEL>
Pradeep Kumar4a5a99a2019-04-26 15:22:39 +0000869 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
870 ipmi::storage::cmdClearSel, ipmi::Privilege::Operator,
871 clearSEL);
872
Marri Devender Raofa7b4e22017-07-03 00:52:20 -0500873 // <Get FRU Inventory Area Info>
Pradeep Kumarb0c794d2019-05-02 13:09:14 +0000874 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
875 ipmi::storage::cmdGetFruInventoryAreaInfo,
876 ipmi::Privilege::User, ipmiStorageGetFruInvAreaInfo);
Marri Devender Raofa7b4e22017-07-03 00:52:20 -0500877
Jason M. Billsb5248c92019-06-24 15:53:08 -0700878 // <READ FRU Data>
anil kumar appana5b7c3262019-05-27 18:10:23 +0000879 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
880 ipmi::storage::cmdReadFruData,
881 ipmi::Privilege::Operator, ipmiStorageReadFruData);
Marri Devender Raocac383b2017-07-03 13:24:27 -0500882
Dhruvaraj Subhashchandrane66c3b02018-02-07 01:21:56 -0600883 // <Get Repository Info>
Pradeep Kumarb60e8402019-05-06 15:17:01 +0000884 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
885 ipmi::storage::cmdGetSdrRepositoryInfo,
886 ipmi::Privilege::User, ipmiGetRepositoryInfo);
Dhruvaraj Subhashchandrane66c3b02018-02-07 01:21:56 -0600887
Tom Joseph5ca50952018-02-22 00:33:38 +0530888 // <Reserve SDR Repository>
jayaprakash Mutyalad9578232019-05-13 20:22:50 +0000889 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
890 ipmi::storage::cmdReserveSdrRepository,
891 ipmi::Privilege::User, ipmiSensorReserveSdr);
Tom Joseph5ca50952018-02-22 00:33:38 +0530892
893 // <Get SDR>
Patrick Venture0b02be92018-08-31 11:55:55 -0700894 ipmi_register_callback(NETFUN_STORAGE, IPMI_CMD_GET_SDR, nullptr,
895 ipmi_sen_get_sdr, PRIVILEGE_USER);
Tom Joseph5ca50952018-02-22 00:33:38 +0530896
Willy Tud351a722021-08-12 14:33:40 -0700897#endif
898
899 // Common Handers used by both implementation.
900
901 // <Reserve SEL>
902 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
903 ipmi::storage::cmdReserveSel, ipmi::Privilege::User,
904 ipmiStorageReserveSel);
905
Marri Devender Rao908f7502017-07-10 01:49:54 -0500906 ipmi::fru::registerCallbackHandler();
Chris Austenb4f5b922015-10-13 12:44:43 -0500907 return;
908}