blob: 0b1a4e4dd8b80cf58727e46e6b736dbec96de545 [file] [log] [blame]
Patrick Venture3a5071a2018-09-12 13:27:42 -07001#include "storagehandler.hpp"
2
Willy Tu0ca3bfe2022-01-28 09:40:18 -08003#include "entity_map_json.hpp"
Patrick Venture3a5071a2018-09-12 13:27:42 -07004#include "fruread.hpp"
5#include "read_fru_data.hpp"
6#include "selutility.hpp"
7#include "sensorhandler.hpp"
8#include "storageaddsel.hpp"
Patrick Venture3a5071a2018-09-12 13:27:42 -07009
Lei YU52d91242017-10-17 22:52:28 +080010#include <arpa/inet.h>
Patrick Venture3a5071a2018-09-12 13:27:42 -070011#include <mapper.h>
12#include <systemd/sd-bus.h>
Patrick Venture0b02be92018-08-31 11:55:55 -070013
14#include <algorithm>
Lei YU52d91242017-10-17 22:52:28 +080015#include <chrono>
16#include <cstdio>
Patrick Ventureb51bf9c2018-09-10 15:53:14 -070017#include <cstring>
Vernon Mauerybdda8002019-02-26 10:18:51 -080018#include <filesystem>
Vernon Mauerye08fbff2019-04-03 09:19:34 -070019#include <ipmid/api.hpp>
Vernon Mauery6a98fe72019-03-11 15:57:48 -070020#include <ipmid/utils.hpp>
Lei YUa0bb2a32021-09-24 11:03:56 +080021#include <optional>
Patrick Venture3a5071a2018-09-12 13:27:42 -070022#include <phosphor-logging/elog-errors.hpp>
Lotus Xu57d35572021-01-24 11:13:13 +080023#include <phosphor-logging/elog.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070024#include <phosphor-logging/log.hpp>
25#include <sdbusplus/server.hpp>
26#include <string>
Vernon Mauery16b86932019-05-01 08:36:11 -070027#include <variant>
Patrick Venture3a5071a2018-09-12 13:27:42 -070028#include <xyz/openbmc_project/Common/error.hpp>
Lotus Xu57d35572021-01-24 11:13:13 +080029#include <xyz/openbmc_project/Logging/SEL/error.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070030
Chris Austenb4f5b922015-10-13 12:44:43 -050031void register_netfn_storage_functions() __attribute__((constructor));
32
Patrick Venture0b02be92018-08-31 11:55:55 -070033unsigned int g_sel_time = 0xFFFFFFFF;
Patrick Venturedb0cbe62019-09-09 14:47:22 -070034namespace ipmi
35{
36namespace sensor
37{
38extern const IdInfoMap sensors;
39} // namespace sensor
40} // namespace ipmi
Lotus Xu57d35572021-01-24 11:13:13 +080041extern const ipmi::sensor::InvObjectIDMap invSensors;
Dhruvaraj Subhashchandrane66c3b02018-02-07 01:21:56 -060042extern const FruMap frus;
anil kumar appana2c7db1d2019-05-28 11:20:19 +000043constexpr uint8_t eventDataSize = 3;
Patrick Venture0b02be92018-08-31 11:55:55 -070044namespace
45{
shamim ali071d00c2022-03-02 15:42:46 +053046constexpr auto SystemdTimeService = "org.freedesktop.timedate1";
47constexpr auto SystemdTimePath = "/org/freedesktop/timedate1";
48constexpr auto SystemdTimeInterface = "org.freedesktop.timedate1";
49
Lei YUe8939392017-06-15 10:45:05 +080050constexpr auto TIME_INTERFACE = "xyz.openbmc_project.Time.EpochTime";
George Liu4d623e92020-05-25 16:51:57 +080051constexpr auto BMC_TIME_PATH = "/xyz/openbmc_project/time/bmc";
Lei YUe8939392017-06-15 10:45:05 +080052constexpr auto DBUS_PROPERTIES = "org.freedesktop.DBus.Properties";
Patrick Venture0b02be92018-08-31 11:55:55 -070053constexpr auto PROPERTY_ELAPSED = "Elapsed";
Lei YUe8939392017-06-15 10:45:05 +080054
Lei YUd9555252021-09-14 20:30:41 +080055constexpr auto logWatchPath = "/xyz/openbmc_project/logging";
Lei YUd9e57662021-09-14 18:06:28 +080056constexpr auto logBasePath = "/xyz/openbmc_project/logging/entry";
57constexpr auto logEntryIntf = "xyz.openbmc_project.Logging.Entry";
58constexpr auto logDeleteIntf = "xyz.openbmc_project.Object.Delete";
Patrick Venture0b02be92018-08-31 11:55:55 -070059} // namespace
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +053060
Tom Joseph6f7deaa2017-06-30 19:03:54 +053061using InternalFailure =
Patrick Venture0b02be92018-08-31 11:55:55 -070062 sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
Tom Joseph6f7deaa2017-06-30 19:03:54 +053063using namespace phosphor::logging;
Marri Devender Raocac383b2017-07-03 13:24:27 -050064using namespace ipmi::fru;
Lotus Xu57d35572021-01-24 11:13:13 +080065using namespace xyz::openbmc_project::Logging::SEL;
66using SELCreated =
67 sdbusplus::xyz::openbmc_project::Logging::SEL::Error::Created;
Marri Devender Raocac383b2017-07-03 13:24:27 -050068
Lei YUd9e57662021-09-14 18:06:28 +080069using SELRecordID = uint16_t;
70using SELEntry = ipmi::sel::SELEventRecordFormat;
71using SELCacheMap = std::map<SELRecordID, SELEntry>;
72
73SELCacheMap selCacheMap __attribute__((init_priority(101)));
Lei YU3df36612021-09-15 11:41:11 +080074bool selCacheMapInitialized;
Lei YUd9555252021-09-14 20:30:41 +080075std::unique_ptr<sdbusplus::bus::match::match> selAddedMatch
76 __attribute__((init_priority(101)));
Lei YUb6b72b02021-09-14 21:06:05 +080077std::unique_ptr<sdbusplus::bus::match::match> selRemovedMatch
78 __attribute__((init_priority(101)));
Lei YU4106e422021-09-15 10:55:51 +080079std::unique_ptr<sdbusplus::bus::match::match> selUpdatedMatch
80 __attribute__((init_priority(101)));
Lei YUd9e57662021-09-14 18:06:28 +080081
Lei YUb6b72b02021-09-14 21:06:05 +080082static inline uint16_t getLoggingId(const std::string& p)
Lei YUd9e57662021-09-14 18:06:28 +080083{
84 namespace fs = std::filesystem;
85 fs::path entryPath(p);
Lei YUb6b72b02021-09-14 21:06:05 +080086 return std::stoul(entryPath.filename().string());
87}
88
Lei YUeba8e9a2021-09-15 13:16:17 +080089static inline std::string getLoggingObjPath(uint16_t id)
90{
91 return std::string(ipmi::sel::logBasePath) + "/" + std::to_string(id);
92}
93
Lei YUa0bb2a32021-09-24 11:03:56 +080094std::optional<std::pair<uint16_t, SELEntry>>
95 parseLoggingEntry(const std::string& p)
Lei YUb6b72b02021-09-14 21:06:05 +080096{
Lei YU3df36612021-09-15 11:41:11 +080097 try
98 {
Lei YUa0bb2a32021-09-24 11:03:56 +080099 auto id = getLoggingId(p);
100 ipmi::sel::GetSELEntryResponse record{};
Lei YU3df36612021-09-15 11:41:11 +0800101 record = ipmi::sel::convertLogEntrytoSEL(p);
Lei YUa0bb2a32021-09-24 11:03:56 +0800102 return std::pair<uint16_t, SELEntry>({id, std::move(record.event)});
Lei YU3df36612021-09-15 11:41:11 +0800103 }
104 catch (const std::exception& e)
105 {
106 fprintf(stderr, "Failed to convert %s to SEL: %s\n", p.c_str(),
107 e.what());
108 }
Lei YUa0bb2a32021-09-24 11:03:56 +0800109 return std::nullopt;
Lei YUd9e57662021-09-14 18:06:28 +0800110}
111
Lei YUd9555252021-09-14 20:30:41 +0800112static void selAddedCallback(sdbusplus::message::message& m)
113{
114 sdbusplus::message::object_path objPath;
115 try
116 {
117 m.read(objPath);
118 }
119 catch (const sdbusplus::exception::exception& e)
120 {
121 log<level::ERR>("Failed to read object path");
122 return;
123 }
124 std::string p = objPath;
Lei YUa0bb2a32021-09-24 11:03:56 +0800125 auto entry = parseLoggingEntry(p);
126 if (entry)
127 {
128 selCacheMap.insert(std::move(*entry));
129 }
Lei YUd9555252021-09-14 20:30:41 +0800130}
131
Lei YUb6b72b02021-09-14 21:06:05 +0800132static void selRemovedCallback(sdbusplus::message::message& m)
133{
134 sdbusplus::message::object_path objPath;
135 try
136 {
137 m.read(objPath);
138 }
139 catch (const sdbusplus::exception::exception& e)
140 {
141 log<level::ERR>("Failed to read object path");
Lei YUb6b72b02021-09-14 21:06:05 +0800142 }
Lei YUa0bb2a32021-09-24 11:03:56 +0800143 try
144 {
145 std::string p = objPath;
146 selCacheMap.erase(getLoggingId(p));
147 }
148 catch (const std::invalid_argument& e)
149 {
150 log<level::ERR>("Invalid logging entry ID");
151 }
Lei YUb6b72b02021-09-14 21:06:05 +0800152}
153
Lei YU4106e422021-09-15 10:55:51 +0800154static void selUpdatedCallback(sdbusplus::message::message& m)
155{
156 std::string p = m.get_path();
157 auto entry = parseLoggingEntry(p);
Lei YUa0bb2a32021-09-24 11:03:56 +0800158 if (entry)
159 {
160 selCacheMap.insert_or_assign(entry->first, std::move(entry->second));
161 }
Lei YU4106e422021-09-15 10:55:51 +0800162}
163
Lei YUd9555252021-09-14 20:30:41 +0800164void registerSelCallbackHandler()
165{
166 using namespace sdbusplus::bus::match::rules;
167 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
168 if (!selAddedMatch)
169 {
170 selAddedMatch = std::make_unique<sdbusplus::bus::match::match>(
171 bus, interfacesAdded(logWatchPath),
172 std::bind(selAddedCallback, std::placeholders::_1));
173 }
Lei YUb6b72b02021-09-14 21:06:05 +0800174 if (!selRemovedMatch)
175 {
176 selRemovedMatch = std::make_unique<sdbusplus::bus::match::match>(
177 bus, interfacesRemoved(logWatchPath),
178 std::bind(selRemovedCallback, std::placeholders::_1));
179 }
Lei YU4106e422021-09-15 10:55:51 +0800180 if (!selUpdatedMatch)
181 {
182 selUpdatedMatch = std::make_unique<sdbusplus::bus::match::match>(
183 bus,
184 type::signal() + member("PropertiesChanged"s) +
185 interface("org.freedesktop.DBus.Properties"s) +
186 argN(0, logEntryIntf),
187 std::bind(selUpdatedCallback, std::placeholders::_1));
188 }
Lei YUd9555252021-09-14 20:30:41 +0800189}
190
Lei YUd9e57662021-09-14 18:06:28 +0800191void initSELCache()
192{
Lei YUc10cda12022-01-06 16:01:57 +0800193 registerSelCallbackHandler();
Lei YUeba8e9a2021-09-15 13:16:17 +0800194 ipmi::sel::ObjectPaths paths;
Lei YUd9e57662021-09-14 18:06:28 +0800195 try
196 {
Lei YUeba8e9a2021-09-15 13:16:17 +0800197 ipmi::sel::readLoggingObjectPaths(paths);
Lei YUd9e57662021-09-14 18:06:28 +0800198 }
199 catch (const sdbusplus::exception::exception& e)
200 {
201 log<level::ERR>("Failed to get logging object paths");
202 return;
203 }
Lei YUeba8e9a2021-09-15 13:16:17 +0800204 for (const auto& p : paths)
Lei YUd9e57662021-09-14 18:06:28 +0800205 {
Lei YUa0bb2a32021-09-24 11:03:56 +0800206 auto entry = parseLoggingEntry(p);
207 if (entry)
208 {
209 selCacheMap.insert(std::move(*entry));
210 }
Lei YUd9e57662021-09-14 18:06:28 +0800211 }
Lei YU3df36612021-09-15 11:41:11 +0800212 selCacheMapInitialized = true;
Lei YUd9e57662021-09-14 18:06:28 +0800213}
214
Marri Devender Raocac383b2017-07-03 13:24:27 -0500215/**
216 * @enum Device access mode
217 */
218enum class AccessMode
219{
220 bytes, ///< Device is accessed by bytes
221 words ///< Device is accessed by words
222};
223
jayaprakash Mutyalab7557722019-05-02 21:13:30 +0000224/** @brief implements the get SEL Info command
225 * @returns IPMI completion code plus response data
226 * - selVersion - SEL revision
227 * - entries - Number of log entries in SEL.
228 * - freeSpace - Free Space in bytes.
229 * - addTimeStamp - Most recent addition timestamp
230 * - eraseTimeStamp - Most recent erase timestamp
231 * - operationSupport - Reserve & Delete SEL operations supported
232 */
233
234ipmi::RspType<uint8_t, // SEL revision.
235 uint16_t, // number of log entries in SEL.
236 uint16_t, // free Space in bytes.
237 uint32_t, // most recent addition timestamp
238 uint32_t, // most recent erase timestamp.
239
240 bool, // SEL allocation info supported
241 bool, // reserve SEL supported
242 bool, // partial Add SEL Entry supported
243 bool, // delete SEL supported
244 uint3_t, // reserved
245 bool // overflow flag
246 >
247 ipmiStorageGetSelInfo()
Tom Joseph6f7deaa2017-06-30 19:03:54 +0530248{
jayaprakash Mutyalab7557722019-05-02 21:13:30 +0000249 uint16_t entries = 0;
250 // Most recent addition timestamp.
251 uint32_t addTimeStamp = ipmi::sel::invalidTimeStamp;
Tom Joseph6f7deaa2017-06-30 19:03:54 +0530252
Lei YUeba8e9a2021-09-15 13:16:17 +0800253 if (!selCacheMapInitialized)
Tom Josephe59abfb2018-08-06 18:46:27 +0530254 {
Lei YUeba8e9a2021-09-15 13:16:17 +0800255 // In case the initSELCache() fails, try it again
256 initSELCache();
Tom Josephe59abfb2018-08-06 18:46:27 +0530257 }
Lei YUeba8e9a2021-09-15 13:16:17 +0800258 if (!selCacheMap.empty())
Tom Josephe59abfb2018-08-06 18:46:27 +0530259 {
Lei YUeba8e9a2021-09-15 13:16:17 +0800260 entries = static_cast<uint16_t>(selCacheMap.size());
Tom Joseph6f7deaa2017-06-30 19:03:54 +0530261
262 try
263 {
Lei YUeba8e9a2021-09-15 13:16:17 +0800264 auto objPath = getLoggingObjPath(selCacheMap.rbegin()->first);
jayaprakash Mutyalab7557722019-05-02 21:13:30 +0000265 addTimeStamp = static_cast<uint32_t>(
Lei YUeba8e9a2021-09-15 13:16:17 +0800266 (ipmi::sel::getEntryTimeStamp(objPath).count()));
Tom Joseph6f7deaa2017-06-30 19:03:54 +0530267 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -0500268 catch (const InternalFailure& e)
Tom Joseph6f7deaa2017-06-30 19:03:54 +0530269 {
270 }
271 catch (const std::runtime_error& e)
272 {
273 log<level::ERR>(e.what());
274 }
275 }
276
jayaprakash Mutyalab7557722019-05-02 21:13:30 +0000277 constexpr uint8_t selVersion = ipmi::sel::selVersion;
278 constexpr uint16_t freeSpace = 0xFFFF;
279 constexpr uint32_t eraseTimeStamp = ipmi::sel::invalidTimeStamp;
280 constexpr uint3_t reserved{0};
Tom Joseph6f7deaa2017-06-30 19:03:54 +0530281
jayaprakash Mutyalab7557722019-05-02 21:13:30 +0000282 return ipmi::responseSuccess(
283 selVersion, entries, freeSpace, addTimeStamp, eraseTimeStamp,
284 ipmi::sel::operationSupport::getSelAllocationInfo,
285 ipmi::sel::operationSupport::reserveSel,
286 ipmi::sel::operationSupport::partialAddSelEntry,
287 ipmi::sel::operationSupport::deleteSel, reserved,
288 ipmi::sel::operationSupport::overflow);
Tom Joseph6f7deaa2017-06-30 19:03:54 +0530289}
290
Tom Josepha4953392017-06-30 19:09:47 +0530291ipmi_ret_t getSELEntry(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
292 ipmi_request_t request, ipmi_response_t response,
293 ipmi_data_len_t data_len, ipmi_context_t context)
294{
Jason M. Bills851acb12019-02-04 14:06:57 -0800295 if (*data_len != sizeof(ipmi::sel::GetSELEntryRequest))
296 {
297 *data_len = 0;
298 return IPMI_CC_REQ_DATA_LEN_INVALID;
299 }
300
Patrick Venture0b02be92018-08-31 11:55:55 -0700301 auto requestData =
302 reinterpret_cast<const ipmi::sel::GetSELEntryRequest*>(request);
Tom Josepha4953392017-06-30 19:09:47 +0530303
304 if (requestData->reservationID != 0)
305 {
Jason M. Bills13e67c82018-09-10 14:12:16 -0700306 if (!checkSELReservation(requestData->reservationID))
Tom Josepha4953392017-06-30 19:09:47 +0530307 {
308 *data_len = 0;
309 return IPMI_CC_INVALID_RESERVATION_ID;
310 }
311 }
312
Lei YU3df36612021-09-15 11:41:11 +0800313 if (!selCacheMapInitialized)
314 {
315 // In case the initSELCache() fails, try it again
316 initSELCache();
317 }
318
319 if (selCacheMap.empty())
Tom Josepha4953392017-06-30 19:09:47 +0530320 {
321 *data_len = 0;
322 return IPMI_CC_SENSOR_INVALID;
323 }
324
Lei YU3df36612021-09-15 11:41:11 +0800325 SELCacheMap::const_iterator iter;
Tom Josepha4953392017-06-30 19:09:47 +0530326
327 // Check for the requested SEL Entry.
328 if (requestData->selRecordID == ipmi::sel::firstEntry)
329 {
Lei YU3df36612021-09-15 11:41:11 +0800330 iter = selCacheMap.begin();
Tom Josepha4953392017-06-30 19:09:47 +0530331 }
332 else if (requestData->selRecordID == ipmi::sel::lastEntry)
333 {
Lei YU3df36612021-09-15 11:41:11 +0800334 if (selCacheMap.size() > 1)
335 {
336 iter = selCacheMap.end();
337 --iter;
338 }
339 else
340 {
341 // Only one entry exists, return the first
342 iter = selCacheMap.begin();
343 }
Tom Josepha4953392017-06-30 19:09:47 +0530344 }
345 else
346 {
Lei YU3df36612021-09-15 11:41:11 +0800347 iter = selCacheMap.find(requestData->selRecordID);
348 if (iter == selCacheMap.end())
Tom Josepha4953392017-06-30 19:09:47 +0530349 {
350 *data_len = 0;
351 return IPMI_CC_SENSOR_INVALID;
352 }
353 }
354
Lei YU3df36612021-09-15 11:41:11 +0800355 ipmi::sel::GetSELEntryResponse record{0, iter->second};
Tom Josepha4953392017-06-30 19:09:47 +0530356 // Identify the next SEL record ID
Lei YU3df36612021-09-15 11:41:11 +0800357 ++iter;
358 if (iter == selCacheMap.end())
Tom Josepha4953392017-06-30 19:09:47 +0530359 {
Lei YU3df36612021-09-15 11:41:11 +0800360 record.nextRecordID = ipmi::sel::lastEntry;
Tom Josepha4953392017-06-30 19:09:47 +0530361 }
362 else
363 {
Lei YU3df36612021-09-15 11:41:11 +0800364 record.nextRecordID = iter->first;
Tom Josepha4953392017-06-30 19:09:47 +0530365 }
366
367 if (requestData->readLength == ipmi::sel::entireRecord)
368 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700369 std::memcpy(response, &record, sizeof(record));
Tom Josepha4953392017-06-30 19:09:47 +0530370 *data_len = sizeof(record);
371 }
372 else
373 {
374 if (requestData->offset >= ipmi::sel::selRecordSize ||
375 requestData->readLength > ipmi::sel::selRecordSize)
376 {
377 *data_len = 0;
378 return IPMI_CC_INVALID_FIELD_REQUEST;
379 }
380
381 auto diff = ipmi::sel::selRecordSize - requestData->offset;
Patrick Venture0b02be92018-08-31 11:55:55 -0700382 auto readLength =
383 std::min(diff, static_cast<int>(requestData->readLength));
Tom Josepha4953392017-06-30 19:09:47 +0530384
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700385 std::memcpy(response, &record.nextRecordID,
386 sizeof(record.nextRecordID));
387 std::memcpy(static_cast<uint8_t*>(response) +
388 sizeof(record.nextRecordID),
Lei YUaf378fa2020-12-02 16:28:57 +0800389 &record.event.eventRecord.recordID + requestData->offset,
390 readLength);
Tom Josepha4953392017-06-30 19:09:47 +0530391 *data_len = sizeof(record.nextRecordID) + readLength;
392 }
393
394 return IPMI_CC_OK;
395}
396
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000397/** @brief implements the delete SEL entry command
398 * @request
399 * - reservationID; // reservation ID.
400 * - selRecordID; // SEL record ID.
401 *
402 * @returns ipmi completion code plus response data
403 * - Record ID of the deleted record
404 */
405ipmi::RspType<uint16_t // deleted record ID
406 >
407 deleteSELEntry(uint16_t reservationID, uint16_t selRecordID)
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530408{
Jason M. Bills851acb12019-02-04 14:06:57 -0800409
Brad Bishop1a4117b2018-11-21 15:48:18 -0500410 namespace fs = std::filesystem;
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530411
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000412 if (!checkSELReservation(reservationID))
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530413 {
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000414 return ipmi::responseInvalidReservationId();
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530415 }
416
Jason M. Bills13e67c82018-09-10 14:12:16 -0700417 // Per the IPMI spec, need to cancel the reservation when a SEL entry is
418 // deleted
419 cancelSELReservation();
420
Lei YUeba8e9a2021-09-15 13:16:17 +0800421 if (!selCacheMapInitialized)
Tom Josephe59abfb2018-08-06 18:46:27 +0530422 {
Lei YUeba8e9a2021-09-15 13:16:17 +0800423 // In case the initSELCache() fails, try it again
424 initSELCache();
Tom Josephe59abfb2018-08-06 18:46:27 +0530425 }
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530426
Lei YUeba8e9a2021-09-15 13:16:17 +0800427 if (selCacheMap.empty())
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530428 {
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000429 return ipmi::responseSensorInvalid();
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530430 }
431
Lei YUeba8e9a2021-09-15 13:16:17 +0800432 SELCacheMap::const_iterator iter;
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530433 uint16_t delRecordID = 0;
434
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000435 if (selRecordID == ipmi::sel::firstEntry)
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530436 {
Lei YUeba8e9a2021-09-15 13:16:17 +0800437 delRecordID = selCacheMap.begin()->first;
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530438 }
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000439 else if (selRecordID == ipmi::sel::lastEntry)
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530440 {
Lei YUeba8e9a2021-09-15 13:16:17 +0800441 delRecordID = selCacheMap.rbegin()->first;
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530442 }
443 else
444 {
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000445 delRecordID = selRecordID;
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530446 }
447
Jian7d5f4812022-02-23 19:30:27 +0800448 iter = selCacheMap.find(delRecordID);
449 if (iter == selCacheMap.end())
450 {
451 return ipmi::responseSensorInvalid();
452 }
453
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530454 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
455 std::string service;
456
Lei YUeba8e9a2021-09-15 13:16:17 +0800457 auto objPath = getLoggingObjPath(iter->first);
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530458 try
459 {
Lei YUeba8e9a2021-09-15 13:16:17 +0800460 service = ipmi::getService(bus, ipmi::sel::logDeleteIntf, objPath);
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530461 }
462 catch (const std::runtime_error& e)
463 {
464 log<level::ERR>(e.what());
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000465 return ipmi::responseUnspecifiedError();
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530466 }
467
Lei YUeba8e9a2021-09-15 13:16:17 +0800468 auto methodCall = bus.new_method_call(service.c_str(), objPath.c_str(),
Patrick Venture0b02be92018-08-31 11:55:55 -0700469 ipmi::sel::logDeleteIntf, "Delete");
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530470 auto reply = bus.call(methodCall);
471 if (reply.is_method_error())
472 {
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000473 return ipmi::responseUnspecifiedError();
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530474 }
475
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000476 return ipmi::responseSuccess(delRecordID);
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530477}
478
Pradeep Kumar4a5a99a2019-04-26 15:22:39 +0000479/** @brief implements the Clear SEL command
480 * @request
481 * - reservationID // Reservation ID.
482 * - clr // char array { 'C'(0x43h), 'L'(0x4Ch), 'R'(0x52h) }
483 * - eraseOperation; // requested operation.
484 *
485 * @returns ipmi completion code plus response data
486 * - erase status
487 */
488
489ipmi::RspType<uint8_t // erase status
490 >
491 clearSEL(uint16_t reservationID, const std::array<char, 3>& clr,
492 uint8_t eraseOperation)
Tom Joseph2f05bb52017-06-30 19:14:49 +0530493{
Pradeep Kumar4a5a99a2019-04-26 15:22:39 +0000494 static constexpr std::array<char, 3> clrOk = {'C', 'L', 'R'};
495 if (clr != clrOk)
Jason M. Bills851acb12019-02-04 14:06:57 -0800496 {
Pradeep Kumar4a5a99a2019-04-26 15:22:39 +0000497 return ipmi::responseInvalidFieldRequest();
Jason M. Bills851acb12019-02-04 14:06:57 -0800498 }
499
Pradeep Kumar4a5a99a2019-04-26 15:22:39 +0000500 if (!checkSELReservation(reservationID))
Tom Joseph2f05bb52017-06-30 19:14:49 +0530501 {
Pradeep Kumar4a5a99a2019-04-26 15:22:39 +0000502 return ipmi::responseInvalidReservationId();
Tom Joseph2f05bb52017-06-30 19:14:49 +0530503 }
504
Tom Joseph2f05bb52017-06-30 19:14:49 +0530505 /*
506 * Erasure status cannot be fetched from DBUS, so always return erasure
507 * status as `erase completed`.
508 */
Pradeep Kumar4a5a99a2019-04-26 15:22:39 +0000509 if (eraseOperation == ipmi::sel::getEraseStatus)
Tom Joseph2f05bb52017-06-30 19:14:49 +0530510 {
Pradeep Kumar4a5a99a2019-04-26 15:22:39 +0000511 return ipmi::responseSuccess(
512 static_cast<uint8_t>(ipmi::sel::eraseComplete));
Tom Joseph2f05bb52017-06-30 19:14:49 +0530513 }
514
Jason M. Bills13e67c82018-09-10 14:12:16 -0700515 // Per the IPMI spec, need to cancel any reservation when the SEL is cleared
516 cancelSELReservation();
517
Tom Joseph2f05bb52017-06-30 19:14:49 +0530518 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
Lotus Xu78fe1b12021-05-23 17:26:56 +0800519 auto service = ipmi::getService(bus, ipmi::sel::logIntf, ipmi::sel::logObj);
520 auto method =
521 bus.new_method_call(service.c_str(), ipmi::sel::logObj,
522 ipmi::sel::logIntf, ipmi::sel::logDeleteAllMethod);
Tom Josephe59abfb2018-08-06 18:46:27 +0530523 try
Tom Joseph2f05bb52017-06-30 19:14:49 +0530524 {
Lotus Xu78fe1b12021-05-23 17:26:56 +0800525 bus.call_noreply(method);
Tom Josephe59abfb2018-08-06 18:46:27 +0530526 }
Patrick Williamsef1259b2021-09-02 09:12:33 -0500527 catch (const sdbusplus::exception::exception& e)
Tom Joseph2f05bb52017-06-30 19:14:49 +0530528 {
Lotus Xu78fe1b12021-05-23 17:26:56 +0800529 log<level::ERR>("Error eraseAll ", entry("ERROR=%s", e.what()));
Pradeep Kumar4a5a99a2019-04-26 15:22:39 +0000530 return ipmi::responseUnspecifiedError();
Tom Joseph2f05bb52017-06-30 19:14:49 +0530531 }
532
Pradeep Kumar4a5a99a2019-04-26 15:22:39 +0000533 return ipmi::responseSuccess(
534 static_cast<uint8_t>(ipmi::sel::eraseComplete));
Tom Joseph2f05bb52017-06-30 19:14:49 +0530535}
536
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000537/** @brief implements the get SEL time command
538 * @returns IPMI completion code plus response data
539 * -current time
540 */
541ipmi::RspType<uint32_t> // current time
542 ipmiStorageGetSelTime()
Adriana Kobylak8e30f2a2015-10-20 10:23:51 -0500543{
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530544 using namespace std::chrono;
George Liu4d623e92020-05-25 16:51:57 +0800545 uint64_t bmc_time_usec = 0;
546 std::stringstream bmcTime;
Adriana Kobylak8e30f2a2015-10-20 10:23:51 -0500547
Lei YUe8939392017-06-15 10:45:05 +0800548 try
549 {
550 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
George Liu4d623e92020-05-25 16:51:57 +0800551 auto service = ipmi::getService(bus, TIME_INTERFACE, BMC_TIME_PATH);
Vernon Mauery16b86932019-05-01 08:36:11 -0700552 std::variant<uint64_t> value;
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530553
George Liu4d623e92020-05-25 16:51:57 +0800554 // Get bmc time
555 auto method = bus.new_method_call(service.c_str(), BMC_TIME_PATH,
Patrick Venture0b02be92018-08-31 11:55:55 -0700556 DBUS_PROPERTIES, "Get");
Lei YUe8939392017-06-15 10:45:05 +0800557
558 method.append(TIME_INTERFACE, PROPERTY_ELAPSED);
559 auto reply = bus.call(method);
560 if (reply.is_method_error())
561 {
562 log<level::ERR>("Error getting time",
563 entry("SERVICE=%s", service.c_str()),
George Liu4d623e92020-05-25 16:51:57 +0800564 entry("PATH=%s", BMC_TIME_PATH));
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000565 return ipmi::responseUnspecifiedError();
Lei YUe8939392017-06-15 10:45:05 +0800566 }
567 reply.read(value);
George Liu4d623e92020-05-25 16:51:57 +0800568 bmc_time_usec = std::get<uint64_t>(value);
Lei YUe8939392017-06-15 10:45:05 +0800569 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -0500570 catch (const InternalFailure& e)
Lei YUe8939392017-06-15 10:45:05 +0800571 {
572 log<level::ERR>(e.what());
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000573 return ipmi::responseUnspecifiedError();
Lei YUe8939392017-06-15 10:45:05 +0800574 }
Tom Joseph30fd0a12019-09-24 06:53:22 +0530575 catch (const std::exception& e)
Lei YUe8939392017-06-15 10:45:05 +0800576 {
577 log<level::ERR>(e.what());
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000578 return ipmi::responseUnspecifiedError();
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530579 }
580
George Liu4d623e92020-05-25 16:51:57 +0800581 bmcTime << "BMC time:"
582 << duration_cast<seconds>(microseconds(bmc_time_usec)).count();
583 log<level::DEBUG>(bmcTime.str().c_str());
Nagaraju Goruganti8960b7c2018-04-29 22:38:40 -0500584
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530585 // Time is really long int but IPMI wants just uint32. This works okay until
586 // the number of seconds since 1970 overflows uint32 size.. Still a whole
587 // lot of time here to even think about that.
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000588 return ipmi::responseSuccess(
George Liu4d623e92020-05-25 16:51:57 +0800589 duration_cast<seconds>(microseconds(bmc_time_usec)).count());
Adriana Kobylak8e30f2a2015-10-20 10:23:51 -0500590}
591
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000592/** @brief implements the set SEL time command
593 * @param selDeviceTime - epoch time
594 * -local time as the number of seconds from 00:00:00, January 1, 1970
595 * @returns IPMI completion code
596 */
597ipmi::RspType<> ipmiStorageSetSelTime(uint32_t selDeviceTime)
Chris Austenb4f5b922015-10-13 12:44:43 -0500598{
Lei YUe8939392017-06-15 10:45:05 +0800599 using namespace std::chrono;
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000600 microseconds usec{seconds(selDeviceTime)};
Norman James82330442015-11-19 16:53:26 -0600601
Lei YUe8939392017-06-15 10:45:05 +0800602 try
603 {
604 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
shamim ali071d00c2022-03-02 15:42:46 +0530605 bool ntp = std::get<bool>(
606 ipmi::getDbusProperty(bus, SystemdTimeService, SystemdTimePath,
607 SystemdTimeInterface, "NTP"));
608 if (ntp)
609 {
610 return ipmi::responseCommandNotAvailable();
611 }
612
George Liu4d623e92020-05-25 16:51:57 +0800613 auto service = ipmi::getService(bus, TIME_INTERFACE, BMC_TIME_PATH);
Andrew Geissler6467ed22020-05-16 16:03:53 -0500614 std::variant<uint64_t> value{(uint64_t)usec.count()};
Lei YUe8939392017-06-15 10:45:05 +0800615
George Liu4d623e92020-05-25 16:51:57 +0800616 // Set bmc time
617 auto method = bus.new_method_call(service.c_str(), BMC_TIME_PATH,
Patrick Venture0b02be92018-08-31 11:55:55 -0700618 DBUS_PROPERTIES, "Set");
Lei YUe8939392017-06-15 10:45:05 +0800619
620 method.append(TIME_INTERFACE, PROPERTY_ELAPSED, value);
621 auto reply = bus.call(method);
622 if (reply.is_method_error())
623 {
624 log<level::ERR>("Error setting time",
625 entry("SERVICE=%s", service.c_str()),
George Liu4d623e92020-05-25 16:51:57 +0800626 entry("PATH=%s", BMC_TIME_PATH));
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000627 return ipmi::responseUnspecifiedError();
Lei YUe8939392017-06-15 10:45:05 +0800628 }
Norman James82330442015-11-19 16:53:26 -0600629 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -0500630 catch (const InternalFailure& e)
Lei YUe8939392017-06-15 10:45:05 +0800631 {
632 log<level::ERR>(e.what());
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000633 return ipmi::responseUnspecifiedError();
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530634 }
Tom Joseph30fd0a12019-09-24 06:53:22 +0530635 catch (const std::exception& e)
Lei YUe8939392017-06-15 10:45:05 +0800636 {
637 log<level::ERR>(e.what());
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000638 return ipmi::responseUnspecifiedError();
Norman James82330442015-11-19 16:53:26 -0600639 }
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530640
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000641 return ipmi::responseSuccess();
Chris Austenb4f5b922015-10-13 12:44:43 -0500642}
643
jayaprakash Mutyalab7557722019-05-02 21:13:30 +0000644/** @brief implements the reserve SEL command
645 * @returns IPMI completion code plus response data
646 * - SEL reservation ID.
647 */
648ipmi::RspType<uint16_t> ipmiStorageReserveSel()
Chris Austenb4f5b922015-10-13 12:44:43 -0500649{
jayaprakash Mutyalab7557722019-05-02 21:13:30 +0000650 return ipmi::responseSuccess(reserveSel());
Chris Austenb4f5b922015-10-13 12:44:43 -0500651}
652
anil kumar appana2c7db1d2019-05-28 11:20:19 +0000653/** @brief implements the Add SEL entry command
654 * @request
655 *
656 * - recordID ID used for SEL Record access
657 * - recordType Record Type
658 * - timeStamp Time when event was logged. LS byte first
659 * - generatorID software ID if event was generated from
660 * system software
661 * - evmRev event message format version
662 * - sensorType sensor type code for service that generated
663 * the event
664 * - sensorNumber number of sensors that generated the event
665 * - eventDir event dir
666 * - eventData event data field contents
667 *
668 * @returns ipmi completion code plus response data
669 * - RecordID of the Added SEL entry
670 */
671ipmi::RspType<uint16_t // recordID of the Added SEL entry
672 >
673 ipmiStorageAddSEL(uint16_t recordID, uint8_t recordType, uint32_t timeStamp,
674 uint16_t generatorID, uint8_t evmRev, uint8_t sensorType,
675 uint8_t sensorNumber, uint8_t eventDir,
676 std::array<uint8_t, eventDataSize> eventData)
Chris Austenb4f5b922015-10-13 12:44:43 -0500677{
Lotus Xu57d35572021-01-24 11:13:13 +0800678 std::string objpath;
679 static constexpr auto systemRecordType = 0x02;
Tom Josephb647d5b2017-10-31 17:25:33 +0530680 // Hostboot sends SEL with OEM record type 0xDE to indicate that there is
681 // a maintenance procedure associated with eSEL record.
682 static constexpr auto procedureType = 0xDE;
Lotus Xu57d35572021-01-24 11:13:13 +0800683 cancelSELReservation();
684 if (recordType == systemRecordType)
685 {
686
687 for (const auto& it : invSensors)
688 {
689 if (it.second.sensorID == sensorNumber)
690 {
691 objpath = it.first;
692 break;
693 }
694 }
695 auto selDataStr = ipmi::sel::toHexStr(eventData);
696
697 bool assert = (eventDir & 0x80) ? false : true;
698
699 recordID = report<SELCreated>(Created::RECORD_TYPE(recordType),
700 Created::GENERATOR_ID(generatorID),
701 Created::SENSOR_DATA(selDataStr.c_str()),
702 Created::EVENT_DIR(assert),
703 Created::SENSOR_PATH(objpath.c_str()));
704 }
705 else if (recordType == procedureType)
Tom Josephb647d5b2017-10-31 17:25:33 +0530706 {
707 // In the OEM record type 0xDE, byte 11 in the SEL record indicate the
708 // procedure number.
anil kumar appana2c7db1d2019-05-28 11:20:19 +0000709 createProcedureLogEntry(sensorType);
Tom Josephb647d5b2017-10-31 17:25:33 +0530710 }
Chris Austenb4f5b922015-10-13 12:44:43 -0500711
anil kumar appana2c7db1d2019-05-28 11:20:19 +0000712 return ipmi::responseSuccess(recordID);
Chris Austenb4f5b922015-10-13 12:44:43 -0500713}
714
Konstantin Aladyshev69e3cd42021-11-26 16:46:17 +0300715bool isFruPresent(ipmi::Context::ptr& ctx, const std::string& fruPath)
Kirill Pakhomovfa6e2092020-04-24 18:57:15 +0300716{
717 using namespace ipmi::fru;
718
Konstantin Aladyshev69e3cd42021-11-26 16:46:17 +0300719 std::string service;
720 boost::system::error_code ec =
721 getService(ctx, invItemInterface, invObjPath + fruPath, service);
722 if (!ec)
723 {
724 bool result;
725 ec = ipmi::getDbusProperty(ctx, service, invObjPath + fruPath,
726 invItemInterface, itemPresentProp, result);
727 if (!ec)
728 {
729 return result;
730 }
731 }
Konstantin Aladyshevc7e4b042021-12-24 15:30:47 +0300732
733 ipmi::ObjectValueTree managedObjects;
734 ec = getManagedObjects(ctx, "xyz.openbmc_project.EntityManager", "/",
735 managedObjects);
736 if (!ec)
737 {
738 auto connection = managedObjects.find(fruPath);
739 if (connection != managedObjects.end())
740 {
741 return true;
742 }
743 }
744
Konstantin Aladyshev69e3cd42021-11-26 16:46:17 +0300745 return false;
Kirill Pakhomovfa6e2092020-04-24 18:57:15 +0300746}
747
Pradeep Kumarb0c794d2019-05-02 13:09:14 +0000748/** @brief implements the get FRU Inventory Area Info command
749 *
750 * @returns IPMI completion code plus response data
751 * - FRU Inventory area size in bytes,
752 * - access bit
753 **/
754ipmi::RspType<uint16_t, // FRU Inventory area size in bytes,
755 uint8_t // access size (bytes / words)
756 >
Konstantin Aladyshev69e3cd42021-11-26 16:46:17 +0300757 ipmiStorageGetFruInvAreaInfo(ipmi::Context::ptr ctx, uint8_t fruID)
Marri Devender Raofa7b4e22017-07-03 00:52:20 -0500758{
Tom Joseph187f5642018-03-29 13:49:06 +0530759
Pradeep Kumarb0c794d2019-05-02 13:09:14 +0000760 auto iter = frus.find(fruID);
Tom Joseph187f5642018-03-29 13:49:06 +0530761 if (iter == frus.end())
762 {
Pradeep Kumarb0c794d2019-05-02 13:09:14 +0000763 return ipmi::responseSensorInvalid();
Tom Joseph187f5642018-03-29 13:49:06 +0530764 }
765
Kirill Pakhomovfa6e2092020-04-24 18:57:15 +0300766 auto path = iter->second[0].path;
Konstantin Aladyshev69e3cd42021-11-26 16:46:17 +0300767 if (!isFruPresent(ctx, path))
Kirill Pakhomovfa6e2092020-04-24 18:57:15 +0300768 {
769 return ipmi::responseSensorInvalid();
770 }
771
Marri Devender Raocac383b2017-07-03 13:24:27 -0500772 try
773 {
Pradeep Kumarb0c794d2019-05-02 13:09:14 +0000774 return ipmi::responseSuccess(
775 static_cast<uint16_t>(getFruAreaData(fruID).size()),
776 static_cast<uint8_t>(AccessMode::bytes));
Marri Devender Raocac383b2017-07-03 13:24:27 -0500777 }
Patrick Venture0b02be92018-08-31 11:55:55 -0700778 catch (const InternalFailure& e)
Marri Devender Raocac383b2017-07-03 13:24:27 -0500779 {
Marri Devender Raocac383b2017-07-03 13:24:27 -0500780 log<level::ERR>(e.what());
Pradeep Kumarb0c794d2019-05-02 13:09:14 +0000781 return ipmi::responseUnspecifiedError();
Marri Devender Raocac383b2017-07-03 13:24:27 -0500782 }
Marri Devender Raofa7b4e22017-07-03 00:52:20 -0500783}
784
anil kumar appana5b7c3262019-05-27 18:10:23 +0000785/**@brief implements the Read FRU Data command
786 * @param fruDeviceId - FRU device ID. FFh = reserved
787 * @param offset - FRU inventory offset to read
788 * @param readCount - count to read
789 *
790 * @return IPMI completion code plus response data
791 * - returnCount - response data count.
792 * - data - response data
793 */
794ipmi::RspType<uint8_t, // count returned
795 std::vector<uint8_t>> // FRU data
796 ipmiStorageReadFruData(uint8_t fruDeviceId, uint16_t offset,
797 uint8_t readCount)
Marri Devender Raofa7b4e22017-07-03 00:52:20 -0500798{
anil kumar appana5b7c3262019-05-27 18:10:23 +0000799 if (fruDeviceId == 0xFF)
Tom Joseph187f5642018-03-29 13:49:06 +0530800 {
anil kumar appana5b7c3262019-05-27 18:10:23 +0000801 return ipmi::responseInvalidFieldRequest();
Tom Joseph187f5642018-03-29 13:49:06 +0530802 }
803
anil kumar appana5b7c3262019-05-27 18:10:23 +0000804 auto iter = frus.find(fruDeviceId);
805 if (iter == frus.end())
806 {
807 return ipmi::responseSensorInvalid();
808 }
809
Marri Devender Raocac383b2017-07-03 13:24:27 -0500810 try
811 {
anil kumar appana5b7c3262019-05-27 18:10:23 +0000812 const auto& fruArea = getFruAreaData(fruDeviceId);
Marri Devender Raocac383b2017-07-03 13:24:27 -0500813 auto size = fruArea.size();
Nagaraju Goruganti7f2d7c92018-03-21 11:18:30 -0500814
Tom Josephefcd68b2018-04-26 18:46:27 +0530815 if (offset >= size)
816 {
anil kumar appana5b7c3262019-05-27 18:10:23 +0000817 return ipmi::responseParmOutOfRange();
Tom Josephefcd68b2018-04-26 18:46:27 +0530818 }
819
Nagaraju Goruganti7f2d7c92018-03-21 11:18:30 -0500820 // Write the count of response data.
anil kumar appana5b7c3262019-05-27 18:10:23 +0000821 uint8_t returnCount;
822 if ((offset + readCount) <= size)
Marri Devender Raocac383b2017-07-03 13:24:27 -0500823 {
anil kumar appana5b7c3262019-05-27 18:10:23 +0000824 returnCount = readCount;
Nagaraju Goruganti7f2d7c92018-03-21 11:18:30 -0500825 }
826 else
827 {
anil kumar appana5b7c3262019-05-27 18:10:23 +0000828 returnCount = size - offset;
Marri Devender Raocac383b2017-07-03 13:24:27 -0500829 }
Ratan Gupta2848d602018-01-31 20:39:20 +0530830
anil kumar appana5b7c3262019-05-27 18:10:23 +0000831 std::vector<uint8_t> fruData((fruArea.begin() + offset),
832 (fruArea.begin() + offset + returnCount));
Ratan Gupta2848d602018-01-31 20:39:20 +0530833
anil kumar appana5b7c3262019-05-27 18:10:23 +0000834 return ipmi::responseSuccess(returnCount, fruData);
Marri Devender Raocac383b2017-07-03 13:24:27 -0500835 }
836 catch (const InternalFailure& e)
837 {
Marri Devender Raocac383b2017-07-03 13:24:27 -0500838 log<level::ERR>(e.what());
anil kumar appana5b7c3262019-05-27 18:10:23 +0000839 return ipmi::responseUnspecifiedError();
Marri Devender Raocac383b2017-07-03 13:24:27 -0500840 }
Marri Devender Raofa7b4e22017-07-03 00:52:20 -0500841}
842
Pradeep Kumarb60e8402019-05-06 15:17:01 +0000843ipmi::RspType<uint8_t, // SDR version
844 uint16_t, // record count LS first
845 uint16_t, // free space in bytes, LS first
846 uint32_t, // addition timestamp LS first
847 uint32_t, // deletion timestamp LS first
848 uint8_t> // operation Support
849 ipmiGetRepositoryInfo()
Dhruvaraj Subhashchandrane66c3b02018-02-07 01:21:56 -0600850{
Dhruvaraj Subhashchandrane66c3b02018-02-07 01:21:56 -0600851
Pradeep Kumarb60e8402019-05-06 15:17:01 +0000852 constexpr uint8_t sdrVersion = 0x51;
853 constexpr uint16_t freeSpace = 0xFFFF;
854 constexpr uint32_t additionTimestamp = 0x0;
855 constexpr uint32_t deletionTimestamp = 0x0;
856 constexpr uint8_t operationSupport = 0;
Dhruvaraj Subhashchandrane66c3b02018-02-07 01:21:56 -0600857
Willy Tu0ca3bfe2022-01-28 09:40:18 -0800858 // Get SDR count. This returns the total number of SDRs in the device.
859 const auto& entityRecords =
860 ipmi::sensor::EntityInfoMapContainer::getContainer()
861 ->getIpmiEntityRecords();
862 uint16_t records =
863 ipmi::sensor::sensors.size() + frus.size() + entityRecords.size();
Dhruvaraj Subhashchandrane66c3b02018-02-07 01:21:56 -0600864
Pradeep Kumarb60e8402019-05-06 15:17:01 +0000865 return ipmi::responseSuccess(sdrVersion, records, freeSpace,
866 additionTimestamp, deletionTimestamp,
867 operationSupport);
Dhruvaraj Subhashchandrane66c3b02018-02-07 01:21:56 -0600868}
Chris Austenb4f5b922015-10-13 12:44:43 -0500869
Chris Austenb4f5b922015-10-13 12:44:43 -0500870void register_netfn_storage_functions()
871{
Lei YU3df36612021-09-15 11:41:11 +0800872 selCacheMapInitialized = false;
Lei YUd9e57662021-09-14 18:06:28 +0800873 initSELCache();
Willy Tud351a722021-08-12 14:33:40 -0700874 // Handlers with dbus-sdr handler implementation.
875 // Do not register the hander if it dynamic sensors stack is used.
876
877#ifndef FEATURE_DYNAMIC_SENSORS
Tom Joseph6f7deaa2017-06-30 19:03:54 +0530878 // <Get SEL Info>
jayaprakash Mutyalab7557722019-05-02 21:13:30 +0000879 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
880 ipmi::storage::cmdGetSelInfo, ipmi::Privilege::User,
881 ipmiStorageGetSelInfo);
Tom Joseph6f7deaa2017-06-30 19:03:54 +0530882
Tom05732372016-09-06 17:21:23 +0530883 // <Get SEL Time>
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000884 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
885 ipmi::storage::cmdGetSelTime, ipmi::Privilege::User,
886 ipmiStorageGetSelTime);
Adriana Kobylak8e30f2a2015-10-20 10:23:51 -0500887
Tom05732372016-09-06 17:21:23 +0530888 // <Set SEL Time>
jayaprakash Mutyaladb2e8c42019-05-03 01:38:01 +0000889 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
890 ipmi::storage::cmdSetSelTime,
891 ipmi::Privilege::Operator, ipmiStorageSetSelTime);
Chris Austenb4f5b922015-10-13 12:44:43 -0500892
Tom Josepha4953392017-06-30 19:09:47 +0530893 // <Get SEL Entry>
Patrick Venture0b02be92018-08-31 11:55:55 -0700894 ipmi_register_callback(NETFUN_STORAGE, IPMI_CMD_GET_SEL_ENTRY, NULL,
895 getSELEntry, PRIVILEGE_USER);
Tom Josepha4953392017-06-30 19:09:47 +0530896
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530897 // <Delete SEL Entry>
Pradeep Kumar00a18d02019-04-26 17:04:28 +0000898 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
899 ipmi::storage::cmdDeleteSelEntry,
900 ipmi::Privilege::Operator, deleteSELEntry);
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530901
Tom05732372016-09-06 17:21:23 +0530902 // <Add SEL Entry>
anil kumar appana2c7db1d2019-05-28 11:20:19 +0000903 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
904 ipmi::storage::cmdAddSelEntry,
905 ipmi::Privilege::Operator, ipmiStorageAddSEL);
906
Tom Joseph2f05bb52017-06-30 19:14:49 +0530907 // <Clear SEL>
Pradeep Kumar4a5a99a2019-04-26 15:22:39 +0000908 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
909 ipmi::storage::cmdClearSel, ipmi::Privilege::Operator,
910 clearSEL);
911
Marri Devender Raofa7b4e22017-07-03 00:52:20 -0500912 // <Get FRU Inventory Area Info>
Pradeep Kumarb0c794d2019-05-02 13:09:14 +0000913 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
914 ipmi::storage::cmdGetFruInventoryAreaInfo,
915 ipmi::Privilege::User, ipmiStorageGetFruInvAreaInfo);
Marri Devender Raofa7b4e22017-07-03 00:52:20 -0500916
Jason M. Billsb5248c92019-06-24 15:53:08 -0700917 // <READ FRU Data>
anil kumar appana5b7c3262019-05-27 18:10:23 +0000918 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
919 ipmi::storage::cmdReadFruData,
920 ipmi::Privilege::Operator, ipmiStorageReadFruData);
Marri Devender Raocac383b2017-07-03 13:24:27 -0500921
Dhruvaraj Subhashchandrane66c3b02018-02-07 01:21:56 -0600922 // <Get Repository Info>
Pradeep Kumarb60e8402019-05-06 15:17:01 +0000923 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
924 ipmi::storage::cmdGetSdrRepositoryInfo,
925 ipmi::Privilege::User, ipmiGetRepositoryInfo);
Dhruvaraj Subhashchandrane66c3b02018-02-07 01:21:56 -0600926
Tom Joseph5ca50952018-02-22 00:33:38 +0530927 // <Reserve SDR Repository>
jayaprakash Mutyalad9578232019-05-13 20:22:50 +0000928 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
929 ipmi::storage::cmdReserveSdrRepository,
930 ipmi::Privilege::User, ipmiSensorReserveSdr);
Tom Joseph5ca50952018-02-22 00:33:38 +0530931
932 // <Get SDR>
Patrick Venture0b02be92018-08-31 11:55:55 -0700933 ipmi_register_callback(NETFUN_STORAGE, IPMI_CMD_GET_SDR, nullptr,
934 ipmi_sen_get_sdr, PRIVILEGE_USER);
Tom Joseph5ca50952018-02-22 00:33:38 +0530935
Willy Tud351a722021-08-12 14:33:40 -0700936#endif
937
938 // Common Handers used by both implementation.
939
940 // <Reserve SEL>
941 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
942 ipmi::storage::cmdReserveSel, ipmi::Privilege::User,
943 ipmiStorageReserveSel);
944
Marri Devender Rao908f7502017-07-10 01:49:54 -0500945 ipmi::fru::registerCallbackHandler();
Chris Austenb4f5b922015-10-13 12:44:43 -0500946 return;
947}