blob: 96e2d2b67a5013f0043703eba7e0e4a62d2817cc [file] [log] [blame]
Jason M. Bills3f7c5e42018-10-03 14:00:41 -07001/*
Jason M. Bills1a2fbdd2019-05-10 09:05:37 -07002// Copyright (c) 2017-2019 Intel Corporation
Jason M. Bills3f7c5e42018-10-03 14:00:41 -07003//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8// http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15*/
16
Patrick Ventureca99ef52019-10-20 14:00:50 -070017#include "storagecommands.hpp"
18
19#include "commandutils.hpp"
20#include "ipmi_to_redfish_hooks.hpp"
21#include "sdrutils.hpp"
Patrick Venturec2a07d42020-05-30 16:35:03 -070022#include "types.hpp"
Patrick Ventureca99ef52019-10-20 14:00:50 -070023
Jason M. Bills1d4d54d2019-04-23 11:26:11 -070024#include <boost/algorithm/string.hpp>
Jason M. Bills3f7c5e42018-10-03 14:00:41 -070025#include <boost/container/flat_map.hpp>
James Feist2a265d52019-04-08 11:16:27 -070026#include <ipmid/api.hpp>
James Feist25690252019-12-23 12:25:49 -080027#include <ipmid/message.hpp>
Jason M. Billsc04e2e72018-11-28 15:15:56 -080028#include <phosphor-ipmi-host/selutility.hpp>
Jason M. Bills3f7c5e42018-10-03 14:00:41 -070029#include <phosphor-logging/log.hpp>
30#include <sdbusplus/message/types.hpp>
31#include <sdbusplus/timer.hpp>
James Feistfcd2d3a2020-05-28 10:38:15 -070032
33#include <filesystem>
Archana Kakanif23fd542021-09-16 05:05:10 +000034#include <fstream>
James Feistfcd2d3a2020-05-28 10:38:15 -070035#include <iostream>
Jason M. Billsc04e2e72018-11-28 15:15:56 -080036#include <stdexcept>
Archana Kakanif23fd542021-09-16 05:05:10 +000037#include <unordered_set>
Jason M. Bills3f7c5e42018-10-03 14:00:41 -070038
Patrick Venture9ce789f2019-10-17 09:09:39 -070039static constexpr bool DEBUG = false;
40
Jason M. Bills1d4d54d2019-04-23 11:26:11 -070041namespace intel_oem::ipmi::sel
42{
43static const std::filesystem::path selLogDir = "/var/log";
44static const std::string selLogFilename = "ipmi_sel";
45
46static int getFileTimestamp(const std::filesystem::path& file)
47{
48 struct stat st;
49
50 if (stat(file.c_str(), &st) >= 0)
51 {
52 return st.st_mtime;
53 }
54 return ::ipmi::sel::invalidTimeStamp;
55}
56
57namespace erase_time
Jason M. Bills7944c302019-03-20 15:24:05 -070058{
59static constexpr const char* selEraseTimestamp = "/var/lib/ipmi/sel_erase_time";
60
61void save()
62{
63 // open the file, creating it if necessary
64 int fd = open(selEraseTimestamp, O_WRONLY | O_CREAT | O_CLOEXEC, 0644);
65 if (fd < 0)
66 {
67 std::cerr << "Failed to open file\n";
68 return;
69 }
70
71 // update the file timestamp to the current time
72 if (futimens(fd, NULL) < 0)
73 {
74 std::cerr << "Failed to update timestamp: "
75 << std::string(strerror(errno));
76 }
77 close(fd);
78}
79
80int get()
81{
Jason M. Bills1d4d54d2019-04-23 11:26:11 -070082 return getFileTimestamp(selEraseTimestamp);
Jason M. Bills7944c302019-03-20 15:24:05 -070083}
Jason M. Bills1d4d54d2019-04-23 11:26:11 -070084} // namespace erase_time
85} // namespace intel_oem::ipmi::sel
Jason M. Bills7944c302019-03-20 15:24:05 -070086
Jason M. Bills3f7c5e42018-10-03 14:00:41 -070087namespace ipmi
88{
89
90namespace storage
91{
92
Jason M. Billse2d1aee2018-10-03 15:57:18 -070093constexpr static const size_t maxMessageSize = 64;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -070094constexpr static const size_t maxFruSdrNameSize = 16;
James Feiste4f710d2020-05-20 15:50:30 -070095using ObjectType = boost::container::flat_map<
96 std::string, boost::container::flat_map<std::string, DbusVariant>>;
97using ManagedObjectType =
98 boost::container::flat_map<sdbusplus::message::object_path, ObjectType>;
99using ManagedEntry = std::pair<sdbusplus::message::object_path, ObjectType>;
Archana Kakanif23fd542021-09-16 05:05:10 +0000100using GetObjectType =
101 std::vector<std::pair<std::string, std::vector<std::string>>>;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700102
James Feist3bcba452018-12-20 12:31:03 -0800103constexpr static const char* fruDeviceServiceName =
104 "xyz.openbmc_project.FruDevice";
James Feist25690252019-12-23 12:25:49 -0800105constexpr static const size_t writeTimeoutSeconds = 10;
Anoop S358e7df2020-05-05 16:43:34 +0000106constexpr static const char* chassisTypeRackMount = "23";
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700107
Jason M. Bills4ed6f2c2019-04-02 12:21:25 -0700108// event direction is bit[7] of eventType where 1b = Deassertion event
109constexpr static const uint8_t deassertionEvent = 0x80;
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800110
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700111static std::vector<uint8_t> fruCache;
Johnathan Mantey07574002022-12-13 14:52:54 -0800112static uint16_t cacheBus = 0xFFFF;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700113static uint8_t cacheAddr = 0XFF;
James Feiste4f710d2020-05-20 15:50:30 -0700114static uint8_t lastDevId = 0xFF;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700115
Johnathan Mantey07574002022-12-13 14:52:54 -0800116static uint16_t writeBus = 0xFFFF;
James Feist25690252019-12-23 12:25:49 -0800117static uint8_t writeAddr = 0XFF;
118
119std::unique_ptr<phosphor::Timer> writeTimer = nullptr;
Patrick Williamsf944d2e2022-07-22 19:26:52 -0500120static std::vector<sdbusplus::bus::match_t> fruMatches;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700121
James Feist25690252019-12-23 12:25:49 -0800122ManagedObjectType frus;
123
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700124// we unfortunately have to build a map of hashes in case there is a
125// collision to verify our dev-id
Johnathan Mantey07574002022-12-13 14:52:54 -0800126boost::container::flat_map<uint8_t, std::pair<uint16_t, uint8_t>> deviceHashes;
Archana Kakanif23fd542021-09-16 05:05:10 +0000127// Map devId to Object Path
128boost::container::flat_map<uint8_t, std::string> devicePath;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700129
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700130void registerStorageFunctions() __attribute__((constructor));
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700131
132bool writeFru()
133{
Johnathan Mantey07574002022-12-13 14:52:54 -0800134 if (writeBus == 0xFFFF && writeAddr == 0xFF)
James Feist25690252019-12-23 12:25:49 -0800135 {
136 return true;
137 }
Vernon Mauery15419dd2019-05-24 09:40:30 -0700138 std::shared_ptr<sdbusplus::asio::connection> dbus = getSdBus();
Patrick Williamsf944d2e2022-07-22 19:26:52 -0500139 sdbusplus::message_t writeFru = dbus->new_method_call(
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700140 fruDeviceServiceName, "/xyz/openbmc_project/FruDevice",
141 "xyz.openbmc_project.FruDeviceManager", "WriteFru");
James Feist25690252019-12-23 12:25:49 -0800142 writeFru.append(writeBus, writeAddr, fruCache);
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700143 try
144 {
Patrick Williamsf944d2e2022-07-22 19:26:52 -0500145 sdbusplus::message_t writeFruResp = dbus->call(writeFru);
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700146 }
Patrick Williamsbd51e6a2021-10-06 13:09:44 -0500147 catch (const sdbusplus::exception_t&)
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700148 {
149 // todo: log sel?
150 phosphor::logging::log<phosphor::logging::level::ERR>(
151 "error writing fru");
152 return false;
153 }
Johnathan Mantey07574002022-12-13 14:52:54 -0800154 writeBus = 0xFFFF;
James Feist25690252019-12-23 12:25:49 -0800155 writeAddr = 0xFF;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700156 return true;
157}
158
James Feist25690252019-12-23 12:25:49 -0800159void createTimers()
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700160{
James Feist25690252019-12-23 12:25:49 -0800161 writeTimer = std::make_unique<phosphor::Timer>(writeFru);
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700162}
163
James Feiste4f710d2020-05-20 15:50:30 -0700164void recalculateHashes()
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700165{
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700166
167 deviceHashes.clear();
Archana Kakanif23fd542021-09-16 05:05:10 +0000168 devicePath.clear();
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700169 // hash the object paths to create unique device id's. increment on
170 // collision
171 std::hash<std::string> hasher;
172 for (const auto& fru : frus)
173 {
174 auto fruIface = fru.second.find("xyz.openbmc_project.FruDevice");
175 if (fruIface == fru.second.end())
176 {
177 continue;
178 }
179
180 auto busFind = fruIface->second.find("BUS");
181 auto addrFind = fruIface->second.find("ADDRESS");
182 if (busFind == fruIface->second.end() ||
183 addrFind == fruIface->second.end())
184 {
185 phosphor::logging::log<phosphor::logging::level::INFO>(
186 "fru device missing Bus or Address",
187 phosphor::logging::entry("FRU=%s", fru.first.str.c_str()));
188 continue;
189 }
190
Johnathan Mantey07574002022-12-13 14:52:54 -0800191 uint16_t fruBus = std::get<uint32_t>(busFind->second);
Vernon Mauery8166c8d2019-05-23 11:22:30 -0700192 uint8_t fruAddr = std::get<uint32_t>(addrFind->second);
Anoop S358e7df2020-05-05 16:43:34 +0000193 auto chassisFind = fruIface->second.find("CHASSIS_TYPE");
194 std::string chassisType;
195 if (chassisFind != fruIface->second.end())
196 {
197 chassisType = std::get<std::string>(chassisFind->second);
198 }
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700199
200 uint8_t fruHash = 0;
Anoop S358e7df2020-05-05 16:43:34 +0000201 if (chassisType.compare(chassisTypeRackMount) != 0)
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700202 {
203 fruHash = hasher(fru.first.str);
204 // can't be 0xFF based on spec, and 0 is reserved for baseboard
205 if (fruHash == 0 || fruHash == 0xFF)
206 {
207 fruHash = 1;
208 }
209 }
Johnathan Mantey07574002022-12-13 14:52:54 -0800210 std::pair<uint16_t, uint8_t> newDev(fruBus, fruAddr);
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700211
212 bool emplacePassed = false;
213 while (!emplacePassed)
214 {
215 auto resp = deviceHashes.emplace(fruHash, newDev);
Archana Kakanif23fd542021-09-16 05:05:10 +0000216
217 devicePath.emplace(fruHash, fru.first);
218
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700219 emplacePassed = resp.second;
220 if (!emplacePassed)
221 {
222 fruHash++;
223 // can't be 0xFF based on spec, and 0 is reserved for
224 // baseboard
225 if (fruHash == 0XFF)
226 {
227 fruHash = 0x1;
228 }
229 }
230 }
231 }
James Feiste4f710d2020-05-20 15:50:30 -0700232}
233
234void replaceCacheFru(const std::shared_ptr<sdbusplus::asio::connection>& bus,
Archana Kakanif23fd542021-09-16 05:05:10 +0000235 boost::asio::yield_context& yield)
James Feiste4f710d2020-05-20 15:50:30 -0700236{
237 boost::system::error_code ec;
Archana Kakanif23fd542021-09-16 05:05:10 +0000238 // ObjectPaths and Services which implements "xyz.openbmc_project.FruDevice"
239 // interface
240 GetSubTreeType fruServices = bus->yield_method_call<GetSubTreeType>(
241 yield, ec, "xyz.openbmc_project.ObjectMapper",
242 "/xyz/openbmc_project/object_mapper",
243 "xyz.openbmc_project.ObjectMapper", "GetSubTree", "/", 0,
244 std::array<const char*, 1>{"xyz.openbmc_project.FruDevice"});
James Feiste4f710d2020-05-20 15:50:30 -0700245
James Feiste4f710d2020-05-20 15:50:30 -0700246 if (ec)
247 {
248 phosphor::logging::log<phosphor::logging::level::ERR>(
Archana Kakanif23fd542021-09-16 05:05:10 +0000249 "GetSubTree failed for FruDevice Interface ",
James Feiste4f710d2020-05-20 15:50:30 -0700250 phosphor::logging::entry("ERROR=%s", ec.message().c_str()));
251
252 return;
253 }
Archana Kakanif23fd542021-09-16 05:05:10 +0000254 // Get List of services which have implemented FruDevice interface
255 std::unordered_set<std::string> services;
256 for (const auto& [path, serviceMap] : fruServices)
257 {
258 for (const auto& [service, interfaces] : serviceMap)
259 {
260 services.insert(service);
261 }
262 }
263
264 // GetAll the objects under services which implement FruDevice interface
265 for (const std::string& service : services)
266 {
267 ec = boost::system::errc::make_error_code(boost::system::errc::success);
268 ManagedObjectType obj = bus->yield_method_call<ManagedObjectType>(
269 yield, ec, service, "/", "org.freedesktop.DBus.ObjectManager",
270 "GetManagedObjects");
271 if (ec)
272 {
273 phosphor::logging::log<phosphor::logging::level::ERR>(
274 "GetMangagedObjects failed",
275 phosphor::logging::entry("ERROR=%s", ec.message().c_str()));
276 continue;
277 }
278 // Save the object path which has FruDevice interface
279 for (const auto& [path, serviceMap] : fruServices)
280 {
281 for (const auto& serv : serviceMap)
282 {
283 if (serv.first == service)
284 {
285 auto fru = obj.find(path);
286 if (fru == obj.end())
287 {
288 continue;
289 }
290 frus.emplace(fru->first, fru->second);
291 }
292 }
293 }
294 }
295
James Feiste4f710d2020-05-20 15:50:30 -0700296 recalculateHashes();
297}
298
299ipmi::Cc getFru(ipmi::Context::ptr ctx, uint8_t devId)
300{
301 if (lastDevId == devId && devId != 0xFF)
302 {
303 return ipmi::ccSuccess;
304 }
305
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700306 auto deviceFind = deviceHashes.find(devId);
Archana Kakanif23fd542021-09-16 05:05:10 +0000307 auto devPath = devicePath.find(devId);
308 if (deviceFind == deviceHashes.end() || devPath == devicePath.end())
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700309 {
310 return IPMI_CC_SENSOR_INVALID;
311 }
312
313 fruCache.clear();
James Feist25690252019-12-23 12:25:49 -0800314
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700315 cacheBus = deviceFind->second.first;
316 cacheAddr = deviceFind->second.second;
James Feist25690252019-12-23 12:25:49 -0800317
James Feiste4f710d2020-05-20 15:50:30 -0700318 boost::system::error_code ec;
Archana Kakanif23fd542021-09-16 05:05:10 +0000319 GetObjectType fruService = ctx->bus->yield_method_call<GetObjectType>(
320 ctx->yield, ec, "xyz.openbmc_project.ObjectMapper",
321 "/xyz/openbmc_project/object_mapper",
322 "xyz.openbmc_project.ObjectMapper", "GetObject", devPath->second,
323 std::array<const char*, 1>{"xyz.openbmc_project.FruDevice"});
James Feiste4f710d2020-05-20 15:50:30 -0700324
James Feist25690252019-12-23 12:25:49 -0800325 if (ec)
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700326 {
James Feist25690252019-12-23 12:25:49 -0800327 phosphor::logging::log<phosphor::logging::level::ERR>(
Archana Kakanif23fd542021-09-16 05:05:10 +0000328 "Couldn't get raw fru because of service",
329 phosphor::logging::entry("ERROR=%s", ec.message().c_str()));
330 return ipmi::ccResponseError;
331 }
332
333 bool foundFru = false;
334 for (auto& service : fruService)
335 {
336 fruCache = ctx->bus->yield_method_call<std::vector<uint8_t>>(
337 ctx->yield, ec, service.first, "/xyz/openbmc_project/FruDevice",
338 "xyz.openbmc_project.FruDeviceManager", "GetRawFru", cacheBus,
339 cacheAddr);
340
341 if (!ec)
342 {
343 foundFru = true;
344 break;
345 }
346 }
347
348 if (!foundFru)
349 {
350 phosphor::logging::log<phosphor::logging::level::ERR>(
James Feist25690252019-12-23 12:25:49 -0800351 "Couldn't get raw fru",
352 phosphor::logging::entry("ERROR=%s", ec.message().c_str()));
Johnathan Mantey07574002022-12-13 14:52:54 -0800353 cacheBus = 0xFFFF;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700354 cacheAddr = 0xFF;
James Feist25690252019-12-23 12:25:49 -0800355 return ipmi::ccResponseError;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700356 }
357
358 lastDevId = devId;
James Feist25690252019-12-23 12:25:49 -0800359 return ipmi::ccSuccess;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700360}
361
James Feiste4f710d2020-05-20 15:50:30 -0700362void writeFruIfRunning()
363{
364 if (!writeTimer->isRunning())
365 {
366 return;
367 }
368 writeTimer->stop();
369 writeFru();
370}
371
372void startMatch(void)
373{
374 if (fruMatches.size())
375 {
376 return;
377 }
378
379 fruMatches.reserve(2);
380
381 auto bus = getSdBus();
382 fruMatches.emplace_back(*bus,
383 "type='signal',arg0path='/xyz/openbmc_project/"
384 "FruDevice/',member='InterfacesAdded'",
Patrick Williamsf944d2e2022-07-22 19:26:52 -0500385 [](sdbusplus::message_t& message) {
James Feiste4f710d2020-05-20 15:50:30 -0700386 sdbusplus::message::object_path path;
387 ObjectType object;
388 try
389 {
390 message.read(path, object);
391 }
Patrick Williamsbd51e6a2021-10-06 13:09:44 -0500392 catch (const sdbusplus::exception_t&)
James Feiste4f710d2020-05-20 15:50:30 -0700393 {
394 return;
395 }
396 auto findType = object.find(
397 "xyz.openbmc_project.FruDevice");
398 if (findType == object.end())
399 {
400 return;
401 }
402 writeFruIfRunning();
403 frus[path] = object;
404 recalculateHashes();
405 lastDevId = 0xFF;
406 });
407
408 fruMatches.emplace_back(*bus,
409 "type='signal',arg0path='/xyz/openbmc_project/"
410 "FruDevice/',member='InterfacesRemoved'",
Patrick Williamsf944d2e2022-07-22 19:26:52 -0500411 [](sdbusplus::message_t& message) {
James Feiste4f710d2020-05-20 15:50:30 -0700412 sdbusplus::message::object_path path;
413 std::set<std::string> interfaces;
414 try
415 {
416 message.read(path, interfaces);
417 }
Patrick Williamsbd51e6a2021-10-06 13:09:44 -0500418 catch (const sdbusplus::exception_t&)
James Feiste4f710d2020-05-20 15:50:30 -0700419 {
420 return;
421 }
422 auto findType = interfaces.find(
423 "xyz.openbmc_project.FruDevice");
424 if (findType == interfaces.end())
425 {
426 return;
427 }
428 writeFruIfRunning();
429 frus.erase(path);
430 recalculateHashes();
431 lastDevId = 0xFF;
432 });
433
434 // call once to populate
435 boost::asio::spawn(*getIoContext(), [](boost::asio::yield_context yield) {
436 replaceCacheFru(getSdBus(), yield);
437 });
438}
439
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000440/** @brief implements the read FRU data command
441 * @param fruDeviceId - FRU Device ID
442 * @param fruInventoryOffset - FRU Inventory Offset to write
443 * @param countToRead - Count to read
444 *
445 * @returns ipmi completion code plus response data
446 * - countWritten - Count written
447 */
448ipmi::RspType<uint8_t, // Count
449 std::vector<uint8_t> // Requested data
450 >
James Feist25690252019-12-23 12:25:49 -0800451 ipmiStorageReadFruData(ipmi::Context::ptr ctx, uint8_t fruDeviceId,
452 uint16_t fruInventoryOffset, uint8_t countToRead)
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700453{
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000454 if (fruDeviceId == 0xFF)
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700455 {
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000456 return ipmi::responseInvalidFieldRequest();
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700457 }
458
James Feiste4f710d2020-05-20 15:50:30 -0700459 ipmi::Cc status = getFru(ctx, fruDeviceId);
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700460
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000461 if (status != ipmi::ccSuccess)
462 {
463 return ipmi::response(status);
464 }
465
466 size_t fromFruByteLen = 0;
467 if (countToRead + fruInventoryOffset < fruCache.size())
468 {
469 fromFruByteLen = countToRead;
470 }
471 else if (fruCache.size() > fruInventoryOffset)
472 {
473 fromFruByteLen = fruCache.size() - fruInventoryOffset;
474 }
475 else
476 {
srikanta mondal92108382020-02-27 18:53:20 +0000477 return ipmi::responseReqDataLenExceeded();
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000478 }
479
480 std::vector<uint8_t> requestedData;
481
482 requestedData.insert(
483 requestedData.begin(), fruCache.begin() + fruInventoryOffset,
484 fruCache.begin() + fruInventoryOffset + fromFruByteLen);
485
Patrick Venture70b17f92019-10-28 20:01:53 -0700486 return ipmi::responseSuccess(static_cast<uint8_t>(requestedData.size()),
487 requestedData);
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700488}
489
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000490/** @brief implements the write FRU data command
491 * @param fruDeviceId - FRU Device ID
492 * @param fruInventoryOffset - FRU Inventory Offset to write
493 * @param dataToWrite - Data to write
494 *
495 * @returns ipmi completion code plus response data
496 * - countWritten - Count written
497 */
498ipmi::RspType<uint8_t>
James Feist25690252019-12-23 12:25:49 -0800499 ipmiStorageWriteFruData(ipmi::Context::ptr ctx, uint8_t fruDeviceId,
500 uint16_t fruInventoryOffset,
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000501 std::vector<uint8_t>& dataToWrite)
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700502{
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000503 if (fruDeviceId == 0xFF)
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700504 {
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000505 return ipmi::responseInvalidFieldRequest();
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700506 }
507
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000508 size_t writeLen = dataToWrite.size();
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700509
James Feiste4f710d2020-05-20 15:50:30 -0700510 ipmi::Cc status = getFru(ctx, fruDeviceId);
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000511 if (status != ipmi::ccSuccess)
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700512 {
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000513 return ipmi::response(status);
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700514 }
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000515 int lastWriteAddr = fruInventoryOffset + writeLen;
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700516 if (fruCache.size() < lastWriteAddr)
517 {
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000518 fruCache.resize(fruInventoryOffset + writeLen);
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700519 }
520
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000521 std::copy(dataToWrite.begin(), dataToWrite.begin() + writeLen,
522 fruCache.begin() + fruInventoryOffset);
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700523
524 bool atEnd = false;
525
526 if (fruCache.size() >= sizeof(FRUHeader))
527 {
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700528 FRUHeader* header = reinterpret_cast<FRUHeader*>(fruCache.data());
529
Peter Lundgrenc59391f2019-11-19 14:26:15 -0800530 int areaLength = 0;
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700531 int lastRecordStart = std::max(
Peter Lundgrenc59391f2019-11-19 14:26:15 -0800532 {header->internalOffset, header->chassisOffset, header->boardOffset,
533 header->productOffset, header->multiRecordOffset});
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700534 lastRecordStart *= 8; // header starts in are multiples of 8 bytes
535
Peter Lundgrenc59391f2019-11-19 14:26:15 -0800536 if (header->multiRecordOffset)
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700537 {
Peter Lundgrenc59391f2019-11-19 14:26:15 -0800538 // This FRU has a MultiRecord Area
539 uint8_t endOfList = 0;
540 // Walk the MultiRecord headers until the last record
541 while (!endOfList)
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700542 {
Peter Lundgrenc59391f2019-11-19 14:26:15 -0800543 // The MSB in the second byte of the MultiRecord header signals
544 // "End of list"
545 endOfList = fruCache[lastRecordStart + 1] & 0x80;
546 // Third byte in the MultiRecord header is the length
547 areaLength = fruCache[lastRecordStart + 2];
548 // This length is in bytes (not 8 bytes like other headers)
549 areaLength += 5; // The length omits the 5 byte header
550 if (!endOfList)
551 {
552 // Next MultiRecord header
553 lastRecordStart += areaLength;
554 }
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700555 }
556 }
Peter Lundgrenc59391f2019-11-19 14:26:15 -0800557 else
558 {
559 // This FRU does not have a MultiRecord Area
560 // Get the length of the area in multiples of 8 bytes
561 if (lastWriteAddr > (lastRecordStart + 1))
562 {
563 // second byte in record area is the length
564 areaLength = fruCache[lastRecordStart + 1];
565 areaLength *= 8; // it is in multiples of 8 bytes
566 }
567 }
568 if (lastWriteAddr >= (areaLength + lastRecordStart))
569 {
570 atEnd = true;
571 }
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700572 }
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000573 uint8_t countWritten = 0;
James Feist25690252019-12-23 12:25:49 -0800574
575 writeBus = cacheBus;
576 writeAddr = cacheAddr;
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700577 if (atEnd)
578 {
579 // cancel timer, we're at the end so might as well send it
James Feist25690252019-12-23 12:25:49 -0800580 writeTimer->stop();
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700581 if (!writeFru())
582 {
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000583 return ipmi::responseInvalidFieldRequest();
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700584 }
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000585 countWritten = std::min(fruCache.size(), static_cast<size_t>(0xFF));
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700586 }
587 else
588 {
James Feist25690252019-12-23 12:25:49 -0800589 // start a timer, if no further data is sent to check to see if it is
590 // valid
591 writeTimer->start(std::chrono::duration_cast<std::chrono::microseconds>(
592 std::chrono::seconds(writeTimeoutSeconds)));
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000593 countWritten = 0;
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700594 }
595
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000596 return ipmi::responseSuccess(countWritten);
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700597}
598
jayaprakash Mutyalad33acd62019-05-17 19:37:25 +0000599/** @brief implements the get FRU inventory area info command
600 * @param fruDeviceId - FRU Device ID
601 *
602 * @returns IPMI completion code plus response data
603 * - inventorySize - Number of possible allocation units
604 * - accessType - Allocation unit size in bytes.
605 */
606ipmi::RspType<uint16_t, // inventorySize
607 uint8_t> // accessType
James Feist25690252019-12-23 12:25:49 -0800608 ipmiStorageGetFruInvAreaInfo(ipmi::Context::ptr ctx, uint8_t fruDeviceId)
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700609{
jayaprakash Mutyalad33acd62019-05-17 19:37:25 +0000610 if (fruDeviceId == 0xFF)
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700611 {
jayaprakash Mutyalad33acd62019-05-17 19:37:25 +0000612 return ipmi::responseInvalidFieldRequest();
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700613 }
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700614
Jayaprakash Mutyala1e2ab062020-08-03 16:57:00 +0000615 ipmi::Cc ret = getFru(ctx, fruDeviceId);
616 if (ret != ipmi::ccSuccess)
617 {
618 return ipmi::response(ret);
619 }
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700620
jayaprakash Mutyalad33acd62019-05-17 19:37:25 +0000621 constexpr uint8_t accessType =
622 static_cast<uint8_t>(GetFRUAreaAccessType::byte);
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700623
jayaprakash Mutyalad33acd62019-05-17 19:37:25 +0000624 return ipmi::responseSuccess(fruCache.size(), accessType);
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700625}
626
James Feist25690252019-12-23 12:25:49 -0800627ipmi_ret_t getFruSdrCount(ipmi::Context::ptr ctx, size_t& count)
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700628{
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700629 count = deviceHashes.size();
630 return IPMI_CC_OK;
631}
632
James Feist25690252019-12-23 12:25:49 -0800633ipmi_ret_t getFruSdrs(ipmi::Context::ptr ctx, size_t index,
634 get_sdr::SensorDataFruRecord& resp)
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700635{
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700636 if (deviceHashes.size() < index)
637 {
638 return IPMI_CC_INVALID_FIELD_REQUEST;
639 }
640 auto device = deviceHashes.begin() + index;
Johnathan Mantey07574002022-12-13 14:52:54 -0800641 uint16_t& bus = device->second.first;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700642 uint8_t& address = device->second.second;
643
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700644 boost::container::flat_map<std::string, DbusVariant>* fruData = nullptr;
645 auto fru =
646 std::find_if(frus.begin(), frus.end(),
647 [bus, address, &fruData](ManagedEntry& entry) {
648 auto findFruDevice =
649 entry.second.find("xyz.openbmc_project.FruDevice");
650 if (findFruDevice == entry.second.end())
651 {
652 return false;
653 }
654 fruData = &(findFruDevice->second);
655 auto findBus = findFruDevice->second.find("BUS");
656 auto findAddress =
657 findFruDevice->second.find("ADDRESS");
658 if (findBus == findFruDevice->second.end() ||
659 findAddress == findFruDevice->second.end())
660 {
661 return false;
662 }
Vernon Mauery8166c8d2019-05-23 11:22:30 -0700663 if (std::get<uint32_t>(findBus->second) != bus)
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700664 {
665 return false;
666 }
Vernon Mauery8166c8d2019-05-23 11:22:30 -0700667 if (std::get<uint32_t>(findAddress->second) != address)
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700668 {
669 return false;
670 }
671 return true;
672 });
673 if (fru == frus.end())
674 {
675 return IPMI_CC_RESPONSE_ERROR;
676 }
Patrick Venture9ce789f2019-10-17 09:09:39 -0700677
James Feist25690252019-12-23 12:25:49 -0800678#ifdef USING_ENTITY_MANAGER_DECORATORS
679
Patrick Venture9ce789f2019-10-17 09:09:39 -0700680 boost::container::flat_map<std::string, DbusVariant>* entityData = nullptr;
Patrick Venture9ce789f2019-10-17 09:09:39 -0700681
James Feist25690252019-12-23 12:25:49 -0800682 // todo: this should really use caching, this is a very inefficient lookup
683 boost::system::error_code ec;
684 ManagedObjectType entities = ctx->bus->yield_method_call<ManagedObjectType>(
Nan Zhou9d2894d2022-09-20 22:22:00 +0000685 ctx->yield, ec, "xyz.openbmc_project.EntityManager",
686 "/xyz/openbmc_project/inventory", "org.freedesktop.DBus.ObjectManager",
687 "GetManagedObjects");
James Feist25690252019-12-23 12:25:49 -0800688
689 if (ec)
Patrick Venture9ce789f2019-10-17 09:09:39 -0700690 {
James Feist25690252019-12-23 12:25:49 -0800691 phosphor::logging::log<phosphor::logging::level::ERR>(
692 "GetMangagedObjects for getSensorMap failed",
693 phosphor::logging::entry("ERROR=%s", ec.message().c_str()));
Patrick Venture9ce789f2019-10-17 09:09:39 -0700694
James Feist25690252019-12-23 12:25:49 -0800695 return ipmi::ccResponseError;
696 }
Patrick Venture9ce789f2019-10-17 09:09:39 -0700697
James Feist25690252019-12-23 12:25:49 -0800698 auto entity = std::find_if(
699 entities.begin(), entities.end(),
700 [bus, address, &entityData](ManagedEntry& entry) {
701 auto findFruDevice = entry.second.find(
702 "xyz.openbmc_project.Inventory.Decorator.FruDevice");
703 if (findFruDevice == entry.second.end())
Patrick Venture9ce789f2019-10-17 09:09:39 -0700704 {
James Feist25690252019-12-23 12:25:49 -0800705 return false;
Patrick Venture9ce789f2019-10-17 09:09:39 -0700706 }
James Feist25690252019-12-23 12:25:49 -0800707
708 // Integer fields added via Entity-Manager json are uint64_ts by
709 // default.
710 auto findBus = findFruDevice->second.find("Bus");
711 auto findAddress = findFruDevice->second.find("Address");
712
713 if (findBus == findFruDevice->second.end() ||
714 findAddress == findFruDevice->second.end())
715 {
716 return false;
717 }
718 if ((std::get<uint64_t>(findBus->second) != bus) ||
719 (std::get<uint64_t>(findAddress->second) != address))
720 {
721 return false;
722 }
723
724 // At this point we found the device entry and should return
725 // true.
726 auto findIpmiDevice = entry.second.find(
727 "xyz.openbmc_project.Inventory.Decorator.Ipmi");
728 if (findIpmiDevice != entry.second.end())
729 {
730 entityData = &(findIpmiDevice->second);
731 }
732
733 return true;
734 });
735
736 if (entity == entities.end())
737 {
738 if constexpr (DEBUG)
739 {
740 std::fprintf(stderr, "Ipmi or FruDevice Decorator interface "
741 "not found for Fru\n");
Patrick Venture9ce789f2019-10-17 09:09:39 -0700742 }
743 }
James Feist25690252019-12-23 12:25:49 -0800744
745#endif
Patrick Venture9ce789f2019-10-17 09:09:39 -0700746
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700747 std::string name;
748 auto findProductName = fruData->find("BOARD_PRODUCT_NAME");
749 auto findBoardName = fruData->find("PRODUCT_PRODUCT_NAME");
750 if (findProductName != fruData->end())
751 {
Vernon Mauery8166c8d2019-05-23 11:22:30 -0700752 name = std::get<std::string>(findProductName->second);
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700753 }
754 else if (findBoardName != fruData->end())
755 {
Vernon Mauery8166c8d2019-05-23 11:22:30 -0700756 name = std::get<std::string>(findBoardName->second);
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700757 }
758 else
759 {
760 name = "UNKNOWN";
761 }
762 if (name.size() > maxFruSdrNameSize)
763 {
764 name = name.substr(0, maxFruSdrNameSize);
765 }
766 size_t sizeDiff = maxFruSdrNameSize - name.size();
767
768 resp.header.record_id_lsb = 0x0; // calling code is to implement these
769 resp.header.record_id_msb = 0x0;
770 resp.header.sdr_version = ipmiSdrVersion;
Patrick Venture73d01352019-10-11 18:32:59 -0700771 resp.header.record_type = get_sdr::SENSOR_DATA_FRU_RECORD;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700772 resp.header.record_length = sizeof(resp.body) + sizeof(resp.key) - sizeDiff;
773 resp.key.deviceAddress = 0x20;
774 resp.key.fruID = device->first;
775 resp.key.accessLun = 0x80; // logical / physical fru device
776 resp.key.channelNumber = 0x0;
777 resp.body.reserved = 0x0;
778 resp.body.deviceType = 0x10;
James Feist4f86d1f2019-04-03 10:30:26 -0700779 resp.body.deviceTypeModifier = 0x0;
Patrick Venture9ce789f2019-10-17 09:09:39 -0700780
781 uint8_t entityID = 0;
782 uint8_t entityInstance = 0x1;
783
James Feist25690252019-12-23 12:25:49 -0800784#ifdef USING_ENTITY_MANAGER_DECORATORS
Patrick Venture9ce789f2019-10-17 09:09:39 -0700785 if (entityData)
786 {
787 auto entityIdProperty = entityData->find("EntityId");
788 auto entityInstanceProperty = entityData->find("EntityInstance");
789
790 if (entityIdProperty != entityData->end())
791 {
792 entityID = static_cast<uint8_t>(
793 std::get<uint64_t>(entityIdProperty->second));
794 }
795 if (entityInstanceProperty != entityData->end())
796 {
797 entityInstance = static_cast<uint8_t>(
798 std::get<uint64_t>(entityInstanceProperty->second));
799 }
800 }
James Feist25690252019-12-23 12:25:49 -0800801#endif
Patrick Venture9ce789f2019-10-17 09:09:39 -0700802
803 resp.body.entityID = entityID;
804 resp.body.entityInstance = entityInstance;
805
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700806 resp.body.oem = 0x0;
807 resp.body.deviceIDLen = name.size();
808 name.copy(resp.body.deviceID, name.size());
809
810 return IPMI_CC_OK;
811}
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700812
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700813static bool getSELLogFiles(std::vector<std::filesystem::path>& selLogFiles)
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800814{
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700815 // Loop through the directory looking for ipmi_sel log files
816 for (const std::filesystem::directory_entry& dirEnt :
817 std::filesystem::directory_iterator(intel_oem::ipmi::sel::selLogDir))
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800818 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700819 std::string filename = dirEnt.path().filename();
820 if (boost::starts_with(filename, intel_oem::ipmi::sel::selLogFilename))
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800821 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700822 // If we find an ipmi_sel log file, save the path
823 selLogFiles.emplace_back(intel_oem::ipmi::sel::selLogDir /
824 filename);
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800825 }
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800826 }
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700827 // As the log files rotate, they are appended with a ".#" that is higher for
828 // the older logs. Since we don't expect more than 10 log files, we
829 // can just sort the list to get them in order from newest to oldest
830 std::sort(selLogFiles.begin(), selLogFiles.end());
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800831
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700832 return !selLogFiles.empty();
833}
834
835static int countSELEntries()
836{
837 // Get the list of ipmi_sel log files
838 std::vector<std::filesystem::path> selLogFiles;
839 if (!getSELLogFiles(selLogFiles))
840 {
841 return 0;
842 }
843 int numSELEntries = 0;
844 // Loop through each log file and count the number of logs
845 for (const std::filesystem::path& file : selLogFiles)
846 {
847 std::ifstream logStream(file);
848 if (!logStream.is_open())
849 {
850 continue;
851 }
852
853 std::string line;
854 while (std::getline(logStream, line))
855 {
856 numSELEntries++;
857 }
858 }
859 return numSELEntries;
860}
861
862static bool findSELEntry(const int recordID,
Patrick Ventureff7e15b2019-09-25 16:48:26 -0700863 const std::vector<std::filesystem::path>& selLogFiles,
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700864 std::string& entry)
865{
866 // Record ID is the first entry field following the timestamp. It is
867 // preceded by a space and followed by a comma
868 std::string search = " " + std::to_string(recordID) + ",";
869
870 // Loop through the ipmi_sel log entries
871 for (const std::filesystem::path& file : selLogFiles)
872 {
873 std::ifstream logStream(file);
874 if (!logStream.is_open())
875 {
876 continue;
877 }
878
879 while (std::getline(logStream, entry))
880 {
881 // Check if the record ID matches
882 if (entry.find(search) != std::string::npos)
883 {
884 return true;
885 }
886 }
887 }
888 return false;
889}
890
891static uint16_t
892 getNextRecordID(const uint16_t recordID,
Patrick Ventureff7e15b2019-09-25 16:48:26 -0700893 const std::vector<std::filesystem::path>& selLogFiles)
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700894{
895 uint16_t nextRecordID = recordID + 1;
896 std::string entry;
897 if (findSELEntry(nextRecordID, selLogFiles, entry))
898 {
899 return nextRecordID;
900 }
901 else
902 {
903 return ipmi::sel::lastEntry;
904 }
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800905}
906
Patrick Ventureff7e15b2019-09-25 16:48:26 -0700907static int fromHexStr(const std::string& hexStr, std::vector<uint8_t>& data)
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800908{
909 for (unsigned int i = 0; i < hexStr.size(); i += 2)
910 {
911 try
912 {
913 data.push_back(static_cast<uint8_t>(
914 std::stoul(hexStr.substr(i, 2), nullptr, 16)));
915 }
Patrick Williamsbd51e6a2021-10-06 13:09:44 -0500916 catch (const std::invalid_argument& e)
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800917 {
918 phosphor::logging::log<phosphor::logging::level::ERR>(e.what());
919 return -1;
920 }
Patrick Williamsbd51e6a2021-10-06 13:09:44 -0500921 catch (const std::out_of_range& e)
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800922 {
923 phosphor::logging::log<phosphor::logging::level::ERR>(e.what());
924 return -1;
925 }
926 }
927 return 0;
928}
929
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700930ipmi::RspType<uint8_t, // SEL version
931 uint16_t, // SEL entry count
932 uint16_t, // free space
933 uint32_t, // last add timestamp
934 uint32_t, // last erase timestamp
935 uint8_t> // operation support
936 ipmiStorageGetSELInfo()
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800937{
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700938 constexpr uint8_t selVersion = ipmi::sel::selVersion;
939 uint16_t entries = countSELEntries();
940 uint32_t addTimeStamp = intel_oem::ipmi::sel::getFileTimestamp(
941 intel_oem::ipmi::sel::selLogDir / intel_oem::ipmi::sel::selLogFilename);
942 uint32_t eraseTimeStamp = intel_oem::ipmi::sel::erase_time::get();
943 constexpr uint8_t operationSupport =
944 intel_oem::ipmi::sel::selOperationSupport;
945 constexpr uint16_t freeSpace =
946 0xffff; // Spec indicates that more than 64kB is free
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800947
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700948 return ipmi::responseSuccess(selVersion, entries, freeSpace, addTimeStamp,
949 eraseTimeStamp, operationSupport);
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800950}
951
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700952using systemEventType = std::tuple<
953 uint32_t, // Timestamp
954 uint16_t, // Generator ID
955 uint8_t, // EvM Rev
956 uint8_t, // Sensor Type
957 uint8_t, // Sensor Number
958 uint7_t, // Event Type
959 bool, // Event Direction
960 std::array<uint8_t, intel_oem::ipmi::sel::systemEventSize>>; // Event Data
961using oemTsEventType = std::tuple<
962 uint32_t, // Timestamp
963 std::array<uint8_t, intel_oem::ipmi::sel::oemTsEventSize>>; // Event Data
964using oemEventType =
965 std::array<uint8_t, intel_oem::ipmi::sel::oemEventSize>; // Event Data
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800966
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700967ipmi::RspType<uint16_t, // Next Record ID
968 uint16_t, // Record ID
969 uint8_t, // Record Type
970 std::variant<systemEventType, oemTsEventType,
971 oemEventType>> // Record Content
972 ipmiStorageGetSELEntry(uint16_t reservationID, uint16_t targetID,
973 uint8_t offset, uint8_t size)
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800974{
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700975 // Only support getting the entire SEL record. If a partial size or non-zero
976 // offset is requested, return an error
977 if (offset != 0 || size != ipmi::sel::entireRecord)
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800978 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700979 return ipmi::responseRetBytesUnavailable();
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800980 }
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800981
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700982 // Check the reservation ID if one is provided or required (only if the
983 // offset is non-zero)
984 if (reservationID != 0 || offset != 0)
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800985 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700986 if (!checkSELReservation(reservationID))
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800987 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700988 return ipmi::responseInvalidReservationId();
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800989 }
990 }
991
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700992 // Get the ipmi_sel log files
993 std::vector<std::filesystem::path> selLogFiles;
994 if (!getSELLogFiles(selLogFiles))
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800995 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700996 return ipmi::responseSensorInvalid();
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800997 }
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800998
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700999 std::string targetEntry;
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001000
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001001 if (targetID == ipmi::sel::firstEntry)
1002 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001003 // The first entry will be at the top of the oldest log file
1004 std::ifstream logStream(selLogFiles.back());
1005 if (!logStream.is_open())
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001006 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001007 return ipmi::responseUnspecifiedError();
1008 }
1009
1010 if (!std::getline(logStream, targetEntry))
1011 {
1012 return ipmi::responseUnspecifiedError();
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001013 }
1014 }
1015 else if (targetID == ipmi::sel::lastEntry)
1016 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001017 // The last entry will be at the bottom of the newest log file
1018 std::ifstream logStream(selLogFiles.front());
1019 if (!logStream.is_open())
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001020 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001021 return ipmi::responseUnspecifiedError();
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001022 }
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001023
1024 std::string line;
1025 while (std::getline(logStream, line))
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001026 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001027 targetEntry = line;
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001028 }
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001029 }
1030 else
1031 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001032 if (!findSELEntry(targetID, selLogFiles, targetEntry))
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001033 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001034 return ipmi::responseSensorInvalid();
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001035 }
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001036 }
1037
Jason M. Bills52aaa7d2019-05-08 15:21:39 -07001038 // The format of the ipmi_sel message is "<Timestamp>
1039 // <ID>,<Type>,<EventData>,[<Generator ID>,<Path>,<Direction>]".
1040 // First get the Timestamp
1041 size_t space = targetEntry.find_first_of(" ");
1042 if (space == std::string::npos)
1043 {
1044 return ipmi::responseUnspecifiedError();
1045 }
1046 std::string entryTimestamp = targetEntry.substr(0, space);
1047 // Then get the log contents
1048 size_t entryStart = targetEntry.find_first_not_of(" ", space);
1049 if (entryStart == std::string::npos)
1050 {
1051 return ipmi::responseUnspecifiedError();
1052 }
1053 std::string_view entry(targetEntry);
1054 entry.remove_prefix(entryStart);
1055 // Use split to separate the entry into its fields
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001056 std::vector<std::string> targetEntryFields;
Jason M. Bills52aaa7d2019-05-08 15:21:39 -07001057 boost::split(targetEntryFields, entry, boost::is_any_of(","),
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001058 boost::token_compress_on);
Jason M. Bills52aaa7d2019-05-08 15:21:39 -07001059 if (targetEntryFields.size() < 3)
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001060 {
1061 return ipmi::responseUnspecifiedError();
1062 }
Jason M. Bills1a2fbdd2019-05-10 09:05:37 -07001063 std::string& recordIDStr = targetEntryFields[0];
1064 std::string& recordTypeStr = targetEntryFields[1];
1065 std::string& eventDataStr = targetEntryFields[2];
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001066
Jason M. Bills1a2fbdd2019-05-10 09:05:37 -07001067 uint16_t recordID;
1068 uint8_t recordType;
1069 try
1070 {
1071 recordID = std::stoul(recordIDStr);
1072 recordType = std::stoul(recordTypeStr, nullptr, 16);
1073 }
1074 catch (const std::invalid_argument&)
1075 {
1076 return ipmi::responseUnspecifiedError();
1077 }
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001078 uint16_t nextRecordID = getNextRecordID(recordID, selLogFiles);
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001079 std::vector<uint8_t> eventDataBytes;
Jason M. Bills1a2fbdd2019-05-10 09:05:37 -07001080 if (fromHexStr(eventDataStr, eventDataBytes) < 0)
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001081 {
1082 return ipmi::responseUnspecifiedError();
1083 }
1084
1085 if (recordType == intel_oem::ipmi::sel::systemEvent)
1086 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001087 // Get the timestamp
1088 std::tm timeStruct = {};
Jason M. Bills52aaa7d2019-05-08 15:21:39 -07001089 std::istringstream entryStream(entryTimestamp);
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001090
1091 uint32_t timestamp = ipmi::sel::invalidTimeStamp;
1092 if (entryStream >> std::get_time(&timeStruct, "%Y-%m-%dT%H:%M:%S"))
1093 {
1094 timestamp = std::mktime(&timeStruct);
1095 }
1096
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001097 // Set the event message revision
1098 uint8_t evmRev = intel_oem::ipmi::sel::eventMsgRev;
1099
Jason M. Bills1a2fbdd2019-05-10 09:05:37 -07001100 uint16_t generatorID = 0;
1101 uint8_t sensorType = 0;
Johnathan Mantey308c3a82020-07-22 11:50:54 -07001102 uint16_t sensorAndLun = 0;
Jason M. Bills1a2fbdd2019-05-10 09:05:37 -07001103 uint8_t sensorNum = 0xFF;
1104 uint7_t eventType = 0;
1105 bool eventDir = 0;
1106 // System type events should have six fields
1107 if (targetEntryFields.size() >= 6)
1108 {
1109 std::string& generatorIDStr = targetEntryFields[3];
1110 std::string& sensorPath = targetEntryFields[4];
1111 std::string& eventDirStr = targetEntryFields[5];
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001112
Jason M. Bills1a2fbdd2019-05-10 09:05:37 -07001113 // Get the generator ID
1114 try
1115 {
1116 generatorID = std::stoul(generatorIDStr, nullptr, 16);
1117 }
1118 catch (const std::invalid_argument&)
1119 {
1120 std::cerr << "Invalid Generator ID\n";
1121 }
1122
1123 // Get the sensor type, sensor number, and event type for the sensor
1124 sensorType = getSensorTypeFromPath(sensorPath);
Johnathan Mantey308c3a82020-07-22 11:50:54 -07001125 sensorAndLun = getSensorNumberFromPath(sensorPath);
1126 sensorNum = static_cast<uint8_t>(sensorAndLun);
1127 generatorID |= sensorAndLun >> 8;
Jason M. Bills1a2fbdd2019-05-10 09:05:37 -07001128 eventType = getSensorEventTypeFromPath(sensorPath);
1129
1130 // Get the event direction
1131 try
1132 {
1133 eventDir = std::stoul(eventDirStr) ? 0 : 1;
1134 }
1135 catch (const std::invalid_argument&)
1136 {
1137 std::cerr << "Invalid Event Direction\n";
1138 }
1139 }
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001140
1141 // Only keep the eventData bytes that fit in the record
1142 std::array<uint8_t, intel_oem::ipmi::sel::systemEventSize> eventData{};
1143 std::copy_n(eventDataBytes.begin(),
1144 std::min(eventDataBytes.size(), eventData.size()),
1145 eventData.begin());
1146
1147 return ipmi::responseSuccess(
1148 nextRecordID, recordID, recordType,
1149 systemEventType{timestamp, generatorID, evmRev, sensorType,
1150 sensorNum, eventType, eventDir, eventData});
1151 }
1152 else if (recordType >= intel_oem::ipmi::sel::oemTsEventFirst &&
1153 recordType <= intel_oem::ipmi::sel::oemTsEventLast)
1154 {
1155 // Get the timestamp
1156 std::tm timeStruct = {};
Jason M. Bills52aaa7d2019-05-08 15:21:39 -07001157 std::istringstream entryStream(entryTimestamp);
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001158
1159 uint32_t timestamp = ipmi::sel::invalidTimeStamp;
1160 if (entryStream >> std::get_time(&timeStruct, "%Y-%m-%dT%H:%M:%S"))
1161 {
1162 timestamp = std::mktime(&timeStruct);
1163 }
1164
1165 // Only keep the bytes that fit in the record
1166 std::array<uint8_t, intel_oem::ipmi::sel::oemTsEventSize> eventData{};
1167 std::copy_n(eventDataBytes.begin(),
1168 std::min(eventDataBytes.size(), eventData.size()),
1169 eventData.begin());
1170
1171 return ipmi::responseSuccess(nextRecordID, recordID, recordType,
1172 oemTsEventType{timestamp, eventData});
1173 }
Patrick Venturec5136aa2019-10-04 20:39:31 -07001174 else if (recordType >= intel_oem::ipmi::sel::oemEventFirst)
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001175 {
1176 // Only keep the bytes that fit in the record
1177 std::array<uint8_t, intel_oem::ipmi::sel::oemEventSize> eventData{};
1178 std::copy_n(eventDataBytes.begin(),
1179 std::min(eventDataBytes.size(), eventData.size()),
1180 eventData.begin());
1181
1182 return ipmi::responseSuccess(nextRecordID, recordID, recordType,
1183 eventData);
1184 }
1185
1186 return ipmi::responseUnspecifiedError();
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001187}
1188
Jason M. Bills6dd8f042019-04-11 10:39:02 -07001189ipmi::RspType<uint16_t> ipmiStorageAddSELEntry(
1190 uint16_t recordID, uint8_t recordType, uint32_t timestamp,
1191 uint16_t generatorID, uint8_t evmRev, uint8_t sensorType, uint8_t sensorNum,
1192 uint8_t eventType, uint8_t eventData1, uint8_t eventData2,
1193 uint8_t eventData3)
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001194{
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001195 // Per the IPMI spec, need to cancel any reservation when a SEL entry is
1196 // added
1197 cancelSELReservation();
1198
Jason M. Bills6dd8f042019-04-11 10:39:02 -07001199 // Send this request to the Redfish hooks to log it as a Redfish message
1200 // instead. There is no need to add it to the SEL, so just return success.
1201 intel_oem::ipmi::sel::checkRedfishHooks(
1202 recordID, recordType, timestamp, generatorID, evmRev, sensorType,
1203 sensorNum, eventType, eventData1, eventData2, eventData3);
Jason M. Bills99b78ec2019-01-18 10:42:18 -08001204
Jason M. Bills6dd8f042019-04-11 10:39:02 -07001205 uint16_t responseID = 0xFFFF;
1206 return ipmi::responseSuccess(responseID);
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001207}
1208
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001209ipmi::RspType<uint8_t> ipmiStorageClearSEL(ipmi::Context::ptr ctx,
1210 uint16_t reservationID,
1211 const std::array<uint8_t, 3>& clr,
1212 uint8_t eraseOperation)
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001213{
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001214 if (!checkSELReservation(reservationID))
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001215 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001216 return ipmi::responseInvalidReservationId();
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001217 }
1218
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001219 static constexpr std::array<uint8_t, 3> clrExpected = {'C', 'L', 'R'};
1220 if (clr != clrExpected)
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001221 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001222 return ipmi::responseInvalidFieldRequest();
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001223 }
1224
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001225 // Erasure status cannot be fetched, so always return erasure status as
1226 // `erase completed`.
1227 if (eraseOperation == ipmi::sel::getEraseStatus)
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001228 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001229 return ipmi::responseSuccess(ipmi::sel::eraseComplete);
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001230 }
1231
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001232 // Check that initiate erase is correct
1233 if (eraseOperation != ipmi::sel::initiateErase)
1234 {
1235 return ipmi::responseInvalidFieldRequest();
1236 }
1237
1238 // Per the IPMI spec, need to cancel any reservation when the SEL is
1239 // cleared
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001240 cancelSELReservation();
1241
Jason M. Bills7944c302019-03-20 15:24:05 -07001242 // Save the erase time
1243 intel_oem::ipmi::sel::erase_time::save();
1244
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001245 // Clear the SEL by deleting the log files
1246 std::vector<std::filesystem::path> selLogFiles;
1247 if (getSELLogFiles(selLogFiles))
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001248 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001249 for (const std::filesystem::path& file : selLogFiles)
1250 {
1251 std::error_code ec;
1252 std::filesystem::remove(file, ec);
1253 }
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001254 }
1255
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001256 // Reload rsyslog so it knows to start new log files
Vernon Mauery15419dd2019-05-24 09:40:30 -07001257 std::shared_ptr<sdbusplus::asio::connection> dbus = getSdBus();
Patrick Williamsf944d2e2022-07-22 19:26:52 -05001258 sdbusplus::message_t rsyslogReload = dbus->new_method_call(
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001259 "org.freedesktop.systemd1", "/org/freedesktop/systemd1",
1260 "org.freedesktop.systemd1.Manager", "ReloadUnit");
1261 rsyslogReload.append("rsyslog.service", "replace");
1262 try
1263 {
Patrick Williamsf944d2e2022-07-22 19:26:52 -05001264 sdbusplus::message_t reloadResponse = dbus->call(rsyslogReload);
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001265 }
Patrick Williamsbd51e6a2021-10-06 13:09:44 -05001266 catch (const sdbusplus::exception_t& e)
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001267 {
1268 phosphor::logging::log<phosphor::logging::level::ERR>(e.what());
1269 }
1270
1271 return ipmi::responseSuccess(ipmi::sel::eraseComplete);
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001272}
1273
Jason M. Bills1a474622019-06-14 14:51:33 -07001274ipmi::RspType<uint32_t> ipmiStorageGetSELTime()
1275{
1276 struct timespec selTime = {};
1277
1278 if (clock_gettime(CLOCK_REALTIME, &selTime) < 0)
1279 {
1280 return ipmi::responseUnspecifiedError();
1281 }
1282
1283 return ipmi::responseSuccess(selTime.tv_sec);
1284}
1285
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001286ipmi::RspType<> ipmiStorageSetSELTime(uint32_t selTime)
Jason M. Billscac97a52019-01-30 14:43:46 -08001287{
1288 // Set SEL Time is not supported
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001289 return ipmi::responseInvalidCommand();
Jason M. Billscac97a52019-01-30 14:43:46 -08001290}
1291
James Feist74c50c62019-08-14 14:18:41 -07001292std::vector<uint8_t> getType12SDRs(uint16_t index, uint16_t recordId)
1293{
1294 std::vector<uint8_t> resp;
1295 if (index == 0)
1296 {
James Feist74c50c62019-08-14 14:18:41 -07001297 std::string bmcName = "Basbrd Mgmt Ctlr";
Johnathan Manteyf4d5e052021-09-22 12:58:08 -07001298 Type12Record bmc(recordId, 0x20, 0, 0, 0xbf, 0x2e, 1, 0, bmcName);
James Feist74c50c62019-08-14 14:18:41 -07001299 uint8_t* bmcPtr = reinterpret_cast<uint8_t*>(&bmc);
1300 resp.insert(resp.end(), bmcPtr, bmcPtr + sizeof(Type12Record));
1301 }
1302 else if (index == 1)
1303 {
James Feist74c50c62019-08-14 14:18:41 -07001304 std::string meName = "Mgmt Engine";
Johnathan Manteyf4d5e052021-09-22 12:58:08 -07001305 Type12Record me(recordId, 0x2c, 6, 0x24, 0x21, 0x2e, 2, 0, meName);
James Feist74c50c62019-08-14 14:18:41 -07001306 uint8_t* mePtr = reinterpret_cast<uint8_t*>(&me);
1307 resp.insert(resp.end(), mePtr, mePtr + sizeof(Type12Record));
1308 }
1309 else
1310 {
1311 throw std::runtime_error("getType12SDRs:: Illegal index " +
1312 std::to_string(index));
1313 }
1314
1315 return resp;
1316}
1317
Yong Lifee5e4c2020-01-17 19:36:29 +08001318std::vector<uint8_t> getNMDiscoverySDR(uint16_t index, uint16_t recordId)
1319{
1320 std::vector<uint8_t> resp;
1321 if (index == 0)
1322 {
1323 NMDiscoveryRecord nm = {};
1324 nm.header.record_id_lsb = recordId;
1325 nm.header.record_id_msb = recordId >> 8;
1326 nm.header.sdr_version = ipmiSdrVersion;
1327 nm.header.record_type = 0xC0;
1328 nm.header.record_length = 0xB;
1329 nm.oemID0 = 0x57;
1330 nm.oemID1 = 0x1;
1331 nm.oemID2 = 0x0;
1332 nm.subType = 0x0D;
1333 nm.version = 0x1;
1334 nm.slaveAddress = 0x2C;
1335 nm.channelNumber = 0x60;
1336 nm.healthEventSensor = 0x19;
1337 nm.exceptionEventSensor = 0x18;
1338 nm.operationalCapSensor = 0x1A;
1339 nm.thresholdExceededSensor = 0x1B;
1340
1341 uint8_t* nmPtr = reinterpret_cast<uint8_t*>(&nm);
1342 resp.insert(resp.end(), nmPtr, nmPtr + sizeof(NMDiscoveryRecord));
1343 }
1344 else
1345 {
1346 throw std::runtime_error("getNMDiscoverySDR:: Illegal index " +
1347 std::to_string(index));
1348 }
1349
1350 return resp;
1351}
1352
Jason M. Billse2d1aee2018-10-03 15:57:18 -07001353void registerStorageFunctions()
1354{
James Feist25690252019-12-23 12:25:49 -08001355 createTimers();
James Feiste4f710d2020-05-20 15:50:30 -07001356 startMatch();
1357
Jason M. Billse2d1aee2018-10-03 15:57:18 -07001358 // <Get FRU Inventory Area Info>
jayaprakash Mutyalad33acd62019-05-17 19:37:25 +00001359 ipmi::registerHandler(ipmi::prioOemBase, ipmi::netFnStorage,
1360 ipmi::storage::cmdGetFruInventoryAreaInfo,
1361 ipmi::Privilege::User, ipmiStorageGetFruInvAreaInfo);
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001362 // <READ FRU Data>
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +00001363 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
1364 ipmi::storage::cmdReadFruData, ipmi::Privilege::User,
1365 ipmiStorageReadFruData);
Jason M. Billse2d1aee2018-10-03 15:57:18 -07001366
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001367 // <WRITE FRU Data>
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +00001368 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
1369 ipmi::storage::cmdWriteFruData,
1370 ipmi::Privilege::Operator, ipmiStorageWriteFruData);
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001371
1372 // <Get SEL Info>
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001373 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
Jason M. Bills542498e2019-06-24 16:57:42 -07001374 ipmi::storage::cmdGetSelInfo, ipmi::Privilege::User,
1375 ipmiStorageGetSELInfo);
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001376
1377 // <Get SEL Entry>
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001378 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
Jason M. Bills542498e2019-06-24 16:57:42 -07001379 ipmi::storage::cmdGetSelEntry, ipmi::Privilege::User,
1380 ipmiStorageGetSELEntry);
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001381
1382 // <Add SEL Entry>
Jason M. Bills6dd8f042019-04-11 10:39:02 -07001383 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
Vernon Mauery98bbf692019-09-16 11:14:59 -07001384 ipmi::storage::cmdAddSelEntry,
Jason M. Bills6dd8f042019-04-11 10:39:02 -07001385 ipmi::Privilege::Operator, ipmiStorageAddSELEntry);
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001386
1387 // <Clear SEL>
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001388 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
1389 ipmi::storage::cmdClearSel, ipmi::Privilege::Operator,
1390 ipmiStorageClearSEL);
Jason M. Billscac97a52019-01-30 14:43:46 -08001391
Jason M. Bills1a474622019-06-14 14:51:33 -07001392 // <Get SEL Time>
1393 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
Jason M. Bills542498e2019-06-24 16:57:42 -07001394 ipmi::storage::cmdGetSelTime, ipmi::Privilege::User,
1395 ipmiStorageGetSELTime);
Jason M. Bills1a474622019-06-14 14:51:33 -07001396
Jason M. Billscac97a52019-01-30 14:43:46 -08001397 // <Set SEL Time>
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001398 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
1399 ipmi::storage::cmdSetSelTime,
1400 ipmi::Privilege::Operator, ipmiStorageSetSELTime);
Jason M. Billse2d1aee2018-10-03 15:57:18 -07001401}
Jason M. Bills3f7c5e42018-10-03 14:00:41 -07001402} // namespace storage
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001403} // namespace ipmi