blob: c020948354fc56e906dc2a64cdfdd3ef86956aeb [file] [log] [blame]
Marri Devender Raocac383b2017-07-03 13:24:27 -05001#include <algorithm>
Lei YU52d91242017-10-17 22:52:28 +08002#include <arpa/inet.h>
3#include <chrono>
4#include <cstdio>
Tom Josepha4953392017-06-30 19:09:47 +05305#include <experimental/filesystem>
Lei YU52d91242017-10-17 22:52:28 +08006#include <mapper.h>
7#include <string>
8#include <systemd/sd-bus.h>
9
Tom Joseph6f7deaa2017-06-30 19:03:54 +053010#include <phosphor-logging/log.hpp>
Marri Devender Raocac383b2017-07-03 13:24:27 -050011#include <phosphor-logging/elog-errors.hpp>
Lei YU52d91242017-10-17 22:52:28 +080012#include <sdbusplus/server.hpp>
13
Dhruvaraj Subhashchandrane66c3b02018-02-07 01:21:56 -060014#include "fruread.hpp"
Lei YU52d91242017-10-17 22:52:28 +080015#include "host-ipmid/ipmid-api.h"
16#include "read_fru_data.hpp"
17#include "selutility.hpp"
18#include "storageaddsel.h"
19#include "storagehandler.h"
20#include "utils.hpp"
21#include "xyz/openbmc_project/Common/error.hpp"
Tom Joseph5ca50952018-02-22 00:33:38 +053022#include "sensorhandler.h"
Lei YU52d91242017-10-17 22:52:28 +080023
Chris Austen41a4b312015-10-25 03:45:42 -050024
Chris Austenb4f5b922015-10-13 12:44:43 -050025void register_netfn_storage_functions() __attribute__((constructor));
26
Chris Austenb4f5b922015-10-13 12:44:43 -050027unsigned int g_sel_time = 0xFFFFFFFF;
Nan Li36c0cb62016-03-31 11:16:08 +080028extern unsigned short g_sel_reserve;
Dhruvaraj Subhashchandrane66c3b02018-02-07 01:21:56 -060029extern const ipmi::sensor::IdInfoMap sensors;
30extern const FruMap frus;
Chris Austenb4f5b922015-10-13 12:44:43 -050031
Lei YUe8939392017-06-15 10:45:05 +080032namespace {
33constexpr auto TIME_INTERFACE = "xyz.openbmc_project.Time.EpochTime";
34constexpr auto HOST_TIME_PATH = "/xyz/openbmc_project/time/host";
35constexpr auto DBUS_PROPERTIES = "org.freedesktop.DBus.Properties";
36constexpr auto PROPERTY_ELAPSED= "Elapsed";
37
38const char* getTimeString(const uint64_t& usecSinceEpoch)
39{
40 using namespace std::chrono;
41 system_clock::time_point tp{microseconds(usecSinceEpoch)};
42 auto t = system_clock::to_time_t(tp);
43 return std::ctime(&t);
44}
45}
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +053046
Tom Joseph6f7deaa2017-06-30 19:03:54 +053047namespace cache
48{
49 /*
50 * This cache contains the object paths of the logging entries sorted in the
51 * order of the filename(numeric order). The cache is initialized by
52 * invoking readLoggingObjectPaths with the cache as the parameter. The
53 * cache is invoked in the execution of the Get SEL info and Delete SEL
54 * entry command. The Get SEL Info command is typically invoked before the
55 * Get SEL entry command, so the cache is utilized for responding to Get SEL
56 * entry command. The cache is invalidated by clearing after Delete SEL
57 * entry and Clear SEL command.
58 */
59 ipmi::sel::ObjectPaths paths;
60
61} // namespace objectPathsCache
62
63using InternalFailure =
64 sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
65using namespace phosphor::logging;
Marri Devender Raocac383b2017-07-03 13:24:27 -050066using namespace ipmi::fru;
67
68/**
69 * @enum Device access mode
70 */
71enum class AccessMode
72{
73 bytes, ///< Device is accessed by bytes
74 words ///< Device is accessed by words
75};
76
Tom Joseph6f7deaa2017-06-30 19:03:54 +053077
Adriana Kobylak8e30f2a2015-10-20 10:23:51 -050078ipmi_ret_t ipmi_storage_wildcard(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
79 ipmi_request_t request, ipmi_response_t response,
Chris Austenb4f5b922015-10-13 12:44:43 -050080 ipmi_data_len_t data_len, ipmi_context_t context)
81{
Chris Austenb4f5b922015-10-13 12:44:43 -050082 // Status code.
Nan Li70aa8d92016-08-29 00:11:10 +080083 ipmi_ret_t rc = IPMI_CC_INVALID;
Chris Austenb4f5b922015-10-13 12:44:43 -050084 *data_len = 0;
85 return rc;
86}
87
Tom Joseph6f7deaa2017-06-30 19:03:54 +053088ipmi_ret_t getSELInfo(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
89 ipmi_request_t request, ipmi_response_t response,
90 ipmi_data_len_t data_len, ipmi_context_t context)
91{
92 std::vector<uint8_t> outPayload(sizeof(ipmi::sel::GetSELInfoResponse));
93 auto responseData = reinterpret_cast<ipmi::sel::GetSELInfoResponse*>
94 (outPayload.data());
95
96 responseData->selVersion = ipmi::sel::selVersion;
97 // Last erase timestamp is not available from log manager.
98 responseData->eraseTimeStamp = ipmi::sel::invalidTimeStamp;
99 responseData->operationSupport = ipmi::sel::operationSupport;
100
101 ipmi::sel::readLoggingObjectPaths(cache::paths);
102 responseData->entries = 0;
103 responseData->addTimeStamp = ipmi::sel::invalidTimeStamp;
104
105 if (!cache::paths.empty())
106 {
107 responseData->entries = static_cast<uint16_t>(cache::paths.size());
108
109 try
110 {
111 responseData->addTimeStamp = static_cast<uint32_t>(
112 (ipmi::sel::getEntryTimeStamp(cache::paths.back())
113 .count()));
114 }
115 catch (InternalFailure& e)
116 {
117 }
118 catch (const std::runtime_error& e)
119 {
120 log<level::ERR>(e.what());
121 }
122 }
123
124 memcpy(response, outPayload.data(), outPayload.size());
125 *data_len = outPayload.size();
126
127 return IPMI_CC_OK;
128}
129
Tom Josepha4953392017-06-30 19:09:47 +0530130ipmi_ret_t getSELEntry(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
131 ipmi_request_t request, ipmi_response_t response,
132 ipmi_data_len_t data_len, ipmi_context_t context)
133{
134 auto requestData = reinterpret_cast<const ipmi::sel::GetSELEntryRequest*>
135 (request);
136
137 if (requestData->reservationID != 0)
138 {
139 if (g_sel_reserve != requestData->reservationID)
140 {
141 *data_len = 0;
142 return IPMI_CC_INVALID_RESERVATION_ID;
143 }
144 }
145
146 if (cache::paths.empty())
147 {
148 *data_len = 0;
149 return IPMI_CC_SENSOR_INVALID;
150 }
151
152 ipmi::sel::ObjectPaths::const_iterator iter;
153
154 // Check for the requested SEL Entry.
155 if (requestData->selRecordID == ipmi::sel::firstEntry)
156 {
157 iter = cache::paths.begin();
158 }
159 else if (requestData->selRecordID == ipmi::sel::lastEntry)
160 {
161 iter = cache::paths.end();
162 }
163 else
164 {
165 std::string objPath = std::string(ipmi::sel::logBasePath) + "/" +
166 std::to_string(requestData->selRecordID);
167
168 iter = std::find(cache::paths.begin(), cache::paths.end(), objPath);
169 if (iter == cache::paths.end())
170 {
171 *data_len = 0;
172 return IPMI_CC_SENSOR_INVALID;
173 }
174 }
175
176 ipmi::sel::GetSELEntryResponse record {};
177
178 // Convert the log entry into SEL record.
179 try
180 {
181 record = ipmi::sel::convertLogEntrytoSEL(*iter);
182 }
183 catch (InternalFailure& e)
184 {
185 *data_len = 0;
186 return IPMI_CC_UNSPECIFIED_ERROR;
187 }
188 catch (const std::runtime_error& e)
189 {
190 log<level::ERR>(e.what());
191 *data_len = 0;
192 return IPMI_CC_UNSPECIFIED_ERROR;
193 }
194
195
196 // Identify the next SEL record ID
197 if(iter != cache::paths.end())
198 {
199 ++iter;
200 if (iter == cache::paths.end())
201 {
202 record.nextRecordID = ipmi::sel::lastEntry;
203 }
204 else
205 {
206 namespace fs = std::experimental::filesystem;
207 fs::path path(*iter);
208 record.nextRecordID = static_cast<uint16_t>
209 (std::stoul(std::string(path.filename().c_str())));
210 }
211 }
212 else
213 {
214 record.nextRecordID = ipmi::sel::lastEntry;
215 }
216
217 if (requestData->readLength == ipmi::sel::entireRecord)
218 {
219 memcpy(response, &record, sizeof(record));
220 *data_len = sizeof(record);
221 }
222 else
223 {
224 if (requestData->offset >= ipmi::sel::selRecordSize ||
225 requestData->readLength > ipmi::sel::selRecordSize)
226 {
227 *data_len = 0;
228 return IPMI_CC_INVALID_FIELD_REQUEST;
229 }
230
231 auto diff = ipmi::sel::selRecordSize - requestData->offset;
232 auto readLength = std::min(diff,
233 static_cast<int>(requestData->readLength));
234
235 memcpy(response, &record.nextRecordID, sizeof(record.nextRecordID));
236 memcpy(static_cast<uint8_t*>(response) + sizeof(record.nextRecordID),
237 &record.recordID + requestData->offset, readLength);
238 *data_len = sizeof(record.nextRecordID) + readLength;
239 }
240
241 return IPMI_CC_OK;
242}
243
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530244ipmi_ret_t deleteSELEntry(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
245 ipmi_request_t request, ipmi_response_t response,
246 ipmi_data_len_t data_len, ipmi_context_t context)
247{
248 namespace fs = std::experimental::filesystem;
249 auto requestData = reinterpret_cast<const ipmi::sel::DeleteSELEntryRequest*>
250 (request);
251
252 if (g_sel_reserve != requestData->reservationID)
253 {
254 *data_len = 0;
255 return IPMI_CC_INVALID_RESERVATION_ID;
256 }
257
258 ipmi::sel::readLoggingObjectPaths(cache::paths);
259
260 if (cache::paths.empty())
261 {
262 *data_len = 0;
263 return IPMI_CC_SENSOR_INVALID;
264 }
265
266 ipmi::sel::ObjectPaths::const_iterator iter;
267 uint16_t delRecordID = 0;
268
269 if (requestData->selRecordID == ipmi::sel::firstEntry)
270 {
271 iter = cache::paths.begin();
272 fs::path path(*iter);
273 delRecordID = static_cast<uint16_t>
274 (std::stoul(std::string(path.filename().c_str())));
275 }
276 else if (requestData->selRecordID == ipmi::sel::lastEntry)
277 {
278 iter = cache::paths.end();
279 fs::path path(*iter);
280 delRecordID = static_cast<uint16_t>
281 (std::stoul(std::string(path.filename().c_str())));
282 }
283 else
284 {
285 std::string objPath = std::string(ipmi::sel::logBasePath) + "/" +
286 std::to_string(requestData->selRecordID);
287
288 iter = std::find(cache::paths.begin(), cache::paths.end(), objPath);
289 if (iter == cache::paths.end())
290 {
291 *data_len = 0;
292 return IPMI_CC_SENSOR_INVALID;
293 }
294 delRecordID = requestData->selRecordID;
295 }
296
297 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
298 std::string service;
299
300 try
301 {
302 service = ipmi::getService(bus, ipmi::sel::logDeleteIntf, *iter);
303 }
304 catch (const std::runtime_error& e)
305 {
306 log<level::ERR>(e.what());
307 *data_len = 0;
308 return IPMI_CC_UNSPECIFIED_ERROR;
309 }
310
311 auto methodCall = bus.new_method_call(service.c_str(),
312 (*iter).c_str(),
313 ipmi::sel::logDeleteIntf,
314 "Delete");
315 auto reply = bus.call(methodCall);
316 if (reply.is_method_error())
317 {
318 *data_len = 0;
319 return IPMI_CC_UNSPECIFIED_ERROR;
320 }
321
322 // Invalidate the cache of dbus entry objects.
323 cache::paths.clear();
324 memcpy(response, &delRecordID, sizeof(delRecordID));
325 *data_len = sizeof(delRecordID);
326
327 return IPMI_CC_OK;
328}
329
Tom Joseph2f05bb52017-06-30 19:14:49 +0530330ipmi_ret_t clearSEL(ipmi_netfn_t netfn, ipmi_cmd_t cmd, ipmi_request_t request,
331 ipmi_response_t response, ipmi_data_len_t data_len,
332 ipmi_context_t context)
333{
334 auto requestData = reinterpret_cast<const ipmi::sel::ClearSELRequest*>
335 (request);
336
337 if (g_sel_reserve != requestData->reservationID)
338 {
339 *data_len = 0;
340 return IPMI_CC_INVALID_RESERVATION_ID;
341 }
342
343 if (requestData->charC != 'C' ||
344 requestData->charL != 'L' ||
345 requestData->charR != 'R')
346 {
347 *data_len = 0;
348 return IPMI_CC_INVALID_FIELD_REQUEST;
349 }
350
351 uint8_t eraseProgress = ipmi::sel::eraseComplete;
352
353 /*
354 * Erasure status cannot be fetched from DBUS, so always return erasure
355 * status as `erase completed`.
356 */
357 if (requestData->eraseOperation == ipmi::sel::getEraseStatus)
358 {
359 memcpy(response, &eraseProgress, sizeof(eraseProgress));
360 *data_len = sizeof(eraseProgress);
361 return IPMI_CC_OK;
362 }
363
364 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
365 auto depth = 0;
366
367 auto mapperCall = bus.new_method_call(ipmi::sel::mapperBusName,
368 ipmi::sel::mapperObjPath,
369 ipmi::sel::mapperIntf,
370 "GetSubTreePaths");
371 mapperCall.append(ipmi::sel::logBasePath);
372 mapperCall.append(depth);
373 mapperCall.append(ipmi::sel::ObjectPaths({ipmi::sel::logEntryIntf}));
374
375 auto reply = bus.call(mapperCall);
376 if (reply.is_method_error())
377 {
378 memcpy(response, &eraseProgress, sizeof(eraseProgress));
379 *data_len = sizeof(eraseProgress);
380 return IPMI_CC_OK;
381 }
382
383 ipmi::sel::ObjectPaths objectPaths;
384 reply.read(objectPaths);
385 if (objectPaths.empty())
386 {
387 memcpy(response, &eraseProgress, sizeof(eraseProgress));
388 *data_len = sizeof(eraseProgress);
389 return IPMI_CC_OK;
390 }
391
392 std::string service;
393
394 try
395 {
396 service = ipmi::getService(bus,
397 ipmi::sel::logDeleteIntf,
398 objectPaths.front());
399 }
400 catch (const std::runtime_error& e)
401 {
402 log<level::ERR>(e.what());
403 *data_len = 0;
404 return IPMI_CC_UNSPECIFIED_ERROR;
405 }
406
407 for (const auto& iter : objectPaths)
408 {
409 auto methodCall = bus.new_method_call(service.c_str(),
410 iter.c_str(),
411 ipmi::sel::logDeleteIntf,
412 "Delete");
413
414 auto reply = bus.call(methodCall);
415 if (reply.is_method_error())
416 {
417 *data_len = 0;
418 return IPMI_CC_UNSPECIFIED_ERROR;
419 }
420 }
421
422 // Invalidate the cache of dbus entry objects.
423 cache::paths.clear();
424 memcpy(response, &eraseProgress, sizeof(eraseProgress));
425 *data_len = sizeof(eraseProgress);
426 return IPMI_CC_OK;
427}
428
Adriana Kobylak8e30f2a2015-10-20 10:23:51 -0500429ipmi_ret_t ipmi_storage_get_sel_time(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
430 ipmi_request_t request, ipmi_response_t response,
431 ipmi_data_len_t data_len, ipmi_context_t context)
432{
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530433 using namespace std::chrono;
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530434 uint64_t host_time_usec = 0;
435 uint32_t resp = 0;
Nagaraju Goruganti8960b7c2018-04-29 22:38:40 -0500436 std::stringstream hostTime;
Adriana Kobylak8e30f2a2015-10-20 10:23:51 -0500437
Lei YUe8939392017-06-15 10:45:05 +0800438 try
439 {
440 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
441 auto service = ipmi::getService(bus, TIME_INTERFACE, HOST_TIME_PATH);
442 sdbusplus::message::variant<uint64_t> value;
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530443
Lei YUe8939392017-06-15 10:45:05 +0800444 // Get host time
445 auto method = bus.new_method_call(service.c_str(),
446 HOST_TIME_PATH,
447 DBUS_PROPERTIES,
448 "Get");
449
450 method.append(TIME_INTERFACE, PROPERTY_ELAPSED);
451 auto reply = bus.call(method);
452 if (reply.is_method_error())
453 {
454 log<level::ERR>("Error getting time",
455 entry("SERVICE=%s", service.c_str()),
456 entry("PATH=%s", HOST_TIME_PATH));
457 return IPMI_CC_UNSPECIFIED_ERROR;
458 }
459 reply.read(value);
460 host_time_usec = value.get<uint64_t>();
461 }
462 catch (InternalFailure& e)
463 {
464 log<level::ERR>(e.what());
465 return IPMI_CC_UNSPECIFIED_ERROR;
466 }
467 catch (const std::runtime_error& e)
468 {
469 log<level::ERR>(e.what());
470 return IPMI_CC_UNSPECIFIED_ERROR;
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530471 }
472
Nagaraju Goruganti8960b7c2018-04-29 22:38:40 -0500473 hostTime << "Host time:" << getTimeString(host_time_usec);
474 log<level::DEBUG>(hostTime.str().c_str());
475
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530476
477 // Time is really long int but IPMI wants just uint32. This works okay until
478 // the number of seconds since 1970 overflows uint32 size.. Still a whole
479 // lot of time here to even think about that.
480 resp = duration_cast<seconds>(microseconds(host_time_usec)).count();
481 resp = htole32(resp);
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530482
Adriana Kobylak8e30f2a2015-10-20 10:23:51 -0500483 // From the IPMI Spec 2.0, response should be a 32-bit value
484 *data_len = sizeof(resp);
485
486 // Pack the actual response
487 memcpy(response, &resp, *data_len);
488
Lei YUe8939392017-06-15 10:45:05 +0800489 return IPMI_CC_OK;
Adriana Kobylak8e30f2a2015-10-20 10:23:51 -0500490}
491
492ipmi_ret_t ipmi_storage_set_sel_time(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
493 ipmi_request_t request, ipmi_response_t response,
Chris Austenb4f5b922015-10-13 12:44:43 -0500494 ipmi_data_len_t data_len, ipmi_context_t context)
495{
Lei YUe8939392017-06-15 10:45:05 +0800496 using namespace std::chrono;
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530497 ipmi_ret_t rc = IPMI_CC_OK;
Lei YUe8939392017-06-15 10:45:05 +0800498 uint32_t secs = *static_cast<uint32_t*>(request);
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530499 *data_len = 0;
Chris Austenb4f5b922015-10-13 12:44:43 -0500500
Lei YUe8939392017-06-15 10:45:05 +0800501 secs = le32toh(secs);
502 microseconds usec{seconds(secs)};
Norman James82330442015-11-19 16:53:26 -0600503
Lei YUe8939392017-06-15 10:45:05 +0800504 try
505 {
506 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
507 auto service = ipmi::getService(bus, TIME_INTERFACE, HOST_TIME_PATH);
508 sdbusplus::message::variant<uint64_t> value{usec.count()};
509
510 // Set host time
511 auto method = bus.new_method_call(service.c_str(),
512 HOST_TIME_PATH,
513 DBUS_PROPERTIES,
514 "Set");
515
516 method.append(TIME_INTERFACE, PROPERTY_ELAPSED, value);
517 auto reply = bus.call(method);
518 if (reply.is_method_error())
519 {
520 log<level::ERR>("Error setting time",
521 entry("SERVICE=%s", service.c_str()),
522 entry("PATH=%s", HOST_TIME_PATH));
523 rc = IPMI_CC_UNSPECIFIED_ERROR;
524 }
Norman James82330442015-11-19 16:53:26 -0600525 }
Lei YUe8939392017-06-15 10:45:05 +0800526 catch (InternalFailure& e)
527 {
528 log<level::ERR>(e.what());
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530529 rc = IPMI_CC_UNSPECIFIED_ERROR;
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530530 }
Lei YUe8939392017-06-15 10:45:05 +0800531 catch (const std::runtime_error& e)
532 {
533 log<level::ERR>(e.what());
Norman James82330442015-11-19 16:53:26 -0600534 rc = IPMI_CC_UNSPECIFIED_ERROR;
535 }
Vishwanatha Subbanna5fba7a62016-09-01 14:06:07 +0530536
Chris Austenb4f5b922015-10-13 12:44:43 -0500537 return rc;
538}
539
Adriana Kobylak8e30f2a2015-10-20 10:23:51 -0500540ipmi_ret_t ipmi_storage_reserve_sel(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
541 ipmi_request_t request, ipmi_response_t response,
Chris Austenb4f5b922015-10-13 12:44:43 -0500542 ipmi_data_len_t data_len, ipmi_context_t context)
543{
Chris Austenb4f5b922015-10-13 12:44:43 -0500544 ipmi_ret_t rc = IPMI_CC_OK;
545
Nan Li36c0cb62016-03-31 11:16:08 +0800546 // IPMI spec, Reservation ID, the value simply increases against each execution of reserve_sel command.
547 if( ++g_sel_reserve == 0)
548 g_sel_reserve = 1;
Chris Austenb4f5b922015-10-13 12:44:43 -0500549
550 *data_len = sizeof(g_sel_reserve);
551
552 // Pack the actual response
553 memcpy(response, &g_sel_reserve, *data_len);
554
555 return rc;
556}
557
Adriana Kobylak8e30f2a2015-10-20 10:23:51 -0500558ipmi_ret_t ipmi_storage_add_sel(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
559 ipmi_request_t request, ipmi_response_t response,
Chris Austenb4f5b922015-10-13 12:44:43 -0500560 ipmi_data_len_t data_len, ipmi_context_t context)
561{
562
563 ipmi_ret_t rc = IPMI_CC_OK;
Chris Austen41a4b312015-10-25 03:45:42 -0500564 ipmi_add_sel_request_t *p = (ipmi_add_sel_request_t*) request;
565 uint16_t recordid;
Chris Austenb4f5b922015-10-13 12:44:43 -0500566
Chris Austen313d95b2015-10-31 12:55:30 -0500567 recordid = ((uint16_t)p->eventdata[1] << 8) | p->eventdata[2];
Chris Austen41a4b312015-10-25 03:45:42 -0500568
Chris Austenb4f5b922015-10-13 12:44:43 -0500569 *data_len = sizeof(g_sel_reserve);
570
571 // Pack the actual response
Chris Austen7cc33322015-11-11 00:20:22 -0600572 memcpy(response, &p->eventdata[1], 2);
Chris Austenb4f5b922015-10-13 12:44:43 -0500573
Tom Josephb647d5b2017-10-31 17:25:33 +0530574 // Hostboot sends SEL with OEM record type 0xDE to indicate that there is
575 // a maintenance procedure associated with eSEL record.
576 static constexpr auto procedureType = 0xDE;
577 if (p->recordtype == procedureType)
578 {
579 // In the OEM record type 0xDE, byte 11 in the SEL record indicate the
580 // procedure number.
581 createProcedureLogEntry(p->sensortype);
582 }
583 else
584 {
585 send_esel(recordid);
586 }
Chris Austenb4f5b922015-10-13 12:44:43 -0500587
588 return rc;
589}
590
Marri Devender Raofa7b4e22017-07-03 00:52:20 -0500591//Read FRU info area
592ipmi_ret_t ipmi_storage_get_fru_inv_area_info(
593 ipmi_netfn_t netfn, ipmi_cmd_t cmd, ipmi_request_t request,
594 ipmi_response_t response, ipmi_data_len_t data_len,
595 ipmi_context_t context)
596{
597 ipmi_ret_t rc = IPMI_CC_OK;
Marri Devender Raocac383b2017-07-03 13:24:27 -0500598 const FruInvenAreaInfoRequest* reqptr =
599 reinterpret_cast<const FruInvenAreaInfoRequest*>(request);
Tom Joseph187f5642018-03-29 13:49:06 +0530600
601 auto iter = frus.find(reqptr->fruID);
602 if (iter == frus.end())
603 {
604 *data_len = 0;
605 return IPMI_CC_SENSOR_INVALID;
606 }
607
Marri Devender Raocac383b2017-07-03 13:24:27 -0500608 try
609 {
610 const auto& fruArea = getFruAreaData(reqptr->fruID);
611 auto size = static_cast<uint16_t>(fruArea.size());
612 FruInvenAreaInfoResponse resp;
613 resp.sizems = size >> 8;
614 resp.sizels = size;
615 resp.access = static_cast<uint8_t>(AccessMode::bytes);
616
617 *data_len = sizeof(resp);
618
619 // Pack the actual response
620 memcpy(response, &resp, *data_len);
621 }
622 catch(const InternalFailure& e)
623 {
624 rc = IPMI_CC_UNSPECIFIED_ERROR;
625 *data_len = 0;
626 log<level::ERR>(e.what());
Marri Devender Raocac383b2017-07-03 13:24:27 -0500627 }
Marri Devender Raofa7b4e22017-07-03 00:52:20 -0500628 return rc;
629}
630
631//Read FRU data
632ipmi_ret_t ipmi_storage_read_fru_data(
633 ipmi_netfn_t netfn, ipmi_cmd_t cmd, ipmi_request_t request,
634 ipmi_response_t response, ipmi_data_len_t data_len,
635 ipmi_context_t context)
636{
637 ipmi_ret_t rc = IPMI_CC_OK;
Marri Devender Raocac383b2017-07-03 13:24:27 -0500638 const ReadFruDataRequest* reqptr =
Nagaraju Goruganti7f2d7c92018-03-21 11:18:30 -0500639 reinterpret_cast<const ReadFruDataRequest*>(request);
640 auto resptr =
641 reinterpret_cast<ReadFruDataResponse*>(response);
Tom Joseph187f5642018-03-29 13:49:06 +0530642
643 auto iter = frus.find(reqptr->fruID);
644 if (iter == frus.end())
645 {
646 *data_len = 0;
647 return IPMI_CC_SENSOR_INVALID;
648 }
649
Marri Devender Raocac383b2017-07-03 13:24:27 -0500650 auto offset =
651 static_cast<uint16_t>(reqptr->offsetMS << 8 | reqptr->offsetLS);
652 try
653 {
654 const auto& fruArea = getFruAreaData(reqptr->fruID);
655 auto size = fruArea.size();
Nagaraju Goruganti7f2d7c92018-03-21 11:18:30 -0500656
Tom Josephefcd68b2018-04-26 18:46:27 +0530657 if (offset >= size)
658 {
659 return IPMI_CC_PARM_OUT_OF_RANGE;
660 }
661
Nagaraju Goruganti7f2d7c92018-03-21 11:18:30 -0500662 // Write the count of response data.
663 if ((offset + reqptr->count) <= size)
Marri Devender Raocac383b2017-07-03 13:24:27 -0500664 {
Nagaraju Goruganti7f2d7c92018-03-21 11:18:30 -0500665 resptr->count = reqptr->count;
666 }
667 else
668 {
669 resptr->count = size - offset;
Marri Devender Raocac383b2017-07-03 13:24:27 -0500670 }
Ratan Gupta2848d602018-01-31 20:39:20 +0530671
Ratan Gupta2848d602018-01-31 20:39:20 +0530672 std::copy((fruArea.begin() + offset),
Nagaraju Goruganti7f2d7c92018-03-21 11:18:30 -0500673 (fruArea.begin() + offset + resptr->count),
674 resptr->data);
Ratan Gupta2848d602018-01-31 20:39:20 +0530675
Nagaraju Goruganti7f2d7c92018-03-21 11:18:30 -0500676 *data_len = resptr->count + 1; // additional one byte for count
Marri Devender Raocac383b2017-07-03 13:24:27 -0500677 }
678 catch (const InternalFailure& e)
679 {
680 rc = IPMI_CC_UNSPECIFIED_ERROR;
681 *data_len = 0;
682 log<level::ERR>(e.what());
Marri Devender Raocac383b2017-07-03 13:24:27 -0500683 }
Marri Devender Raofa7b4e22017-07-03 00:52:20 -0500684 return rc;
685}
686
Dhruvaraj Subhashchandrane66c3b02018-02-07 01:21:56 -0600687ipmi_ret_t ipmi_get_repository_info(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
688 ipmi_request_t request, ipmi_response_t response,
689 ipmi_data_len_t data_len, ipmi_context_t context)
690{
691 constexpr auto sdrVersion = 0x51;
692 auto responseData =
693 reinterpret_cast<GetRepositoryInfoResponse*>(response);
694
695 memset(responseData, 0 , sizeof(GetRepositoryInfoResponse));
696
697 responseData->sdrVersion = sdrVersion;
698
699 uint16_t records = frus.size() + sensors.size();
700 responseData->recordCountMs = records >> 8;
701 responseData->recordCountLs = records;
702
703 responseData->freeSpace[0] = 0xFF;
704 responseData->freeSpace[1] = 0xFF;
705
706 *data_len = sizeof(GetRepositoryInfoResponse);
707
708 return IPMI_CC_OK;
709}
Chris Austenb4f5b922015-10-13 12:44:43 -0500710
Chris Austenb4f5b922015-10-13 12:44:43 -0500711void register_netfn_storage_functions()
712{
Tom05732372016-09-06 17:21:23 +0530713 // <Wildcard Command>
Tom05732372016-09-06 17:21:23 +0530714 ipmi_register_callback(NETFUN_STORAGE, IPMI_CMD_WILDCARD, NULL, ipmi_storage_wildcard,
715 PRIVILEGE_USER);
Chris Austenb4f5b922015-10-13 12:44:43 -0500716
Tom Joseph6f7deaa2017-06-30 19:03:54 +0530717 // <Get SEL Info>
Tom Joseph6f7deaa2017-06-30 19:03:54 +0530718 ipmi_register_callback(NETFUN_STORAGE, IPMI_CMD_GET_SEL_INFO, NULL, getSELInfo,
719 PRIVILEGE_USER);
720
Tom05732372016-09-06 17:21:23 +0530721 // <Get SEL Time>
Tom05732372016-09-06 17:21:23 +0530722 ipmi_register_callback(NETFUN_STORAGE, IPMI_CMD_GET_SEL_TIME, NULL, ipmi_storage_get_sel_time,
723 PRIVILEGE_USER);
Adriana Kobylak8e30f2a2015-10-20 10:23:51 -0500724
Tom05732372016-09-06 17:21:23 +0530725 // <Set SEL Time>
Tom05732372016-09-06 17:21:23 +0530726 ipmi_register_callback(NETFUN_STORAGE, IPMI_CMD_SET_SEL_TIME, NULL, ipmi_storage_set_sel_time,
727 PRIVILEGE_OPERATOR);
Chris Austenb4f5b922015-10-13 12:44:43 -0500728
Tom05732372016-09-06 17:21:23 +0530729 // <Reserve SEL>
Tom05732372016-09-06 17:21:23 +0530730 ipmi_register_callback(NETFUN_STORAGE, IPMI_CMD_RESERVE_SEL, NULL, ipmi_storage_reserve_sel,
731 PRIVILEGE_USER);
Chris Austenb4f5b922015-10-13 12:44:43 -0500732
Tom Josepha4953392017-06-30 19:09:47 +0530733 // <Get SEL Entry>
Tom Josepha4953392017-06-30 19:09:47 +0530734 ipmi_register_callback(NETFUN_STORAGE, IPMI_CMD_GET_SEL_ENTRY, NULL, getSELEntry,
735 PRIVILEGE_USER);
736
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530737 // <Delete SEL Entry>
Tom Joseph8f4a2aa2017-06-30 19:12:49 +0530738 ipmi_register_callback(NETFUN_STORAGE, IPMI_CMD_DELETE_SEL, NULL, deleteSELEntry,
739 PRIVILEGE_OPERATOR);
740
Tom05732372016-09-06 17:21:23 +0530741 // <Add SEL Entry>
Tom05732372016-09-06 17:21:23 +0530742 ipmi_register_callback(NETFUN_STORAGE, IPMI_CMD_ADD_SEL, NULL, ipmi_storage_add_sel,
743 PRIVILEGE_OPERATOR);
Tom Joseph2f05bb52017-06-30 19:14:49 +0530744 // <Clear SEL>
Tom Joseph2f05bb52017-06-30 19:14:49 +0530745 ipmi_register_callback(NETFUN_STORAGE, IPMI_CMD_CLEAR_SEL, NULL, clearSEL,
746 PRIVILEGE_OPERATOR);
Marri Devender Raofa7b4e22017-07-03 00:52:20 -0500747 // <Get FRU Inventory Area Info>
Marri Devender Raofa7b4e22017-07-03 00:52:20 -0500748 ipmi_register_callback(NETFUN_STORAGE, IPMI_CMD_GET_FRU_INV_AREA_INFO, NULL,
749 ipmi_storage_get_fru_inv_area_info, PRIVILEGE_OPERATOR);
750
751 // <Add READ FRU Data
Marri Devender Raofa7b4e22017-07-03 00:52:20 -0500752 ipmi_register_callback(NETFUN_STORAGE, IPMI_CMD_READ_FRU_DATA, NULL,
753 ipmi_storage_read_fru_data, PRIVILEGE_OPERATOR);
Marri Devender Raocac383b2017-07-03 13:24:27 -0500754
Dhruvaraj Subhashchandrane66c3b02018-02-07 01:21:56 -0600755 // <Get Repository Info>
756 ipmi_register_callback(NETFUN_STORAGE, IPMI_CMD_GET_REPOSITORY_INFO,
757 nullptr, ipmi_get_repository_info,
758 PRIVILEGE_USER);
759
Tom Joseph5ca50952018-02-22 00:33:38 +0530760 // <Reserve SDR Repository>
761 ipmi_register_callback(NETFUN_STORAGE, IPMI_CMD_RESERVE_SDR,
762 nullptr, ipmi_sen_reserve_sdr,
763 PRIVILEGE_USER);
764
765 // <Get SDR>
766 ipmi_register_callback(NETFUN_STORAGE, IPMI_CMD_GET_SDR,
767 nullptr, ipmi_sen_get_sdr,
768 PRIVILEGE_USER);
769
Marri Devender Rao908f7502017-07-10 01:49:54 -0500770 ipmi::fru::registerCallbackHandler();
Chris Austenb4f5b922015-10-13 12:44:43 -0500771 return;
772}
773