blob: 0028592b6cdb8d87a8231ddfb47f8fa93445733a [file] [log] [blame]
Patrick Venture46470a32018-09-07 19:26:25 -07001#include "config.h"
2
3#include "chassishandler.hpp"
Patrick Venture0b02be92018-08-31 11:55:55 -07004
Patrick Venture0b02be92018-08-31 11:55:55 -07005#include <arpa/inet.h>
6#include <endian.h>
7#include <limits.h>
8#include <mapper.h>
9#include <netinet/in.h>
Patrick Venture0b02be92018-08-31 11:55:55 -070010
Vernon Mauerye08fbff2019-04-03 09:19:34 -070011#include <ipmid/api.hpp>
Vernon Mauery33250242019-03-12 16:49:26 -070012#include <ipmid/types.hpp>
Vernon Mauery6a98fe72019-03-11 15:57:48 -070013#include <ipmid/utils.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070014#include <phosphor-logging/elog-errors.hpp>
15#include <phosphor-logging/log.hpp>
16#include <sdbusplus/bus.hpp>
William A. Kennington III4c008022018-10-12 17:18:14 -070017#include <sdbusplus/message/types.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070018#include <sdbusplus/server/object.hpp>
Vernon Mauery1181af72018-10-08 12:05:00 -070019#include <sdbusplus/timer.hpp>
Vernon Mauerye278ead2018-10-09 09:23:43 -070020#include <settings.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070021#include <xyz/openbmc_project/Common/error.hpp>
22#include <xyz/openbmc_project/Control/Boot/Mode/server.hpp>
23#include <xyz/openbmc_project/Control/Boot/Source/server.hpp>
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +030024#include <xyz/openbmc_project/Control/Boot/Type/server.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070025#include <xyz/openbmc_project/Control/Power/RestorePolicy/server.hpp>
Jason M. Billsad588bf2020-01-30 16:18:33 -080026#include <xyz/openbmc_project/State/Chassis/server.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070027#include <xyz/openbmc_project/State/Host/server.hpp>
28#include <xyz/openbmc_project/State/PowerOnHours/server.hpp>
29
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -050030#include <array>
31#include <chrono>
32#include <cstring>
33#include <filesystem>
34#include <fstream>
35#include <future>
36#include <map>
37#include <sstream>
38#include <string>
39
Lei YU4b0ddb62019-01-25 16:43:50 +080040std::unique_ptr<phosphor::Timer> identifyTimer
41 __attribute__((init_priority(101)));
Marri Devender Rao6706c1c2018-05-14 00:29:38 -050042
Yong Lif4e38512019-05-21 14:46:55 +080043static ChassisIDState chassisIDState = ChassisIDState::reserved;
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +000044static constexpr uint8_t setParmVersion = 0x01;
Yong Lif4e38512019-05-21 14:46:55 +080045
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +000046constexpr size_t sizeVersion = 2;
Tom Joseph5110c122018-03-23 17:55:40 +053047constexpr size_t DEFAULT_IDENTIFY_TIME_OUT = 15;
Ratan Gupta6ec7daa2017-07-15 14:13:01 +053048
Patrick Venture0b02be92018-08-31 11:55:55 -070049// PetiBoot-Specific
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +000050static constexpr uint8_t netConfInitialBytes[] = {0x80, 0x21, 0x70, 0x62,
51 0x21, 0x00, 0x01, 0x06};
52static constexpr uint8_t oemParmStart = 96;
53static constexpr uint8_t oemParmEnd = 127;
Ratan Guptafd28dd72016-08-01 04:58:01 -050054
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +000055static constexpr size_t cookieOffset = 1;
56static constexpr size_t versionOffset = 5;
57static constexpr size_t addrSizeOffset = 8;
58static constexpr size_t macOffset = 9;
59static constexpr size_t addrTypeOffset = 16;
60static constexpr size_t ipAddrOffset = 17;
ratagupta6f6bff2016-04-04 06:20:11 -050061
Marri Devender Rao6706c1c2018-05-14 00:29:38 -050062static constexpr size_t encIdentifyObjectsSize = 1;
63static constexpr size_t chassisIdentifyReqLength = 2;
64static constexpr size_t identifyIntervalPos = 0;
65static constexpr size_t forceIdentifyPos = 1;
shgoupfd84fbbf2015-12-17 10:05:51 +080066
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +000067namespace ipmi
68{
69constexpr Cc ccParmNotSupported = 0x80;
70
71static inline auto responseParmNotSupported()
72{
73 return response(ccParmNotSupported);
74}
75} // namespace ipmi
76
Adriana Kobylak40814c62015-10-27 15:58:44 -050077void register_netfn_chassis_functions() __attribute__((constructor));
78
shgoupfd84fbbf2015-12-17 10:05:51 +080079// Host settings in dbus
80// Service name should be referenced by connection name got via object mapper
Patrick Venture0b02be92018-08-31 11:55:55 -070081const char* settings_object_name = "/org/openbmc/settings/host0";
82const char* settings_intf_name = "org.freedesktop.DBus.Properties";
Patrick Venture0b02be92018-08-31 11:55:55 -070083const char* identify_led_object_name =
Tom Joseph5110c122018-03-23 17:55:40 +053084 "/xyz/openbmc_project/led/groups/enclosure_identify";
shgoupfd84fbbf2015-12-17 10:05:51 +080085
Ratan Guptadcb10672017-07-10 10:33:50 +053086constexpr auto SETTINGS_ROOT = "/";
87constexpr auto SETTINGS_MATCH = "host0";
Ratan Guptadcb10672017-07-10 10:33:50 +053088
89constexpr auto IP_INTERFACE = "xyz.openbmc_project.Network.IP";
90constexpr auto MAC_INTERFACE = "xyz.openbmc_project.Network.MACAddress";
91
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -050092static constexpr auto chassisStateRoot = "/xyz/openbmc_project/state";
93static constexpr auto chassisPOHStateIntf =
Patrick Venture0b02be92018-08-31 11:55:55 -070094 "xyz.openbmc_project.State.PowerOnHours";
Patrick Williams7345ac42021-04-30 20:57:39 -050095static constexpr auto pohCounterProperty = "POHCounter";
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -050096static constexpr auto match = "chassis0";
Yong Liae4b0402018-11-02 11:12:14 +080097const static constexpr char chassisCapIntf[] =
98 "xyz.openbmc_project.Control.ChassisCapabilities";
Karthick Sundarrajan86d8bd72019-11-26 12:48:50 -080099const static constexpr char chassisIntrusionProp[] = "ChassisIntrusionEnabled";
100const static constexpr char chassisFrontPanelLockoutProp[] =
101 "ChassisFrontPanelLockoutEnabled";
102const static constexpr char chassisNMIProp[] = "ChassisNMIEnabled";
103const static constexpr char chassisPowerInterlockProp[] =
104 "ChassisPowerInterlockEnabled";
Yong Liae4b0402018-11-02 11:12:14 +0800105const static constexpr char chassisFRUDevAddrProp[] = "FRUDeviceAddress";
106const static constexpr char chassisSDRDevAddrProp[] = "SDRDeviceAddress";
107const static constexpr char chassisSELDevAddrProp[] = "SELDeviceAddress";
108const static constexpr char chassisSMDevAddrProp[] = "SMDeviceAddress";
109const static constexpr char chassisBridgeDevAddrProp[] = "BridgeDeviceAddress";
110static constexpr uint8_t chassisCapFlagMask = 0x0f;
111static constexpr uint8_t chassisCapAddrMask = 0xfe;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700112static constexpr const char* powerButtonIntf =
113 "xyz.openbmc_project.Chassis.Buttons.Power";
114static constexpr const char* powerButtonPath =
115 "/xyz/openbmc_project/Chassis/Buttons/Power0";
116static constexpr const char* resetButtonIntf =
117 "xyz.openbmc_project.Chassis.Buttons.Reset";
118static constexpr const char* resetButtonPath =
119 "/xyz/openbmc_project/Chassis/Buttons/Reset0";
Ratan Guptadcb10672017-07-10 10:33:50 +0530120
Vishwanatha Subbannab12b0c02017-03-07 18:17:19 +0530121// Phosphor Host State manager
122namespace State = sdbusplus::xyz::openbmc_project::State::server;
123
Vernon Mauery185b9f82018-07-20 10:52:36 -0700124namespace fs = std::filesystem;
Andrew Geisslera6e3a302017-05-31 19:34:00 -0500125
Ratan Guptadcb10672017-07-10 10:33:50 +0530126using namespace phosphor::logging;
127using namespace sdbusplus::xyz::openbmc_project::Common::Error;
Marri Devender Rao81719702018-05-07 00:53:48 -0500128using namespace sdbusplus::xyz::openbmc_project::Control::Boot::server;
William A. Kennington III4c008022018-10-12 17:18:14 -0700129
Deepak Kodihalli8cc19362017-07-21 11:18:38 -0500130namespace chassis
131{
132namespace internal
133{
134
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +0300135constexpr auto bootSettingsPath = "/xyz/openbmc_project/control/host0/boot";
136constexpr auto bootEnableIntf = "xyz.openbmc_project.Object.Enable";
Deepak Kodihalli8cc19362017-07-21 11:18:38 -0500137constexpr auto bootModeIntf = "xyz.openbmc_project.Control.Boot.Mode";
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +0300138constexpr auto bootTypeIntf = "xyz.openbmc_project.Control.Boot.Type";
Deepak Kodihalli8cc19362017-07-21 11:18:38 -0500139constexpr auto bootSourceIntf = "xyz.openbmc_project.Control.Boot.Source";
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +0300140constexpr auto bootSettingsOneTimePath =
141 "/xyz/openbmc_project/control/host0/boot/one_time";
142constexpr auto bootOneTimeIntf = "xyz.openbmc_project.Object.Enable";
143
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500144constexpr auto powerRestoreIntf =
145 "xyz.openbmc_project.Control.Power.RestorePolicy";
Patrick Williams5d82f472022-07-22 19:26:53 -0500146sdbusplus::bus_t dbus(ipmid_get_sd_bus_connection());
Deepak Kodihalli8cc19362017-07-21 11:18:38 -0500147
148namespace cache
149{
150
James Feist225dec82019-11-26 16:25:06 -0800151std::unique_ptr<settings::Objects> objectsPtr = nullptr;
152
153settings::Objects& getObjects()
154{
155 if (objectsPtr == nullptr)
156 {
157 objectsPtr = std::make_unique<settings::Objects>(
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +0300158 dbus, std::vector<std::string>{bootModeIntf, bootTypeIntf,
159 bootSourceIntf, powerRestoreIntf});
James Feist225dec82019-11-26 16:25:06 -0800160 }
161 return *objectsPtr;
162}
Deepak Kodihalli8cc19362017-07-21 11:18:38 -0500163
164} // namespace cache
165} // namespace internal
166} // namespace chassis
167
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500168namespace poh
169{
170
171constexpr auto minutesPerCount = 60;
172
173} // namespace poh
174
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000175int getHostNetworkData(ipmi::message::Payload& payload)
Ratan Guptafd28dd72016-08-01 04:58:01 -0500176{
Ratan Guptadcb10672017-07-10 10:33:50 +0530177 ipmi::PropertyMap properties;
178 int rc = 0;
Ratan Gupta8c31d232017-08-13 05:49:43 +0530179 uint8_t addrSize = ipmi::network::IPV4_ADDRESS_SIZE_BYTE;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500180
Ratan Guptadcb10672017-07-10 10:33:50 +0530181 try
182 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700183 // TODO There may be cases where an interface is implemented by multiple
Ratan Guptadcb10672017-07-10 10:33:50 +0530184 // objects,to handle such cases we are interested on that object
185 // which are on interested busname.
186 // Currenlty mapper doesn't give the readable busname(gives busid)
187 // so we can't match with bus name so giving some object specific info
188 // as SETTINGS_MATCH.
189 // Later SETTINGS_MATCH will be replaced with busname.
Ratan Guptafd28dd72016-08-01 04:58:01 -0500190
Patrick Williams5d82f472022-07-22 19:26:53 -0500191 sdbusplus::bus_t bus(ipmid_get_sd_bus_connection());
Ratan Guptadcb10672017-07-10 10:33:50 +0530192
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530193 auto ipObjectInfo = ipmi::getDbusObject(bus, IP_INTERFACE,
194 SETTINGS_ROOT, SETTINGS_MATCH);
195
196 auto macObjectInfo = ipmi::getDbusObject(bus, MAC_INTERFACE,
197 SETTINGS_ROOT, SETTINGS_MATCH);
198
Patrick Venture0b02be92018-08-31 11:55:55 -0700199 properties = ipmi::getAllDbusProperties(
200 bus, ipObjectInfo.second, ipObjectInfo.first, IP_INTERFACE);
201 auto variant = ipmi::getDbusProperty(bus, macObjectInfo.second,
202 macObjectInfo.first, MAC_INTERFACE,
203 "MACAddress");
Ratan Guptadcb10672017-07-10 10:33:50 +0530204
Vernon Maueryf442e112019-04-09 11:44:36 -0700205 auto ipAddress = std::get<std::string>(properties["Address"]);
Ratan Guptad70f4532017-08-04 02:07:31 +0530206
Vernon Maueryf442e112019-04-09 11:44:36 -0700207 auto gateway = std::get<std::string>(properties["Gateway"]);
Ratan Guptad70f4532017-08-04 02:07:31 +0530208
Vernon Maueryf442e112019-04-09 11:44:36 -0700209 auto prefix = std::get<uint8_t>(properties["PrefixLength"]);
Ratan Guptad70f4532017-08-04 02:07:31 +0530210
Patrick Venture0b02be92018-08-31 11:55:55 -0700211 uint8_t isStatic =
Vernon Maueryf442e112019-04-09 11:44:36 -0700212 (std::get<std::string>(properties["Origin"]) ==
Patrick Venture0b02be92018-08-31 11:55:55 -0700213 "xyz.openbmc_project.Network.IP.AddressOrigin.Static")
214 ? 1
215 : 0;
Ratan Guptad70f4532017-08-04 02:07:31 +0530216
Vernon Maueryf442e112019-04-09 11:44:36 -0700217 auto MACAddress = std::get<std::string>(variant);
Ratan Guptacc8feb42017-07-25 21:52:10 +0530218
Ratan Guptad70f4532017-08-04 02:07:31 +0530219 // it is expected here that we should get the valid data
220 // but we may also get the default values.
221 // Validation of the data is done by settings.
222 //
223 // if mac address is default mac address then
224 // don't send blank override.
Ratan Gupta8c31d232017-08-13 05:49:43 +0530225 if ((MACAddress == ipmi::network::DEFAULT_MAC_ADDRESS))
Ratan Guptad70f4532017-08-04 02:07:31 +0530226 {
Ratan Guptad70f4532017-08-04 02:07:31 +0530227 rc = -1;
228 return rc;
229 }
230 // if addr is static then ipaddress,gateway,prefix
231 // should not be default one,don't send blank override.
232 if (isStatic)
233 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700234 if ((ipAddress == ipmi::network::DEFAULT_ADDRESS) ||
235 (gateway == ipmi::network::DEFAULT_ADDRESS) || (!prefix))
Ratan Guptad70f4532017-08-04 02:07:31 +0530236 {
Ratan Guptad70f4532017-08-04 02:07:31 +0530237 rc = -1;
238 return rc;
239 }
240 }
241
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000242 std::string token;
243 std::stringstream ss(MACAddress);
Ratan Guptadcb10672017-07-10 10:33:50 +0530244
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000245 // First pack macOffset no of bytes in payload.
246 // Latter this PetiBoot-Specific data will be populated.
247 std::vector<uint8_t> payloadInitialBytes(macOffset);
248 payload.pack(payloadInitialBytes);
Ratan Guptadcb10672017-07-10 10:33:50 +0530249
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000250 while (std::getline(ss, token, ':'))
251 {
252 payload.pack(stoi(token, nullptr, 16));
253 }
254
255 payload.pack(0x00);
256
257 payload.pack(isStatic);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530258
Vernon Maueryf442e112019-04-09 11:44:36 -0700259 uint8_t addressFamily = (std::get<std::string>(properties["Type"]) ==
260 "xyz.openbmc_project.Network.IP.Protocol.IPv4")
261 ? AF_INET
262 : AF_INET6;
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530263
Patrick Venture0b02be92018-08-31 11:55:55 -0700264 addrSize = (addressFamily == AF_INET)
265 ? ipmi::network::IPV4_ADDRESS_SIZE_BYTE
266 : ipmi::network::IPV6_ADDRESS_SIZE_BYTE;
Ratan Guptadcb10672017-07-10 10:33:50 +0530267
268 // ipaddress and gateway would be in IPv4 format
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000269 std::vector<uint8_t> addrInBinary(addrSize);
Ratan Guptad70f4532017-08-04 02:07:31 +0530270 inet_pton(addressFamily, ipAddress.c_str(),
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000271 reinterpret_cast<void*>(addrInBinary.data()));
Ratan Guptadcb10672017-07-10 10:33:50 +0530272
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000273 payload.pack(addrInBinary);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530274
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000275 payload.pack(prefix);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530276
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000277 std::vector<uint8_t> gatewayDetails(addrSize);
Ratan Guptad70f4532017-08-04 02:07:31 +0530278 inet_pton(addressFamily, gateway.c_str(),
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000279 reinterpret_cast<void*>(gatewayDetails.data()));
280 payload.pack(gatewayDetails);
Ratan Guptadcb10672017-07-10 10:33:50 +0530281 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -0500282 catch (const InternalFailure& e)
Ratan Guptadcb10672017-07-10 10:33:50 +0530283 {
284 commit<InternalFailure>();
Ratan Guptadcb10672017-07-10 10:33:50 +0530285 rc = -1;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500286 return rc;
287 }
288
Patrick Venture0b02be92018-08-31 11:55:55 -0700289 // PetiBoot-Specific
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000290 // If success then copy the first 9 bytes to the payload message
291 // payload first 2 bytes contain the parameter values. Skip that 2 bytes.
292 uint8_t skipFirstTwoBytes = 2;
293 size_t payloadSize = payload.size();
294 uint8_t* configDataStartingAddress = payload.data() + skipFirstTwoBytes;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500295
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000296 if (payloadSize < skipFirstTwoBytes + sizeof(netConfInitialBytes))
297 {
298 log<level::ERR>("Invalid net config ");
299 rc = -1;
300 return rc;
301 }
302 std::copy(netConfInitialBytes,
303 netConfInitialBytes + sizeof(netConfInitialBytes),
304 configDataStartingAddress);
305
306 if (payloadSize < skipFirstTwoBytes + addrSizeOffset + sizeof(addrSize))
307 {
308 log<level::ERR>("Invalid length of address size");
309 rc = -1;
310 return rc;
311 }
312 std::copy(&addrSize, &(addrSize) + sizeof(addrSize),
313 configDataStartingAddress + addrSizeOffset);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530314
Ratan Guptafd28dd72016-08-01 04:58:01 -0500315#ifdef _IPMI_DEBUG_
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700316 std::printf("\n===Printing the IPMI Formatted Data========\n");
Ratan Guptafd28dd72016-08-01 04:58:01 -0500317
Ratan Guptadcb10672017-07-10 10:33:50 +0530318 for (uint8_t pos = 0; pos < index; pos++)
319 {
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000320 std::printf("%02x ", payloadStartingAddress[pos]);
Ratan Guptadcb10672017-07-10 10:33:50 +0530321 }
Ratan Guptafd28dd72016-08-01 04:58:01 -0500322#endif
323
Ratan Guptafd28dd72016-08-01 04:58:01 -0500324 return rc;
325}
326
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530327/** @brief convert IPv4 and IPv6 addresses from binary to text form.
328 * @param[in] family - IPv4/Ipv6
329 * @param[in] data - req data pointer.
330 * @param[in] offset - offset in the data.
331 * @param[in] addrSize - size of the data which needs to be read from offset.
332 * @returns address in text form.
333 */
334
Patrick Venture0b02be92018-08-31 11:55:55 -0700335std::string getAddrStr(uint8_t family, uint8_t* data, uint8_t offset,
336 uint8_t addrSize)
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530337{
338 char ipAddr[INET6_ADDRSTRLEN] = {};
339
Patrick Venture0b02be92018-08-31 11:55:55 -0700340 switch (family)
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530341 {
342 case AF_INET:
343 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700344 struct sockaddr_in addr4
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -0500345 {};
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700346 std::memcpy(&addr4.sin_addr.s_addr, &data[offset], addrSize);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530347
Patrick Venture0b02be92018-08-31 11:55:55 -0700348 inet_ntop(AF_INET, &addr4.sin_addr, ipAddr, INET_ADDRSTRLEN);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530349
350 break;
351 }
352 case AF_INET6:
353 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700354 struct sockaddr_in6 addr6
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -0500355 {};
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700356 std::memcpy(&addr6.sin6_addr.s6_addr, &data[offset], addrSize);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530357
Patrick Venture0b02be92018-08-31 11:55:55 -0700358 inet_ntop(AF_INET6, &addr6.sin6_addr, ipAddr, INET6_ADDRSTRLEN);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530359
360 break;
361 }
362 default:
363 {
364 return {};
365 }
366 }
367
368 return ipAddr;
369}
370
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000371ipmi::Cc setHostNetworkData(ipmi::message::Payload& data)
Ratan Guptafd28dd72016-08-01 04:58:01 -0500372{
Ratan Guptadcb10672017-07-10 10:33:50 +0530373 using namespace std::string_literals;
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000374 std::string hostNetworkConfig;
375 std::string mac("00:00:00:00:00:00");
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530376 std::string ipAddress, gateway;
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000377 std::string addrOrigin{0};
Patrick Venture0b02be92018-08-31 11:55:55 -0700378 uint8_t addrSize{0};
Ratan Guptadcb10672017-07-10 10:33:50 +0530379 std::string addressOrigin =
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530380 "xyz.openbmc_project.Network.IP.AddressOrigin.DHCP";
Patrick Venture0b02be92018-08-31 11:55:55 -0700381 std::string addressType = "xyz.openbmc_project.Network.IP.Protocol.IPv4";
382 uint8_t prefix{0};
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530383 uint8_t family = AF_INET;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500384
Patrick Venture0b02be92018-08-31 11:55:55 -0700385 // cookie starts from second byte
Ratan Guptafd28dd72016-08-01 04:58:01 -0500386 // version starts from sixth byte
387
Ratan Guptadcb10672017-07-10 10:33:50 +0530388 try
Ratan Guptafd28dd72016-08-01 04:58:01 -0500389 {
Ratan Guptadcb10672017-07-10 10:33:50 +0530390 do
391 {
392 // cookie == 0x21 0x70 0x62 0x21
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000393 data.trailingOk = true;
394 auto msgLen = data.size();
395 std::vector<uint8_t> msgPayloadBytes(msgLen);
396 if (data.unpack(msgPayloadBytes) != 0 || !data.fullyUnpacked())
Ratan Guptadcb10672017-07-10 10:33:50 +0530397 {
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000398 log<level::ERR>(
399 "Error in unpacking message of setHostNetworkData");
400 return ipmi::ccReqDataLenInvalid;
401 }
402
403 uint8_t* msgPayloadStartingPos = msgPayloadBytes.data();
404 constexpr size_t cookieSize = 4;
405 if (msgLen < cookieOffset + cookieSize)
406 {
407 log<level::ERR>(
408 "Error in cookie getting of setHostNetworkData");
409 return ipmi::ccReqDataLenInvalid;
410 }
411 if (std::equal(msgPayloadStartingPos + cookieOffset,
412 msgPayloadStartingPos + cookieOffset + cookieSize,
413 (netConfInitialBytes + cookieOffset)) != 0)
414 {
415 // all cookie == 0
416 if (std::all_of(msgPayloadStartingPos + cookieOffset,
417 msgPayloadStartingPos + cookieOffset +
418 cookieSize,
419 [](int i) { return i == 0; }) == true)
Ratan Guptadcb10672017-07-10 10:33:50 +0530420 {
421 // need to zero out the network settings.
422 break;
423 }
424
425 log<level::ERR>("Invalid Cookie");
426 elog<InternalFailure>();
427 }
428
429 // vesion == 0x00 0x01
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000430 if (msgLen < versionOffset + sizeVersion)
Ratan Guptadcb10672017-07-10 10:33:50 +0530431 {
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000432 log<level::ERR>(
433 "Error in version getting of setHostNetworkData");
434 return ipmi::ccReqDataLenInvalid;
435 }
436 if (std::equal(msgPayloadStartingPos + versionOffset,
437 msgPayloadStartingPos + versionOffset + sizeVersion,
438 (netConfInitialBytes + versionOffset)) != 0)
439 {
Ratan Guptadcb10672017-07-10 10:33:50 +0530440 log<level::ERR>("Invalid Version");
441 elog<InternalFailure>();
442 }
443
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000444 if (msgLen < macOffset + 6)
445 {
446 log<level::ERR>(
447 "Error in mac address getting of setHostNetworkData");
448 return ipmi::ccReqDataLenInvalid;
449 }
450 std::stringstream result;
451 std::copy((msgPayloadStartingPos + macOffset),
452 (msgPayloadStartingPos + macOffset + 5),
453 std::ostream_iterator<int>(result, ":"));
454 mac = result.str();
Ratan Guptadcb10672017-07-10 10:33:50 +0530455
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000456 if (msgLen < addrTypeOffset + sizeof(decltype(addrOrigin)))
457 {
458 log<level::ERR>(
459 "Error in original address getting of setHostNetworkData");
460 return ipmi::ccReqDataLenInvalid;
461 }
462 std::copy(msgPayloadStartingPos + addrTypeOffset,
463 msgPayloadStartingPos + addrTypeOffset +
464 sizeof(decltype(addrOrigin)),
465 std::ostream_iterator<int>(result, ""));
466 addrOrigin = result.str();
Ratan Guptadcb10672017-07-10 10:33:50 +0530467
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000468 if (!addrOrigin.empty())
Ratan Guptadcb10672017-07-10 10:33:50 +0530469 {
470 addressOrigin =
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530471 "xyz.openbmc_project.Network.IP.AddressOrigin.Static";
Ratan Guptadcb10672017-07-10 10:33:50 +0530472 }
473
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000474 if (msgLen < addrSizeOffset + sizeof(decltype(addrSize)))
475 {
476 log<level::ERR>(
477 "Error in address size getting of setHostNetworkData");
478 return ipmi::ccReqDataLenInvalid;
479 }
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530480 // Get the address size
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000481 std::copy(msgPayloadStartingPos + addrSizeOffset,
482 (msgPayloadStartingPos + addrSizeOffset +
483 sizeof(decltype(addrSize))),
484 &addrSize);
Ratan Guptadcb10672017-07-10 10:33:50 +0530485
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000486 uint8_t prefixOffset = ipAddrOffset + addrSize;
487 if (msgLen < prefixOffset + sizeof(decltype(prefix)))
488 {
489 log<level::ERR>(
490 "Error in prefix getting of setHostNetworkData");
491 return ipmi::ccReqDataLenInvalid;
492 }
493 std::copy(msgPayloadStartingPos + prefixOffset,
494 (msgPayloadStartingPos + prefixOffset +
495 sizeof(decltype(prefix))),
496 &prefix);
Ratan Guptadcb10672017-07-10 10:33:50 +0530497
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530498 uint8_t gatewayOffset = prefixOffset + sizeof(decltype(prefix));
Ratan Gupta8c31d232017-08-13 05:49:43 +0530499 if (addrSize != ipmi::network::IPV4_ADDRESS_SIZE_BYTE)
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530500 {
501 addressType = "xyz.openbmc_project.Network.IP.Protocol.IPv6";
502 family = AF_INET6;
503 }
504
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000505 if (msgLen < ipAddrOffset + addrSize)
506 {
507 log<level::ERR>(
508 "Error in IP address getting of setHostNetworkData");
509 return ipmi::ccReqDataLenInvalid;
510 }
511 ipAddress = getAddrStr(family, msgPayloadStartingPos, ipAddrOffset,
512 addrSize);
Ratan Guptad70f4532017-08-04 02:07:31 +0530513
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000514 if (msgLen < gatewayOffset + addrSize)
515 {
516 log<level::ERR>(
517 "Error in gateway address getting of setHostNetworkData");
518 return ipmi::ccReqDataLenInvalid;
519 }
520 gateway = getAddrStr(family, msgPayloadStartingPos, gatewayOffset,
521 addrSize);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530522
Patrick Venture0b02be92018-08-31 11:55:55 -0700523 } while (0);
Ratan Guptadcb10672017-07-10 10:33:50 +0530524
Patrick Venture0b02be92018-08-31 11:55:55 -0700525 // Cookie == 0 or it is a valid cookie
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000526 hostNetworkConfig += "ipaddress="s + ipAddress + ",prefix="s +
527 std::to_string(prefix) + ",gateway="s + gateway +
528 ",mac="s + mac + ",addressOrigin="s +
529 addressOrigin;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500530
Patrick Williams5d82f472022-07-22 19:26:53 -0500531 sdbusplus::bus_t bus(ipmid_get_sd_bus_connection());
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530532
533 auto ipObjectInfo = ipmi::getDbusObject(bus, IP_INTERFACE,
534 SETTINGS_ROOT, SETTINGS_MATCH);
535 auto macObjectInfo = ipmi::getDbusObject(bus, MAC_INTERFACE,
536 SETTINGS_ROOT, SETTINGS_MATCH);
Ratan Guptadcb10672017-07-10 10:33:50 +0530537 // set the dbus property
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530538 ipmi::setDbusProperty(bus, ipObjectInfo.second, ipObjectInfo.first,
Patrick Venture0b02be92018-08-31 11:55:55 -0700539 IP_INTERFACE, "Address", std::string(ipAddress));
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530540 ipmi::setDbusProperty(bus, ipObjectInfo.second, ipObjectInfo.first,
Patrick Venture0b02be92018-08-31 11:55:55 -0700541 IP_INTERFACE, "PrefixLength", prefix);
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530542 ipmi::setDbusProperty(bus, ipObjectInfo.second, ipObjectInfo.first,
Patrick Venture0b02be92018-08-31 11:55:55 -0700543 IP_INTERFACE, "Origin", addressOrigin);
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530544 ipmi::setDbusProperty(bus, ipObjectInfo.second, ipObjectInfo.first,
Patrick Venture0b02be92018-08-31 11:55:55 -0700545 IP_INTERFACE, "Gateway", std::string(gateway));
546 ipmi::setDbusProperty(
547 bus, ipObjectInfo.second, ipObjectInfo.first, IP_INTERFACE, "Type",
548 std::string("xyz.openbmc_project.Network.IP.Protocol.IPv4"));
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530549 ipmi::setDbusProperty(bus, macObjectInfo.second, macObjectInfo.first,
Patrick Venture0b02be92018-08-31 11:55:55 -0700550 MAC_INTERFACE, "MACAddress", std::string(mac));
Ratan Guptafd28dd72016-08-01 04:58:01 -0500551
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000552 log<level::DEBUG>("Network configuration changed",
553 entry("NETWORKCONFIG=%s", hostNetworkConfig.c_str()));
Ratan Guptafd28dd72016-08-01 04:58:01 -0500554 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -0500555 catch (const sdbusplus::exception_t& e)
Ratan Guptadcb10672017-07-10 10:33:50 +0530556 {
557 commit<InternalFailure>();
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000558 log<level::ERR>("Error in ipmiChassisSetSysBootOptions call");
559 return ipmi::ccUnspecifiedError;
Ratan Guptadcb10672017-07-10 10:33:50 +0530560 }
561
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000562 return ipmi::ccSuccess;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500563}
564
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500565uint32_t getPOHCounter()
566{
Patrick Williams5d82f472022-07-22 19:26:53 -0500567 sdbusplus::bus_t bus{ipmid_get_sd_bus_connection()};
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500568
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -0500569 auto chassisStateObj = ipmi::getDbusObject(bus, chassisPOHStateIntf,
570 chassisStateRoot, match);
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500571
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -0500572 auto service = ipmi::getService(bus, chassisPOHStateIntf,
573 chassisStateObj.first);
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500574
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -0500575 auto propValue = ipmi::getDbusProperty(bus, service, chassisStateObj.first,
576 chassisPOHStateIntf,
577 pohCounterProperty);
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500578
Vernon Maueryf442e112019-04-09 11:44:36 -0700579 return std::get<uint32_t>(propValue);
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500580}
581
anil kumar appana43263c62019-05-27 12:45:04 +0000582/** @brief Implements the get chassis capabilities command
583 *
584 * @returns IPMI completion code plus response data
585 * chassisCapFlags - chassis capability flag
586 * chassisFRUInfoDevAddr - chassis FRU info Device Address
587 * chassisSDRDevAddr - chassis SDR device address
588 * chassisSELDevAddr - chassis SEL device address
589 * chassisSMDevAddr - chassis system management device address
590 * chassisBridgeDevAddr - chassis bridge device address
591 */
Karthick Sundarrajan86d8bd72019-11-26 12:48:50 -0800592ipmi::RspType<bool, // chassis intrusion sensor
593 bool, // chassis Front panel lockout
594 bool, // chassis NMI
595 bool, // chassis power interlock
596 uint4_t, // reserved
anil kumar appana43263c62019-05-27 12:45:04 +0000597 uint8_t, // chassis FRU info Device Address
598 uint8_t, // chassis SDR device address
599 uint8_t, // chassis SEL device address
600 uint8_t, // chassis system management device address
601 uint8_t // chassis bridge device address
602 >
603 ipmiGetChassisCap()
Nan Li8d15fb42016-08-16 22:29:40 +0800604{
anil kumar appana43263c62019-05-27 12:45:04 +0000605 ipmi::PropertyMap properties;
Yong Liae4b0402018-11-02 11:12:14 +0800606 try
607 {
Patrick Williams5d82f472022-07-22 19:26:53 -0500608 sdbusplus::bus_t bus{ipmid_get_sd_bus_connection()};
Nan Li8d15fb42016-08-16 22:29:40 +0800609
Yong Liae4b0402018-11-02 11:12:14 +0800610 ipmi::DbusObjectInfo chassisCapObject =
611 ipmi::getDbusObject(bus, chassisCapIntf);
Nan Li8d15fb42016-08-16 22:29:40 +0800612
Yong Liae4b0402018-11-02 11:12:14 +0800613 // capabilities flags
614 // [7..4] - reserved
615 // [3] – 1b = provides power interlock (IPM 1.5)
616 // [2] – 1b = provides Diagnostic Interrupt (FP NMI)
617 // [1] – 1b = provides “Front Panel Lockout” (indicates that the chassis
618 // has capabilities
619 // to lock out external power control and reset button or
620 // front panel interfaces and/or detect tampering with those
621 // interfaces).
622 // [0] -1b = Chassis provides intrusion (physical security) sensor.
623 // set to default value 0x0.
Nan Li8d15fb42016-08-16 22:29:40 +0800624
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -0500625 properties = ipmi::getAllDbusProperties(bus, chassisCapObject.second,
626 chassisCapObject.first,
627 chassisCapIntf);
Yong Liae4b0402018-11-02 11:12:14 +0800628 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -0500629 catch (const std::exception& e)
Yong Liae4b0402018-11-02 11:12:14 +0800630 {
anil kumar appana43263c62019-05-27 12:45:04 +0000631 log<level::ERR>("Failed to fetch Chassis Capability properties",
632 entry("ERROR=%s", e.what()));
633 return ipmi::responseUnspecifiedError();
Yong Liae4b0402018-11-02 11:12:14 +0800634 }
635
Karthick Sundarrajan86d8bd72019-11-26 12:48:50 -0800636 bool* chassisIntrusionFlag =
637 std::get_if<bool>(&properties[chassisIntrusionProp]);
638 if (chassisIntrusionFlag == nullptr)
anil kumar appana43263c62019-05-27 12:45:04 +0000639 {
Karthick Sundarrajan86d8bd72019-11-26 12:48:50 -0800640 log<level::ERR>("Error to get chassis Intrusion flags");
641 return ipmi::responseUnspecifiedError();
642 }
643 bool* chassisFrontPanelFlag =
644 std::get_if<bool>(&properties[chassisFrontPanelLockoutProp]);
645 if (chassisFrontPanelFlag == nullptr)
646 {
647 log<level::ERR>("Error to get chassis intrusion flags");
648 return ipmi::responseUnspecifiedError();
649 }
650 bool* chassisNMIFlag = std::get_if<bool>(&properties[chassisNMIProp]);
651 if (chassisNMIFlag == nullptr)
652 {
653 log<level::ERR>("Error to get chassis NMI flags");
654 return ipmi::responseUnspecifiedError();
655 }
656 bool* chassisPowerInterlockFlag =
657 std::get_if<bool>(&properties[chassisPowerInterlockProp]);
658 if (chassisPowerInterlockFlag == nullptr)
659 {
660 log<level::ERR>("Error to get chassis power interlock flags");
anil kumar appana43263c62019-05-27 12:45:04 +0000661 return ipmi::responseUnspecifiedError();
662 }
663 uint8_t* chassisFRUInfoDevAddr =
664 std::get_if<uint8_t>(&properties[chassisFRUDevAddrProp]);
665 if (chassisFRUInfoDevAddr == nullptr)
666 {
667 log<level::ERR>("Error to get chassis FRU info device address");
668 return ipmi::responseUnspecifiedError();
669 }
670 uint8_t* chassisSDRDevAddr =
671 std::get_if<uint8_t>(&properties[chassisSDRDevAddrProp]);
672 if (chassisSDRDevAddr == nullptr)
673 {
674 log<level::ERR>("Error to get chassis SDR device address");
675 return ipmi::responseUnspecifiedError();
676 }
677 uint8_t* chassisSELDevAddr =
678 std::get_if<uint8_t>(&properties[chassisSELDevAddrProp]);
679 if (chassisSELDevAddr == nullptr)
680 {
681 log<level::ERR>("Error to get chassis SEL device address");
682 return ipmi::responseUnspecifiedError();
683 }
684 uint8_t* chassisSMDevAddr =
685 std::get_if<uint8_t>(&properties[chassisSMDevAddrProp]);
686 if (chassisSMDevAddr == nullptr)
687 {
688 log<level::ERR>("Error to get chassis SM device address");
689 return ipmi::responseUnspecifiedError();
690 }
691 uint8_t* chassisBridgeDevAddr =
692 std::get_if<uint8_t>(&properties[chassisBridgeDevAddrProp]);
693 if (chassisBridgeDevAddr == nullptr)
694 {
695 log<level::ERR>("Error to get chassis bridge device address");
696 return ipmi::responseUnspecifiedError();
697 }
698
Karthick Sundarrajan86d8bd72019-11-26 12:48:50 -0800699 return ipmi::responseSuccess(*chassisIntrusionFlag, *chassisFrontPanelFlag,
700 *chassisNMIFlag, *chassisPowerInterlockFlag, 0,
701 *chassisFRUInfoDevAddr, *chassisSDRDevAddr,
702 *chassisSELDevAddr, *chassisSMDevAddr,
703 *chassisBridgeDevAddr);
Yong Liae4b0402018-11-02 11:12:14 +0800704}
705
anil kumar appana894d0222019-05-27 16:32:14 +0000706/** @brief implements set chassis capalibities command
707 * @param intrusion - chassis intrusion
708 * @param fpLockout - frontpannel lockout
709 * @param reserved1 - skip one bit
710 * @param fruDeviceAddr - chassis FRU info Device Address
711 * @param sdrDeviceAddr - chassis SDR device address
712 * @param selDeviceAddr - chassis SEL device address
713 * @param smDeviceAddr - chassis system management device address
714 * @param bridgeDeviceAddr - chassis bridge device address
715 *
716 * @returns IPMI completion code
717 */
718ipmi::RspType<> ipmiSetChassisCap(bool intrusion, bool fpLockout,
719 uint6_t reserved1,
720
721 uint8_t fruDeviceAddr,
722
723 uint8_t sdrDeviceAddr,
724
725 uint8_t selDeviceAddr,
726
727 uint8_t smDeviceAddr,
728
729 uint8_t bridgeDeviceAddr)
Yong Liae4b0402018-11-02 11:12:14 +0800730{
Yong Liae4b0402018-11-02 11:12:14 +0800731 // check input data
anil kumar appana894d0222019-05-27 16:32:14 +0000732 if (reserved1 != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800733 {
anil kumar appana894d0222019-05-27 16:32:14 +0000734 log<level::ERR>("Unsupported request parameter");
735 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800736 }
737
anil kumar appana894d0222019-05-27 16:32:14 +0000738 if ((fruDeviceAddr & ~chassisCapAddrMask) != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800739 {
740 log<level::ERR>("Unsupported request parameter(FRU Addr)",
anil kumar appana894d0222019-05-27 16:32:14 +0000741 entry("REQ=0x%x", fruDeviceAddr));
742 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800743 }
anil kumar appana894d0222019-05-27 16:32:14 +0000744 if ((sdrDeviceAddr & ~chassisCapAddrMask) != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800745 {
746 log<level::ERR>("Unsupported request parameter(SDR Addr)",
anil kumar appana894d0222019-05-27 16:32:14 +0000747 entry("REQ=0x%x", sdrDeviceAddr));
748 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800749 }
750
anil kumar appana894d0222019-05-27 16:32:14 +0000751 if ((selDeviceAddr & ~chassisCapAddrMask) != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800752 {
753 log<level::ERR>("Unsupported request parameter(SEL Addr)",
anil kumar appana894d0222019-05-27 16:32:14 +0000754 entry("REQ=0x%x", selDeviceAddr));
755 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800756 }
757
anil kumar appana894d0222019-05-27 16:32:14 +0000758 if ((smDeviceAddr & ~chassisCapAddrMask) != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800759 {
anil kumar appana894d0222019-05-27 16:32:14 +0000760 log<level::ERR>("Unsupported request parameter(SM Addr)",
761 entry("REQ=0x%x", smDeviceAddr));
762 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800763 }
764
anil kumar appana894d0222019-05-27 16:32:14 +0000765 if ((bridgeDeviceAddr & ~chassisCapAddrMask) != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800766 {
767 log<level::ERR>("Unsupported request parameter(Bridge Addr)",
anil kumar appana894d0222019-05-27 16:32:14 +0000768 entry("REQ=0x%x", bridgeDeviceAddr));
769 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800770 }
771
772 try
773 {
Patrick Williams5d82f472022-07-22 19:26:53 -0500774 sdbusplus::bus_t bus(ipmid_get_sd_bus_connection());
Yong Liae4b0402018-11-02 11:12:14 +0800775 ipmi::DbusObjectInfo chassisCapObject =
776 ipmi::getDbusObject(bus, chassisCapIntf);
777
778 ipmi::setDbusProperty(bus, chassisCapObject.second,
779 chassisCapObject.first, chassisCapIntf,
Karthick Sundarrajan86d8bd72019-11-26 12:48:50 -0800780 chassisIntrusionProp, intrusion);
781
782 ipmi::setDbusProperty(bus, chassisCapObject.second,
783 chassisCapObject.first, chassisCapIntf,
784 chassisFrontPanelLockoutProp, fpLockout);
Yong Liae4b0402018-11-02 11:12:14 +0800785
786 ipmi::setDbusProperty(bus, chassisCapObject.second,
787 chassisCapObject.first, chassisCapIntf,
anil kumar appana894d0222019-05-27 16:32:14 +0000788 chassisFRUDevAddrProp, fruDeviceAddr);
Yong Liae4b0402018-11-02 11:12:14 +0800789
790 ipmi::setDbusProperty(bus, chassisCapObject.second,
791 chassisCapObject.first, chassisCapIntf,
anil kumar appana894d0222019-05-27 16:32:14 +0000792 chassisSDRDevAddrProp, sdrDeviceAddr);
Yong Liae4b0402018-11-02 11:12:14 +0800793
794 ipmi::setDbusProperty(bus, chassisCapObject.second,
795 chassisCapObject.first, chassisCapIntf,
anil kumar appana894d0222019-05-27 16:32:14 +0000796 chassisSELDevAddrProp, selDeviceAddr);
Yong Liae4b0402018-11-02 11:12:14 +0800797
798 ipmi::setDbusProperty(bus, chassisCapObject.second,
799 chassisCapObject.first, chassisCapIntf,
anil kumar appana894d0222019-05-27 16:32:14 +0000800 chassisSMDevAddrProp, smDeviceAddr);
Yong Liae4b0402018-11-02 11:12:14 +0800801
802 ipmi::setDbusProperty(bus, chassisCapObject.second,
803 chassisCapObject.first, chassisCapIntf,
anil kumar appana894d0222019-05-27 16:32:14 +0000804 chassisBridgeDevAddrProp, bridgeDeviceAddr);
Yong Liae4b0402018-11-02 11:12:14 +0800805 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -0500806 catch (const std::exception& e)
Yong Liae4b0402018-11-02 11:12:14 +0800807 {
808 log<level::ERR>(e.what());
anil kumar appana894d0222019-05-27 16:32:14 +0000809 return ipmi::responseUnspecifiedError();
Yong Liae4b0402018-11-02 11:12:14 +0800810 }
anil kumar appana894d0222019-05-27 16:32:14 +0000811 return ipmi::responseSuccess();
Nan Li8d15fb42016-08-16 22:29:40 +0800812}
813
Vishwanatha Subbannab12b0c02017-03-07 18:17:19 +0530814//------------------------------------------
815// Calls into Host State Manager Dbus object
816//------------------------------------------
Jason M. Bills664e1c32020-01-30 16:02:39 -0800817int initiateHostStateTransition(ipmi::Context::ptr& ctx,
818 State::Host::Transition transition)
vishwa36993272015-11-20 12:43:49 -0600819{
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500820 // OpenBMC Host State Manager dbus framework
Jason M. Bills664e1c32020-01-30 16:02:39 -0800821 constexpr auto hostStatePath = "/xyz/openbmc_project/state/host0";
822 constexpr auto hostStateIntf = "xyz.openbmc_project.State.Host";
Vishwanatha Subbannab12b0c02017-03-07 18:17:19 +0530823
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500824 // Convert to string equivalent of the passed in transition enum.
825 auto request = State::convertForMessage(transition);
Vishwanatha Subbannab12b0c02017-03-07 18:17:19 +0530826
Jason M. Bills664e1c32020-01-30 16:02:39 -0800827 std::string service;
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -0500828 boost::system::error_code ec = ipmi::getService(ctx, hostStateIntf,
829 hostStatePath, service);
Jason M. Bills664e1c32020-01-30 16:02:39 -0800830
831 if (!ec)
832 {
833 ec = ipmi::setDbusProperty(ctx, service, hostStatePath, hostStateIntf,
834 "RequestedHostTransition", request);
835 }
836 if (ec)
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500837 {
838 log<level::ERR>("Failed to initiate transition",
Jason M. Bills664e1c32020-01-30 16:02:39 -0800839 entry("EXCEPTION=%s, REQUEST=%s", ec.message().c_str(),
840 request.c_str()));
841 return -1;
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500842 }
Jason M. Bills664e1c32020-01-30 16:02:39 -0800843 log<level::INFO>(
844 "Transition request initiated successfully",
845 entry("USERID=%d, REQUEST=%s", ctx->userId, request.c_str()));
846 return 0;
vishwa36993272015-11-20 12:43:49 -0600847}
848
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +0800849//------------------------------------------
Jason M. Billsad588bf2020-01-30 16:18:33 -0800850// Calls into Chassis State Manager Dbus object
851//------------------------------------------
852int initiateChassisStateTransition(ipmi::Context::ptr& ctx,
853 State::Chassis::Transition transition)
854{
855 // OpenBMC Chassis State Manager dbus framework
856 constexpr auto chassisStatePath = "/xyz/openbmc_project/state/chassis0";
857 constexpr auto chassisStateIntf = "xyz.openbmc_project.State.Chassis";
858
859 std::string service;
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -0500860 boost::system::error_code ec = ipmi::getService(ctx, chassisStateIntf,
861 chassisStatePath, service);
Jason M. Billsad588bf2020-01-30 16:18:33 -0800862
863 // Convert to string equivalent of the passed in transition enum.
864 auto request = State::convertForMessage(transition);
865
866 if (!ec)
867 {
868 ec = ipmi::setDbusProperty(ctx, service, chassisStatePath,
869 chassisStateIntf, "RequestedPowerTransition",
870 request);
871 }
872 if (ec)
873 {
874 log<level::ERR>("Failed to initiate transition",
875 entry("EXCEPTION=%s, REQUEST=%s", ec.message().c_str(),
876 request.c_str()));
877 return -1;
878 }
879
880 return 0;
881}
882
883//------------------------------------------
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +0800884// Set Enabled property to inform NMI source
885// handling to trigger a NMI_OUT BSOD.
886//------------------------------------------
Vernon Mauery9bb4a382021-11-05 12:46:19 -0700887int setNmiProperty(ipmi::Context::ptr& ctx, const bool value)
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +0800888{
889 constexpr const char* nmiSourceObjPath =
890 "/xyz/openbmc_project/Chassis/Control/NMISource";
891 constexpr const char* nmiSourceIntf =
892 "xyz.openbmc_project.Chassis.Control.NMISource";
893 std::string bmcSourceSignal = "xyz.openbmc_project.Chassis.Control."
894 "NMISource.BMCSourceSignal.ChassisCmd";
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +0800895
Vernon Mauery9bb4a382021-11-05 12:46:19 -0700896 std::string service;
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -0500897 boost::system::error_code ec = ipmi::getService(ctx, nmiSourceIntf,
898 nmiSourceObjPath, service);
Vernon Mauery9bb4a382021-11-05 12:46:19 -0700899 if (!ec)
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +0800900 {
Vernon Mauery9bb4a382021-11-05 12:46:19 -0700901 ec = ipmi::setDbusProperty(ctx, service, nmiSourceObjPath,
902 nmiSourceIntf, "BMCSource", bmcSourceSignal);
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +0800903 }
Vernon Mauery9bb4a382021-11-05 12:46:19 -0700904 if (!ec)
905 {
906 ec = ipmi::setDbusProperty(ctx, service, nmiSourceObjPath,
907 nmiSourceIntf, "Enabled", value);
908 }
909 if (ec)
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +0800910 {
911 log<level::ERR>("Failed to trigger NMI_OUT",
Vernon Mauery9bb4a382021-11-05 12:46:19 -0700912 entry("EXCEPTION=%s", ec.message().c_str()));
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +0800913 return -1;
914 }
915
916 return 0;
917}
918
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500919namespace power_policy
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500920{
Nan Lifdd8ec52016-08-28 03:57:40 +0800921
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500922using namespace sdbusplus::xyz::openbmc_project::Control::Power::server;
923using IpmiValue = uint8_t;
924using DbusValue = RestorePolicy::Policy;
Nan Lifdd8ec52016-08-28 03:57:40 +0800925
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700926const std::map<DbusValue, IpmiValue> dbusToIpmi = {
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500927 {RestorePolicy::Policy::AlwaysOff, 0x00},
928 {RestorePolicy::Policy::Restore, 0x01},
Patrick Venture0b02be92018-08-31 11:55:55 -0700929 {RestorePolicy::Policy::AlwaysOn, 0x02}};
Nan Lifdd8ec52016-08-28 03:57:40 +0800930
Yong Lic6713cf2018-09-12 12:35:13 +0800931static constexpr uint8_t noChange = 0x03;
932static constexpr uint8_t allSupport = 0x01 | 0x02 | 0x04;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700933
934/* helper function for Get Chassis Status Command
935 */
936std::optional<uint2_t> getPowerRestorePolicy()
937{
938 uint2_t restorePolicy = 0;
939 using namespace chassis::internal;
940
James Feist225dec82019-11-26 16:25:06 -0800941 settings::Objects& objects = cache::getObjects();
942
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700943 try
944 {
945 const auto& powerRestoreSetting =
James Feist225dec82019-11-26 16:25:06 -0800946 objects.map.at(powerRestoreIntf).front();
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700947 ipmi::Value result = ipmi::getDbusProperty(
948 *getSdBus(),
James Feist225dec82019-11-26 16:25:06 -0800949 objects.service(powerRestoreSetting, powerRestoreIntf).c_str(),
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700950 powerRestoreSetting.c_str(), powerRestoreIntf,
951 "PowerRestorePolicy");
952 auto powerRestore = RestorePolicy::convertPolicyFromString(
953 std::get<std::string>(result));
954 restorePolicy = dbusToIpmi.at(powerRestore);
955 }
956 catch (const std::exception& e)
957 {
958 log<level::ERR>(
959 "Failed to fetch pgood property", entry("ERROR=%s", e.what()),
James Feist225dec82019-11-26 16:25:06 -0800960 entry("PATH=%s", objects.map.at(powerRestoreIntf).front().c_str()),
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700961 entry("INTERFACE=%s", powerRestoreIntf));
James Feist225dec82019-11-26 16:25:06 -0800962 cache::objectsPtr.reset();
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700963 return std::nullopt;
964 }
965 return std::make_optional(restorePolicy);
966}
967
968/*
969 * getPowerStatus
970 * helper function for Get Chassis Status Command
971 * return - optional value for pgood (no value on error)
972 */
973std::optional<bool> getPowerStatus()
974{
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700975 bool powerGood = false;
976 std::shared_ptr<sdbusplus::asio::connection> busp = getSdBus();
977 try
978 {
Jason M. Bills3de424c2019-05-21 09:57:16 -0700979 constexpr const char* chassisStatePath =
980 "/xyz/openbmc_project/state/chassis0";
981 constexpr const char* chassisStateIntf =
982 "xyz.openbmc_project.State.Chassis";
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -0500983 auto service = ipmi::getService(*busp, chassisStateIntf,
984 chassisStatePath);
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700985
Jason M. Bills3de424c2019-05-21 09:57:16 -0700986 ipmi::Value powerState =
987 ipmi::getDbusProperty(*busp, service, chassisStatePath,
988 chassisStateIntf, "CurrentPowerState");
989 powerGood = std::get<std::string>(powerState) ==
990 "xyz.openbmc_project.State.Chassis.PowerState.On";
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700991 }
992 catch (const std::exception& e)
993 {
994 try
995 {
996 // FIXME: some legacy modules use the older path; try that next
997 constexpr const char* legacyPwrCtrlObj =
998 "/org/openbmc/control/power0";
999 constexpr const char* legacyPwrCtrlIntf =
1000 "org.openbmc.control.Power";
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05001001 auto service = ipmi::getService(*busp, legacyPwrCtrlIntf,
1002 legacyPwrCtrlObj);
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001003
1004 ipmi::Value variant = ipmi::getDbusProperty(
1005 *busp, service, legacyPwrCtrlObj, legacyPwrCtrlIntf, "pgood");
1006 powerGood = static_cast<bool>(std::get<int>(variant));
1007 }
1008 catch (const std::exception& e)
1009 {
1010 log<level::ERR>("Failed to fetch pgood property",
Jason M. Bills3de424c2019-05-21 09:57:16 -07001011 entry("ERROR=%s", e.what()));
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001012 return std::nullopt;
1013 }
1014 }
1015 return std::make_optional(powerGood);
1016}
1017
Yong Li70ce7352019-05-16 21:15:27 +08001018/*
1019 * getACFailStatus
1020 * helper function for Get Chassis Status Command
1021 * return - bool value for ACFail (false on error)
1022 */
1023bool getACFailStatus()
1024{
1025 constexpr const char* powerControlObj =
1026 "/xyz/openbmc_project/Chassis/Control/Power0";
1027 constexpr const char* powerControlIntf =
1028 "xyz.openbmc_project.Chassis.Control.Power";
1029 bool acFail = false;
1030 std::shared_ptr<sdbusplus::asio::connection> bus = getSdBus();
1031 try
1032 {
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05001033 auto service = ipmi::getService(*bus, powerControlIntf,
1034 powerControlObj);
Yong Li70ce7352019-05-16 21:15:27 +08001035
1036 ipmi::Value variant = ipmi::getDbusProperty(
1037 *bus, service, powerControlObj, powerControlIntf, "PFail");
1038 acFail = std::get<bool>(variant);
1039 }
1040 catch (const std::exception& e)
1041 {
1042 log<level::ERR>("Failed to fetch PFail property",
1043 entry("ERROR=%s", e.what()),
1044 entry("PATH=%s", powerControlObj),
1045 entry("INTERFACE=%s", powerControlIntf));
1046 }
1047 return acFail;
1048}
Deepak Kodihalli18b70d12017-07-21 13:36:33 -05001049} // namespace power_policy
Nan Lifdd8ec52016-08-28 03:57:40 +08001050
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001051static std::optional<bool> getButtonEnabled(const std::string& buttonPath,
1052 const std::string& buttonIntf)
1053{
1054 std::shared_ptr<sdbusplus::asio::connection> busp = getSdBus();
1055 bool buttonDisabled = false;
1056 try
1057 {
1058 auto service = ipmi::getService(*busp, buttonIntf, buttonPath);
1059 ipmi::Value enabled = ipmi::getDbusProperty(*busp, service, buttonPath,
1060 buttonIntf, "Enabled");
1061 buttonDisabled = !std::get<bool>(enabled);
1062 }
Patrick Williams5d82f472022-07-22 19:26:53 -05001063 catch (const sdbusplus::exception_t& e)
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001064 {
1065 log<level::ERR>("Fail to get button Enabled property",
1066 entry("PATH=%s", buttonPath.c_str()),
1067 entry("ERROR=%s", e.what()));
1068 return std::nullopt;
1069 }
1070 return std::make_optional(buttonDisabled);
1071}
1072
Kuiying Wang21addc52019-01-04 10:50:21 +08001073static bool setButtonEnabled(ipmi::Context::ptr& ctx,
1074 const std::string& buttonPath,
1075 const std::string& buttonIntf, bool enable)
1076{
1077 std::string service;
1078 boost::system::error_code ec;
1079 ec = ipmi::getService(ctx, buttonIntf, buttonPath, service);
1080 if (!ec)
1081 {
1082 ec = ipmi::setDbusProperty(ctx, service, buttonPath, buttonIntf,
1083 "Enabled", enable);
1084 }
1085 if (ec)
1086 {
1087 log<level::ERR>("Fail to set button Enabled property",
1088 entry("SERVICE=%s", service.c_str()),
1089 entry("PATH=%s", buttonPath.c_str()),
1090 entry("ERROR=%s", ec.message().c_str()));
1091 return false;
1092 }
1093 return true;
1094}
1095
Chau Ly9e666cd2023-03-06 08:46:14 +00001096static std::optional<bool> getChassisIntrusionStatus(ipmi::Context::ptr& ctx)
1097{
1098 constexpr const char* chassisIntrusionPath =
1099 "/xyz/openbmc_project/Chassis/Intrusion";
1100 constexpr const char* chassisIntrusionInf =
1101 "xyz.openbmc_project.Chassis.Intrusion";
1102
1103 std::string service;
1104 boost::system::error_code ec = ipmi::getService(
1105 ctx, chassisIntrusionInf, chassisIntrusionPath, service);
1106 if (!ec)
1107 {
1108 std::string chassisIntrusionStr;
1109 ec = ipmi::getDbusProperty<std::string>(
1110 ctx, service, chassisIntrusionPath, chassisIntrusionInf, "Status",
1111 chassisIntrusionStr);
1112 if (!ec)
1113 {
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05001114 bool ret = (chassisIntrusionStr == "HardwareIntrusion") ? true
1115 : false;
Chau Ly9e666cd2023-03-06 08:46:14 +00001116 return std::make_optional(ret);
1117 }
1118 }
1119 log<level::ERR>("Fail to get Chassis Intrusion Status property",
1120 entry("PATH=%s", chassisIntrusionPath),
1121 entry("INTERFACE=%s", chassisIntrusionInf),
1122 entry("ERROR=%s", ec.message().c_str()));
1123 return std::nullopt;
1124}
1125
Nan Lifdd8ec52016-08-28 03:57:40 +08001126//----------------------------------------------------------------------
1127// Get Chassis Status commands
1128//----------------------------------------------------------------------
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001129ipmi::RspType<bool, // Power is on
1130 bool, // Power overload
1131 bool, // Interlock
1132 bool, // power fault
1133 bool, // power control fault
1134 uint2_t, // power restore policy
1135 bool, // reserved
1136
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05001137 bool, // AC failed
1138 bool, // last power down caused by a Power overload
1139 bool, // last power down caused by a power interlock
1140 bool, // last power down caused by power fault
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001141 bool, // last ‘Power is on’ state was entered via IPMI command
1142 uint3_t, // reserved
1143
1144 bool, // Chassis intrusion active
1145 bool, // Front Panel Lockout active
1146 bool, // Drive Fault
1147 bool, // Cooling/fan fault detected
1148 uint2_t, // Chassis Identify State
1149 bool, // Chassis Identify command and state info supported
1150 bool, // reserved
1151
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05001152 bool, // Power off button disabled
1153 bool, // Reset button disabled
1154 bool, // Diagnostic Interrupt button disabled
1155 bool, // Standby (sleep) button disabled
1156 bool, // Power off button disable allowed
1157 bool, // Reset button disable allowed
1158 bool, // Diagnostic Interrupt button disable allowed
1159 bool // Standby (sleep) button disable allowed
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001160 >
Chau Ly9e666cd2023-03-06 08:46:14 +00001161 ipmiGetChassisStatus(ipmi::Context::ptr& ctx)
Nan Lifdd8ec52016-08-28 03:57:40 +08001162{
Deepak Kodihalli18b70d12017-07-21 13:36:33 -05001163 using namespace chassis::internal;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001164 std::optional<uint2_t> restorePolicy =
1165 power_policy::getPowerRestorePolicy();
1166 std::optional<bool> powerGood = power_policy::getPowerStatus();
1167 if (!restorePolicy || !powerGood)
Deepak Kodihalli18b70d12017-07-21 13:36:33 -05001168 {
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001169 return ipmi::responseUnspecifiedError();
Deepak Kodihalli18b70d12017-07-21 13:36:33 -05001170 }
Nan Lifdd8ec52016-08-28 03:57:40 +08001171
1172 // Front Panel Button Capabilities and disable/enable status(Optional)
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05001173 std::optional<bool> powerButtonReading = getButtonEnabled(powerButtonPath,
1174 powerButtonIntf);
Vernon Mauery6d5b2f72019-05-16 14:48:47 -07001175 // allow disable if the interface is present
1176 bool powerButtonDisableAllow = static_cast<bool>(powerButtonReading);
1177 // default return the button is enabled (not disabled)
1178 bool powerButtonDisabled = false;
1179 if (powerButtonDisableAllow)
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001180 {
Vernon Mauery6d5b2f72019-05-16 14:48:47 -07001181 // return the real value of the button status, if present
1182 powerButtonDisabled = *powerButtonReading;
1183 }
1184
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05001185 std::optional<bool> resetButtonReading = getButtonEnabled(resetButtonPath,
1186 resetButtonIntf);
Vernon Mauery6d5b2f72019-05-16 14:48:47 -07001187 // allow disable if the interface is present
1188 bool resetButtonDisableAllow = static_cast<bool>(resetButtonReading);
1189 // default return the button is enabled (not disabled)
1190 bool resetButtonDisabled = false;
1191 if (resetButtonDisableAllow)
1192 {
1193 // return the real value of the button status, if present
1194 resetButtonDisabled = *resetButtonReading;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001195 }
Nan Lifdd8ec52016-08-28 03:57:40 +08001196
Yong Li70ce7352019-05-16 21:15:27 +08001197 bool powerDownAcFailed = power_policy::getACFailStatus();
1198
Chau Ly9e666cd2023-03-06 08:46:14 +00001199 bool chassisIntrusionActive = false;
1200 std::optional<bool> chassisIntrusionStatus = getChassisIntrusionStatus(ctx);
1201 if (chassisIntrusionStatus)
1202 {
1203 chassisIntrusionActive = chassisIntrusionStatus.value();
1204 }
1205
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001206 // This response has a lot of hard-coded, unsupported fields
1207 // They are set to false or 0
1208 constexpr bool powerOverload = false;
1209 constexpr bool chassisInterlock = false;
1210 constexpr bool powerFault = false;
1211 constexpr bool powerControlFault = false;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001212 constexpr bool powerDownOverload = false;
1213 constexpr bool powerDownInterlock = false;
1214 constexpr bool powerDownPowerFault = false;
1215 constexpr bool powerStatusIPMI = false;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001216 constexpr bool frontPanelLockoutActive = false;
1217 constexpr bool driveFault = false;
1218 constexpr bool coolingFanFault = false;
1219 // chassisIdentifySupport set because this command is implemented
1220 constexpr bool chassisIdentifySupport = true;
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001221 uint2_t chassisIdentifyState = types::enum_cast<uint2_t>(chassisIDState);
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001222 constexpr bool diagButtonDisabled = false;
1223 constexpr bool sleepButtonDisabled = false;
1224 constexpr bool diagButtonDisableAllow = false;
1225 constexpr bool sleepButtonDisableAllow = false;
1226
1227 return ipmi::responseSuccess(
1228 *powerGood, powerOverload, chassisInterlock, powerFault,
1229 powerControlFault, *restorePolicy,
1230 false, // reserved
1231
1232 powerDownAcFailed, powerDownOverload, powerDownInterlock,
1233 powerDownPowerFault, powerStatusIPMI,
1234 uint3_t(0), // reserved
1235
1236 chassisIntrusionActive, frontPanelLockoutActive, driveFault,
1237 coolingFanFault, chassisIdentifyState, chassisIdentifySupport,
1238 false, // reserved
1239
Vernon Mauery6d5b2f72019-05-16 14:48:47 -07001240 powerButtonDisabled, resetButtonDisabled, diagButtonDisabled,
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001241 sleepButtonDisabled, powerButtonDisableAllow, resetButtonDisableAllow,
1242 diagButtonDisableAllow, sleepButtonDisableAllow);
Nan Lifdd8ec52016-08-28 03:57:40 +08001243}
Chris Austen7888c4d2015-12-03 15:26:20 -06001244
Vijay Khemka074f64d2020-03-03 15:08:43 -08001245enum class IpmiRestartCause
1246{
1247 Unknown = 0x0,
1248 RemoteCommand = 0x1,
1249 ResetButton = 0x2,
1250 PowerButton = 0x3,
1251 WatchdogTimer = 0x4,
1252 PowerPolicyAlwaysOn = 0x6,
1253 PowerPolicyPreviousState = 0x7,
1254 SoftReset = 0xa,
1255};
1256
1257static IpmiRestartCause
1258 restartCauseToIpmiRestartCause(State::Host::RestartCause cause)
1259{
1260 switch (cause)
1261 {
1262 case State::Host::RestartCause::Unknown:
1263 {
1264 return IpmiRestartCause::Unknown;
1265 }
1266 case State::Host::RestartCause::RemoteCommand:
1267 {
1268 return IpmiRestartCause::RemoteCommand;
1269 }
1270 case State::Host::RestartCause::ResetButton:
1271 {
1272 return IpmiRestartCause::ResetButton;
1273 }
1274 case State::Host::RestartCause::PowerButton:
1275 {
1276 return IpmiRestartCause::PowerButton;
1277 }
1278 case State::Host::RestartCause::WatchdogTimer:
1279 {
1280 return IpmiRestartCause::WatchdogTimer;
1281 }
1282 case State::Host::RestartCause::PowerPolicyAlwaysOn:
1283 {
1284 return IpmiRestartCause::PowerPolicyAlwaysOn;
1285 }
1286 case State::Host::RestartCause::PowerPolicyPreviousState:
1287 {
1288 return IpmiRestartCause::PowerPolicyPreviousState;
1289 }
1290 case State::Host::RestartCause::SoftReset:
1291 {
1292 return IpmiRestartCause::SoftReset;
1293 }
1294 default:
1295 {
1296 return IpmiRestartCause::Unknown;
1297 }
1298 }
1299}
1300
1301/*
1302 * getRestartCause
1303 * helper function for Get Host restart cause Command
1304 * return - optional value for RestartCause (no value on error)
1305 */
1306static std::optional<uint4_t> getRestartCause(ipmi::Context::ptr ctx)
1307{
1308 constexpr const char* restartCausePath =
1309 "/xyz/openbmc_project/control/host0/restart_cause";
1310 constexpr const char* restartCauseIntf =
1311 "xyz.openbmc_project.Control.Host.RestartCause";
1312
1313 std::string service;
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05001314 boost::system::error_code ec = ipmi::getService(ctx, restartCauseIntf,
1315 restartCausePath, service);
Vijay Khemka074f64d2020-03-03 15:08:43 -08001316 if (!ec)
1317 {
1318 std::string restartCauseStr;
1319 ec = ipmi::getDbusProperty<std::string>(
1320 ctx, service, restartCausePath, restartCauseIntf, "RestartCause",
1321 restartCauseStr);
1322 if (!ec)
1323 {
1324 auto cause =
1325 State::Host::convertRestartCauseFromString(restartCauseStr);
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001326 return types::enum_cast<uint4_t>(
1327 restartCauseToIpmiRestartCause(cause));
Vijay Khemka074f64d2020-03-03 15:08:43 -08001328 }
1329 }
1330
1331 log<level::ERR>("Failed to fetch RestartCause property",
1332 entry("ERROR=%s", ec.message().c_str()),
1333 entry("PATH=%s", restartCausePath),
1334 entry("INTERFACE=%s", restartCauseIntf));
1335 return std::nullopt;
1336}
1337
1338ipmi::RspType<uint4_t, // Restart Cause
1339 uint4_t, // reserved
1340 uint8_t // channel number (not supported)
1341 >
1342 ipmiGetSystemRestartCause(ipmi::Context::ptr ctx)
1343{
1344 std::optional<uint4_t> cause = getRestartCause(ctx);
1345 if (!cause)
1346 {
1347 return ipmi::responseUnspecifiedError();
1348 }
1349
Vernon Mauery916d4232021-03-29 13:42:16 -07001350 constexpr uint4_t reserved = 0;
1351 auto channel = static_cast<uint8_t>(ctx->channel);
1352 return ipmi::responseSuccess(cause.value(), reserved, channel);
Vijay Khemka074f64d2020-03-03 15:08:43 -08001353}
anil kumar appanadafff5f2019-04-27 18:06:00 +00001354/** @brief Implementation of chassis control command
1355 *
1356 * @param - chassisControl command byte
1357 *
1358 * @return Success or InvalidFieldRequest.
1359 */
Jason M. Bills664e1c32020-01-30 16:02:39 -08001360ipmi::RspType<> ipmiChassisControl(ipmi::Context::ptr& ctx,
1361 uint8_t chassisControl)
vishwa36993272015-11-20 12:43:49 -06001362{
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001363 int rc = 0;
anil kumar appanadafff5f2019-04-27 18:06:00 +00001364 switch (chassisControl)
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001365 {
1366 case CMD_POWER_ON:
Jason M. Bills664e1c32020-01-30 16:02:39 -08001367 rc = initiateHostStateTransition(ctx, State::Host::Transition::On);
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001368 break;
1369 case CMD_POWER_OFF:
Jason M. Billsc2c3a402020-01-30 16:22:24 -08001370 rc = initiateChassisStateTransition(
1371 ctx, State::Chassis::Transition::Off);
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001372 break;
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001373 case CMD_HARD_RESET:
Jason M. Bills664e1c32020-01-30 16:02:39 -08001374 rc = initiateHostStateTransition(
1375 ctx, State::Host::Transition::ForceWarmReboot);
Chanh Nguyend0a7fcd2021-07-16 22:59:28 +07001376 break;
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001377 case CMD_POWER_CYCLE:
Jason M. Bills664e1c32020-01-30 16:02:39 -08001378 rc = initiateHostStateTransition(ctx,
1379 State::Host::Transition::Reboot);
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001380 break;
Vishwanatha Subbanna8b26d352017-08-04 18:35:18 +05301381 case CMD_SOFT_OFF_VIA_OVER_TEMP:
Jason M. Bills664e1c32020-01-30 16:02:39 -08001382 rc = initiateHostStateTransition(ctx, State::Host::Transition::Off);
Vishwanatha Subbanna8b26d352017-08-04 18:35:18 +05301383 break;
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +08001384 case CMD_PULSE_DIAGNOSTIC_INTR:
Vernon Mauery9bb4a382021-11-05 12:46:19 -07001385 rc = setNmiProperty(ctx, true);
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +08001386 break;
1387
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001388 default:
1389 {
Aditya Saripalli5fb14602017-11-09 14:46:27 +05301390 log<level::ERR>("Invalid Chassis Control command",
anil kumar appanadafff5f2019-04-27 18:06:00 +00001391 entry("CMD=0x%X", chassisControl));
1392 return ipmi::responseInvalidFieldRequest();
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001393 }
1394 }
vishwa36993272015-11-20 12:43:49 -06001395
anil kumar appanadafff5f2019-04-27 18:06:00 +00001396 return ((rc < 0) ? ipmi::responseUnspecifiedError()
1397 : ipmi::responseSuccess());
vishwa36993272015-11-20 12:43:49 -06001398}
1399
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001400/** @brief Return D-Bus connection string to enclosure identify LED object
1401 *
1402 * @param[in, out] connection - connection to D-Bus object
1403 * @return a IPMI return code
1404 */
1405std::string getEnclosureIdentifyConnection()
Tom Joseph5110c122018-03-23 17:55:40 +05301406{
Tom Joseph5110c122018-03-23 17:55:40 +05301407 // lookup enclosure_identify group owner(s) in mapper
1408 auto mapperCall = chassis::internal::dbus.new_method_call(
Patrick Venture0b02be92018-08-31 11:55:55 -07001409 ipmi::MAPPER_BUS_NAME, ipmi::MAPPER_OBJ, ipmi::MAPPER_INTF,
1410 "GetObject");
Tom Joseph5110c122018-03-23 17:55:40 +05301411
1412 mapperCall.append(identify_led_object_name);
Patrick Venture0b02be92018-08-31 11:55:55 -07001413 static const std::vector<std::string> interfaces = {
1414 "xyz.openbmc_project.Led.Group"};
Tom Joseph5110c122018-03-23 17:55:40 +05301415 mapperCall.append(interfaces);
1416 auto mapperReply = chassis::internal::dbus.call(mapperCall);
1417 if (mapperReply.is_method_error())
1418 {
1419 log<level::ERR>("Chassis Identify: Error communicating to mapper.");
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001420 elog<InternalFailure>();
Tom Joseph5110c122018-03-23 17:55:40 +05301421 }
1422 std::vector<std::pair<std::string, std::vector<std::string>>> mapperResp;
1423 mapperReply.read(mapperResp);
1424
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001425 if (mapperResp.size() != encIdentifyObjectsSize)
Tom Joseph5110c122018-03-23 17:55:40 +05301426 {
Patrick Venture0b02be92018-08-31 11:55:55 -07001427 log<level::ERR>(
1428 "Invalid number of enclosure identify objects.",
1429 entry("ENC_IDENTITY_OBJECTS_SIZE=%d", mapperResp.size()));
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001430 elog<InternalFailure>();
1431 }
1432 auto pair = mapperResp[encIdentifyObjectsSize - 1];
1433 return pair.first;
1434}
Tom Joseph5110c122018-03-23 17:55:40 +05301435
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001436/** @brief Turn On/Off enclosure identify LED
1437 *
1438 * @param[in] flag - true to turn on LED, false to turn off
1439 * @return a IPMI return code
1440 */
1441void enclosureIdentifyLed(bool flag)
1442{
1443 using namespace chassis::internal;
1444 std::string connection = std::move(getEnclosureIdentifyConnection());
Vernon Mauery400cc782018-10-09 13:49:53 -07001445 auto msg = std::string("enclosureIdentifyLed(") +
1446 boost::lexical_cast<std::string>(flag) + ")";
1447 log<level::DEBUG>(msg.c_str());
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05001448 auto led = dbus.new_method_call(connection.c_str(),
1449 identify_led_object_name,
1450 "org.freedesktop.DBus.Properties", "Set");
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001451 led.append("xyz.openbmc_project.Led.Group", "Asserted",
Vernon Mauery16b86932019-05-01 08:36:11 -07001452 std::variant<bool>(flag));
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001453 auto ledReply = dbus.call(led);
1454 if (ledReply.is_method_error())
1455 {
1456 log<level::ERR>("Chassis Identify: Error Setting State On/Off\n",
Patrick Venture0b02be92018-08-31 11:55:55 -07001457 entry("LED_STATE=%d", flag));
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001458 elog<InternalFailure>();
1459 }
1460}
1461
1462/** @brief Callback method to turn off LED
1463 */
1464void enclosureIdentifyLedOff()
1465{
1466 try
1467 {
Yong Lif4e38512019-05-21 14:46:55 +08001468 chassisIDState = ChassisIDState::off;
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001469 enclosureIdentifyLed(false);
1470 }
1471 catch (const InternalFailure& e)
1472 {
1473 report<InternalFailure>();
1474 }
1475}
1476
1477/** @brief Create timer to turn on and off the enclosure LED
1478 */
1479void createIdentifyTimer()
1480{
1481 if (!identifyTimer)
1482 {
Vernon Mauery1181af72018-10-08 12:05:00 -07001483 identifyTimer =
1484 std::make_unique<phosphor::Timer>(enclosureIdentifyLedOff);
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001485 }
1486}
1487
Vernon Mauery400cc782018-10-09 13:49:53 -07001488ipmi::RspType<> ipmiChassisIdentify(std::optional<uint8_t> interval,
1489 std::optional<uint8_t> force)
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001490{
Vernon Mauery400cc782018-10-09 13:49:53 -07001491 uint8_t identifyInterval = interval.value_or(DEFAULT_IDENTIFY_TIME_OUT);
1492 bool forceIdentify = force.value_or(0) & 0x01;
Tom Josephbed26992018-07-31 23:00:24 +05301493
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001494 if (identifyInterval || forceIdentify)
1495 {
Vernon Mauery400cc782018-10-09 13:49:53 -07001496 // stop the timer if already started;
1497 // for force identify we should not turn off LED
Vernon Mauery1181af72018-10-08 12:05:00 -07001498 identifyTimer->stop();
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001499 try
Tom Joseph5110c122018-03-23 17:55:40 +05301500 {
Yong Lif4e38512019-05-21 14:46:55 +08001501 chassisIDState = ChassisIDState::temporaryOn;
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001502 enclosureIdentifyLed(true);
1503 }
1504 catch (const InternalFailure& e)
1505 {
1506 report<InternalFailure>();
Vernon Mauery400cc782018-10-09 13:49:53 -07001507 return ipmi::responseResponseError();
Tom Joseph5110c122018-03-23 17:55:40 +05301508 }
1509
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001510 if (forceIdentify)
Tom Joseph5110c122018-03-23 17:55:40 +05301511 {
Yong Lif4e38512019-05-21 14:46:55 +08001512 chassisIDState = ChassisIDState::indefiniteOn;
Vernon Mauery400cc782018-10-09 13:49:53 -07001513 return ipmi::responseSuccess();
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001514 }
1515 // start the timer
1516 auto time = std::chrono::duration_cast<std::chrono::microseconds>(
Patrick Venture0b02be92018-08-31 11:55:55 -07001517 std::chrono::seconds(identifyInterval));
Vernon Mauery1181af72018-10-08 12:05:00 -07001518 identifyTimer->start(time);
Tom Joseph5110c122018-03-23 17:55:40 +05301519 }
Tom Josephbed26992018-07-31 23:00:24 +05301520 else if (!identifyInterval)
1521 {
Vernon Mauery1181af72018-10-08 12:05:00 -07001522 identifyTimer->stop();
Tom Josephbed26992018-07-31 23:00:24 +05301523 enclosureIdentifyLedOff();
1524 }
Vernon Mauery400cc782018-10-09 13:49:53 -07001525 return ipmi::responseSuccess();
Tom Joseph5110c122018-03-23 17:55:40 +05301526}
1527
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001528namespace boot_options
1529{
1530
1531using namespace sdbusplus::xyz::openbmc_project::Control::Boot::server;
1532using IpmiValue = uint8_t;
1533constexpr auto ipmiDefault = 0;
1534
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001535std::map<IpmiValue, Type::Types> typeIpmiToDbus = {{0x00, Type::Types::Legacy},
1536 {0x01, Type::Types::EFI}};
1537
Patrick Venture0b02be92018-08-31 11:55:55 -07001538std::map<IpmiValue, Source::Sources> sourceIpmiToDbus = {
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001539 {0x01, Source::Sources::Network},
1540 {0x02, Source::Sources::Disk},
1541 {0x05, Source::Sources::ExternalMedia},
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08001542 {0x0f, Source::Sources::RemovableMedia},
Patrick Venture0b02be92018-08-31 11:55:55 -07001543 {ipmiDefault, Source::Sources::Default}};
shgoupfd84fbbf2015-12-17 10:05:51 +08001544
Patrick Venture0b02be92018-08-31 11:55:55 -07001545std::map<IpmiValue, Mode::Modes> modeIpmiToDbus = {
Yong Li5833cb62019-10-30 13:27:12 +08001546#ifdef ENABLE_BOOT_FLAG_SAFE_MODE_SUPPORT
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001547 {0x03, Mode::Modes::Safe},
Yong Li5833cb62019-10-30 13:27:12 +08001548#endif // ENABLE_BOOT_SAFE_MODE_SUPPORT
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001549 {0x06, Mode::Modes::Setup},
Patrick Venture0b02be92018-08-31 11:55:55 -07001550 {ipmiDefault, Mode::Modes::Regular}};
shgoupfd84fbbf2015-12-17 10:05:51 +08001551
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001552std::map<Type::Types, IpmiValue> typeDbusToIpmi = {{Type::Types::Legacy, 0x00},
1553 {Type::Types::EFI, 0x01}};
1554
Patrick Venture0b02be92018-08-31 11:55:55 -07001555std::map<Source::Sources, IpmiValue> sourceDbusToIpmi = {
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001556 {Source::Sources::Network, 0x01},
1557 {Source::Sources::Disk, 0x02},
1558 {Source::Sources::ExternalMedia, 0x05},
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08001559 {Source::Sources::RemovableMedia, 0x0f},
Patrick Venture0b02be92018-08-31 11:55:55 -07001560 {Source::Sources::Default, ipmiDefault}};
shgoupfd84fbbf2015-12-17 10:05:51 +08001561
Patrick Venture0b02be92018-08-31 11:55:55 -07001562std::map<Mode::Modes, IpmiValue> modeDbusToIpmi = {
Yong Li5833cb62019-10-30 13:27:12 +08001563#ifdef ENABLE_BOOT_FLAG_SAFE_MODE_SUPPORT
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001564 {Mode::Modes::Safe, 0x03},
Yong Li5833cb62019-10-30 13:27:12 +08001565#endif // ENABLE_BOOT_SAFE_MODE_SUPPORT
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001566 {Mode::Modes::Setup, 0x06},
Patrick Venture0b02be92018-08-31 11:55:55 -07001567 {Mode::Modes::Regular, ipmiDefault}};
shgoupfd84fbbf2015-12-17 10:05:51 +08001568
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001569} // namespace boot_options
shgoupfd84fbbf2015-12-17 10:05:51 +08001570
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001571/** @brief Get the property value for boot source
1572 * @param[in] ctx - context pointer
1573 * @param[out] source - boot source value
1574 * @return On failure return IPMI error.
1575 */
1576static ipmi::Cc getBootSource(ipmi::Context::ptr& ctx, Source::Sources& source)
1577{
1578 using namespace chassis::internal;
1579 std::string result;
1580 std::string service;
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05001581 boost::system::error_code ec = getService(ctx, bootSourceIntf,
1582 bootSettingsPath, service);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001583 if (!ec)
1584 {
1585 ec = ipmi::getDbusProperty(ctx, service, bootSettingsPath,
1586 bootSourceIntf, "BootSource", result);
1587 if (!ec)
1588 {
1589 source = Source::convertSourcesFromString(result);
1590 return ipmi::ccSuccess;
1591 }
1592 }
1593 log<level::ERR>("Error in BootSource Get",
1594 entry("ERROR=%s", ec.message().c_str()));
1595 return ipmi::ccUnspecifiedError;
1596}
1597
Marri Devender Rao81719702018-05-07 00:53:48 -05001598/** @brief Set the property value for boot source
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001599 * @param[in] ctx - context pointer
Marri Devender Rao81719702018-05-07 00:53:48 -05001600 * @param[in] source - boot source value
1601 * @return On failure return IPMI error.
1602 */
Jayaprakash Mutyala6088e9f2021-07-14 07:40:29 +00001603static ipmi::Cc setBootSource(ipmi::Context::ptr& ctx,
1604 const Source::Sources& source)
Marri Devender Rao81719702018-05-07 00:53:48 -05001605{
1606 using namespace chassis::internal;
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001607 std::string service;
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05001608 boost::system::error_code ec = getService(ctx, bootSourceIntf,
1609 bootSettingsPath, service);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001610 if (!ec)
Marri Devender Rao81719702018-05-07 00:53:48 -05001611 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001612 ec = ipmi::setDbusProperty(ctx, service, bootSettingsPath,
1613 bootSourceIntf, "BootSource",
1614 convertForMessage(source));
1615 if (!ec)
1616 {
1617 return ipmi::ccSuccess;
1618 }
Marri Devender Rao81719702018-05-07 00:53:48 -05001619 }
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001620 log<level::ERR>("Error in BootSource Set",
1621 entry("ERROR=%s", ec.message().c_str()));
1622 return ipmi::ccUnspecifiedError;
1623}
1624
1625/** @brief Get the property value for boot mode
1626 * @param[in] ctx - context pointer
1627 * @param[out] mode - boot mode value
1628 * @return On failure return IPMI error.
1629 */
1630static ipmi::Cc getBootMode(ipmi::Context::ptr& ctx, Mode::Modes& mode)
1631{
1632 using namespace chassis::internal;
1633 std::string result;
1634 std::string service;
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05001635 boost::system::error_code ec = getService(ctx, bootModeIntf,
1636 bootSettingsPath, service);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001637 if (!ec)
1638 {
1639 ec = ipmi::getDbusProperty(ctx, service, bootSettingsPath, bootModeIntf,
1640 "BootMode", result);
1641 if (!ec)
1642 {
1643 mode = Mode::convertModesFromString(result);
1644 return ipmi::ccSuccess;
1645 }
1646 }
1647 log<level::ERR>("Error in BootMode Get",
1648 entry("ERROR=%s", ec.message().c_str()));
1649 return ipmi::ccUnspecifiedError;
Marri Devender Rao81719702018-05-07 00:53:48 -05001650}
1651
Patrick Venture0b02be92018-08-31 11:55:55 -07001652/** @brief Set the property value for boot mode
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001653 * @param[in] ctx - context pointer
Marri Devender Rao81719702018-05-07 00:53:48 -05001654 * @param[in] mode - boot mode value
1655 * @return On failure return IPMI error.
1656 */
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001657static ipmi::Cc setBootMode(ipmi::Context::ptr& ctx, const Mode::Modes& mode)
Marri Devender Rao81719702018-05-07 00:53:48 -05001658{
1659 using namespace chassis::internal;
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001660 std::string service;
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05001661 boost::system::error_code ec = getService(ctx, bootModeIntf,
1662 bootSettingsPath, service);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001663 if (!ec)
Marri Devender Rao81719702018-05-07 00:53:48 -05001664 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001665 ec = ipmi::setDbusProperty(ctx, service, bootSettingsPath, bootModeIntf,
1666 "BootMode", convertForMessage(mode));
1667 if (!ec)
1668 {
1669 return ipmi::ccSuccess;
1670 }
Marri Devender Rao81719702018-05-07 00:53:48 -05001671 }
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001672 log<level::ERR>("Error in BootMode Set",
1673 entry("ERROR=%s", ec.message().c_str()));
1674 return ipmi::ccUnspecifiedError;
1675}
1676
1677/** @brief Get the property value for boot type
1678 * @param[in] ctx - context pointer
1679 * @param[out] type - boot type value
1680 * @return On failure return IPMI error.
1681 */
1682static ipmi::Cc getBootType(ipmi::Context::ptr& ctx, Type::Types& type)
1683{
1684 using namespace chassis::internal;
1685 std::string result;
1686 std::string service;
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05001687 boost::system::error_code ec = getService(ctx, bootTypeIntf,
1688 bootSettingsPath, service);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001689
1690 // Don't throw error if BootType interface is not present.
1691 // This interface is not relevant for some Host architectures
1692 // (for example POWER). In this case we don't won't IPMI to
1693 // return an error, but simply return bootType as EFI.
1694 type = Type::Types::EFI;
1695 if (!ec)
1696 {
1697 ec = ipmi::getDbusProperty(ctx, service, bootSettingsPath, bootTypeIntf,
1698 "BootType", result);
1699 if (ec)
1700 {
1701 log<level::ERR>("Error in BootType Get",
1702 entry("ERROR=%s", ec.message().c_str()));
1703 return ipmi::ccUnspecifiedError;
1704 }
1705 type = Type::convertTypesFromString(result);
1706 }
1707
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00001708 return ipmi::ccSuccess;
Marri Devender Rao81719702018-05-07 00:53:48 -05001709}
1710
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001711/** @brief Set the property value for boot type
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001712 * @param[in] ctx - context pointer
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001713 * @param[in] type - boot type value
1714 * @return On failure return IPMI error.
1715 */
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001716static ipmi::Cc setBootType(ipmi::Context::ptr& ctx, const Type::Types& type)
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001717{
1718 using namespace chassis::internal;
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001719 std::string service;
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05001720 boost::system::error_code ec = getService(ctx, bootTypeIntf,
1721 bootSettingsPath, service);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001722 if (!ec)
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001723 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001724 ec = ipmi::setDbusProperty(ctx, service, bootSettingsPath, bootTypeIntf,
1725 "BootType", convertForMessage(type));
1726 if (ec)
1727 {
1728 log<level::ERR>("Error in BootType Set",
1729 entry("ERROR=%s", ec.message().c_str()));
1730 return ipmi::ccUnspecifiedError;
1731 }
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001732 }
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001733 // Don't throw error if BootType interface is not present.
1734 // This interface is not relevant for some Host architectures
1735 // (for example POWER). In this case we don't won't IPMI to
1736 // return an error, but want to just skip this function.
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001737 return ipmi::ccSuccess;
1738}
1739
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001740/** @brief Get the property value for boot override enable
1741 * @param[in] ctx - context pointer
1742 * @param[out] enable - boot override enable
1743 * @return On failure return IPMI error.
1744 */
1745static ipmi::Cc getBootEnable(ipmi::Context::ptr& ctx, bool& enable)
1746{
1747 using namespace chassis::internal;
1748 std::string result;
1749 std::string service;
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05001750 boost::system::error_code ec = getService(ctx, bootEnableIntf,
1751 bootSettingsPath, service);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001752 if (!ec)
1753 {
1754 ec = ipmi::getDbusProperty(ctx, service, bootSettingsPath,
1755 bootEnableIntf, "Enabled", enable);
1756 if (!ec)
1757 {
1758 return ipmi::ccSuccess;
1759 }
1760 }
1761 log<level::ERR>("Error in Boot Override Enable Get",
1762 entry("ERROR=%s", ec.message().c_str()));
1763 return ipmi::ccUnspecifiedError;
1764}
1765
1766/** @brief Set the property value for boot override enable
1767 * @param[in] ctx - context pointer
1768 * @param[in] enable - boot override enable
1769 * @return On failure return IPMI error.
1770 */
1771static ipmi::Cc setBootEnable(ipmi::Context::ptr& ctx, const bool& enable)
1772{
1773 using namespace chassis::internal;
1774 std::string service;
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05001775 boost::system::error_code ec = getService(ctx, bootEnableIntf,
1776 bootSettingsPath, service);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001777 if (!ec)
1778 {
1779 ec = ipmi::setDbusProperty(ctx, service, bootSettingsPath,
1780 bootEnableIntf, "Enabled", enable);
1781 if (!ec)
1782 {
1783 return ipmi::ccSuccess;
1784 }
1785 }
1786 log<level::ERR>("Error in Boot Source Override Enable Set",
1787 entry("ERROR=%s", ec.message().c_str()));
1788 return ipmi::ccUnspecifiedError;
1789}
1790
1791/** @brief Get the property value for boot override one-time
1792 * @param[in] ctx - context pointer
1793 * @param[out] onetime - boot override one-time
1794 * @return On failure return IPMI error.
1795 */
1796static ipmi::Cc getBootOneTime(ipmi::Context::ptr& ctx, bool& onetime)
1797{
1798 using namespace chassis::internal;
1799 std::string result;
1800 std::string service;
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05001801 boost::system::error_code ec = getService(ctx, bootOneTimeIntf,
1802 bootSettingsOneTimePath, service);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001803 if (!ec)
1804 {
1805 ec = ipmi::getDbusProperty(ctx, service, bootSettingsOneTimePath,
1806 bootOneTimeIntf, "Enabled", onetime);
1807 if (!ec)
1808 {
1809 return ipmi::ccSuccess;
1810 }
1811 }
1812 log<level::ERR>("Error in Boot Override OneTime Get",
1813 entry("ERROR=%s", ec.message().c_str()));
1814 return ipmi::ccUnspecifiedError;
1815}
1816
1817/** @brief Set the property value for boot override one-time
1818 * @param[in] ctx - context pointer
1819 * @param[in] onetime - boot override one-time
1820 * @return On failure return IPMI error.
1821 */
1822static ipmi::Cc setBootOneTime(ipmi::Context::ptr& ctx, const bool& onetime)
1823{
1824 using namespace chassis::internal;
1825 std::string service;
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05001826 boost::system::error_code ec = getService(ctx, bootOneTimeIntf,
1827 bootSettingsOneTimePath, service);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001828 if (!ec)
1829 {
1830 ec = ipmi::setDbusProperty(ctx, service, bootSettingsOneTimePath,
1831 bootOneTimeIntf, "Enabled", onetime);
1832 if (!ec)
1833 {
1834 return ipmi::ccSuccess;
1835 }
1836 }
1837 log<level::ERR>("Error in Boot Source Override OneTime Set",
1838 entry("ERROR=%s", ec.message().c_str()));
1839 return ipmi::ccUnspecifiedError;
1840}
1841
huangheab369282020-10-10 14:40:00 +08001842static constexpr uint8_t setComplete = 0x0;
1843static constexpr uint8_t setInProgress = 0x1;
1844static uint8_t transferStatus = setComplete;
Chen Yugang86ac4992021-06-25 08:14:52 +08001845static uint8_t bootFlagValidBitClr = 0;
Hieu Huynh38ffafc2021-05-14 08:40:14 +00001846static uint5_t bootInitiatorAckData = 0x0;
Hieu Huynh1982a3f2021-09-21 03:06:45 +00001847static bool cmosClear = false;
huangheab369282020-10-10 14:40:00 +08001848
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001849/** @brief implements the Get Chassis system boot option
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001850 * @param ctx - context pointer
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001851 * @param bootOptionParameter - boot option parameter selector
1852 * @param reserved1 - reserved bit
1853 * @param setSelector - selects a particular block or set of parameters
1854 * under the given parameter selector
1855 * write as 00h if parameter doesn't use a setSelector
1856 * @param blockSelector- selects a particular block within a set of
1857 * parameters write as 00h if parameter doesn't use a
1858 * blockSelector
1859 *
1860 * @return IPMI completion code plus response data
1861 * @return Payload contains below parameters:
1862 * version - parameter version
1863 * bootOptionParameter - boot option parameter selector
Patrick Venture8b1c3032020-09-15 09:43:03 -07001864 * parmIndicator - parameter valid/invalid indicator
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001865 * data - configuration parameter data
1866 */
1867ipmi::RspType<ipmi::message::Payload>
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001868 ipmiChassisGetSysBootOptions(ipmi::Context::ptr ctx,
1869 uint7_t bootOptionParameter, bool reserved1,
Willy Tu11d68892022-01-20 10:37:34 -08001870 [[maybe_unused]] uint8_t setSelector,
1871 [[maybe_unused]] uint8_t blockSelector)
Adriana Kobylak40814c62015-10-27 15:58:44 -05001872{
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001873 ipmi::Cc rc;
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001874 if (reserved1)
1875 {
1876 return ipmi::responseInvalidFieldRequest();
1877 }
1878
1879 constexpr uint4_t version = 0x01;
1880 ipmi::message::Payload response;
1881 response.pack(version, uint4_t{});
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001882 using namespace boot_options;
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001883
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001884 IpmiValue bootOption = ipmiDefault;
Adriana Kobylak40814c62015-10-27 15:58:44 -05001885
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001886 if (types::enum_cast<BootOptionParameter>(bootOptionParameter) ==
1887 BootOptionParameter::setInProgress)
huangheab369282020-10-10 14:40:00 +08001888 {
1889 response.pack(bootOptionParameter, reserved1, transferStatus);
1890 return ipmi::responseSuccess(std::move(response));
1891 }
1892
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001893 if (types::enum_cast<BootOptionParameter>(bootOptionParameter) ==
1894 BootOptionParameter::bootInfo)
John Wang0213f902020-12-28 14:49:57 +08001895 {
1896 constexpr uint8_t writeMask = 0;
Hieu Huynh38ffafc2021-05-14 08:40:14 +00001897 response.pack(bootOptionParameter, reserved1, writeMask,
1898 bootInitiatorAckData);
John Wang0213f902020-12-28 14:49:57 +08001899 return ipmi::responseSuccess(std::move(response));
1900 }
1901
Chen Yugang86ac4992021-06-25 08:14:52 +08001902 if (types::enum_cast<BootOptionParameter>(bootOptionParameter) ==
1903 BootOptionParameter::bootFlagValidClr)
1904 {
1905 response.pack(bootOptionParameter, reserved1,
1906 uint5_t{bootFlagValidBitClr}, uint3_t{});
1907 return ipmi::responseSuccess(std::move(response));
1908 }
1909
shgoupfd84fbbf2015-12-17 10:05:51 +08001910 /*
1911 * Parameter #5 means boot flags. Please refer to 28.13 of ipmi doc.
1912 * This is the only parameter used by petitboot.
1913 */
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001914 if (types::enum_cast<BootOptionParameter>(bootOptionParameter) ==
1915 BootOptionParameter::bootFlags)
Patrick Venture0b02be92018-08-31 11:55:55 -07001916 {
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001917 using namespace chassis::internal;
1918 using namespace chassis::internal::cache;
shgoupfd84fbbf2015-12-17 10:05:51 +08001919
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001920 try
ratagupta6f6bff2016-04-04 06:20:11 -05001921 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001922 Source::Sources bootSource;
1923 rc = getBootSource(ctx, bootSource);
1924 if (rc != ipmi::ccSuccess)
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001925 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001926 return ipmi::response(rc);
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001927 }
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001928
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001929 Type::Types bootType;
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001930 rc = getBootType(ctx, bootType);
1931 if (rc != ipmi::ccSuccess)
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001932 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001933 return ipmi::response(rc);
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001934 }
1935
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001936 Mode::Modes bootMode;
1937 rc = getBootMode(ctx, bootMode);
1938 if (rc != ipmi::ccSuccess)
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001939 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001940 return ipmi::response(rc);
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001941 }
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001942
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001943 bootOption = sourceDbusToIpmi.at(bootSource);
1944 if ((Mode::Modes::Regular == bootMode) &&
1945 (Source::Sources::Default == bootSource))
1946 {
1947 bootOption = ipmiDefault;
1948 }
1949 else if (Source::Sources::Default == bootSource)
1950 {
1951 bootOption = modeDbusToIpmi.at(bootMode);
1952 }
ratagupta6f6bff2016-04-04 06:20:11 -05001953
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001954 IpmiValue biosBootType = typeDbusToIpmi.at(bootType);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001955
1956 bool oneTimeEnabled;
1957 rc = getBootOneTime(ctx, oneTimeEnabled);
1958 if (rc != ipmi::ccSuccess)
1959 {
1960 return ipmi::response(rc);
1961 }
1962
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001963 uint1_t permanent = oneTimeEnabled ? 0 : 1;
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001964
1965 bool valid;
1966 rc = getBootEnable(ctx, valid);
1967 if (rc != ipmi::ccSuccess)
1968 {
1969 return ipmi::response(rc);
1970 }
1971
1972 uint1_t validFlag = valid ? 1 : 0;
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001973
1974 response.pack(bootOptionParameter, reserved1, uint5_t{},
1975 uint1_t{biosBootType}, uint1_t{permanent},
1976 uint1_t{validFlag}, uint2_t{}, uint4_t{bootOption},
Hieu Huynh1982a3f2021-09-21 03:06:45 +00001977 uint1_t{}, cmosClear, uint8_t{}, uint8_t{},
1978 uint8_t{});
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001979 return ipmi::responseSuccess(std::move(response));
ratagupta6f6bff2016-04-04 06:20:11 -05001980 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -05001981 catch (const InternalFailure& e)
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001982 {
James Feist225dec82019-11-26 16:25:06 -08001983 cache::objectsPtr.reset();
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001984 report<InternalFailure>();
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001985 return ipmi::responseUnspecifiedError();
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001986 }
Patrick Venture0b02be92018-08-31 11:55:55 -07001987 }
Patrick Venture0b02be92018-08-31 11:55:55 -07001988 else
1989 {
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001990 if ((bootOptionParameter >= oemParmStart) &&
1991 (bootOptionParameter <= oemParmEnd))
1992 {
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001993 if (types::enum_cast<BootOptionParameter>(bootOptionParameter) ==
1994 BootOptionParameter::opalNetworkSettings)
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001995 {
1996 response.pack(bootOptionParameter, reserved1);
1997 int ret = getHostNetworkData(response);
1998 if (ret < 0)
1999 {
2000 response.trailingOk = true;
2001 log<level::ERR>(
2002 "getHostNetworkData failed for GetSysBootOptions.");
2003 return ipmi::responseUnspecifiedError();
2004 }
2005 else
2006 {
2007 return ipmi::responseSuccess(std::move(response));
2008 }
2009 }
Jayaprakash Mutyala43a88102021-08-04 16:41:58 +00002010 else
2011 {
2012 log<level::ERR>(
2013 "ipmiChassisGetSysBootOptions: Unsupported parameter",
2014 entry("PARAM=0x%x",
2015 static_cast<uint8_t>(bootOptionParameter)));
2016 return ipmi::responseParmNotSupported();
2017 }
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002018 }
2019 else
2020 {
2021 log<level::ERR>(
2022 "ipmiChassisGetSysBootOptions: Unsupported parameter",
2023 entry("PARAM=0x%x", static_cast<uint8_t>(bootOptionParameter)));
Jayaprakash Mutyala6088e9f2021-07-14 07:40:29 +00002024 return ipmi::responseParmNotSupported();
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002025 }
shgoupfd84fbbf2015-12-17 10:05:51 +08002026 }
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002027 return ipmi::responseUnspecifiedError();
shgoupfd84fbbf2015-12-17 10:05:51 +08002028}
2029
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002030ipmi::RspType<> ipmiChassisSetSysBootOptions(ipmi::Context::ptr ctx,
Willy Tu11d68892022-01-20 10:37:34 -08002031 uint7_t parameterSelector, bool,
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002032 ipmi::message::Payload& data)
shgoupfd84fbbf2015-12-17 10:05:51 +08002033{
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002034 using namespace boot_options;
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002035 ipmi::Cc rc;
shgoupfd84fbbf2015-12-17 10:05:51 +08002036
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07002037 if (types::enum_cast<BootOptionParameter>(parameterSelector) ==
2038 BootOptionParameter::setInProgress)
huangheab369282020-10-10 14:40:00 +08002039 {
2040 uint2_t setInProgressFlag;
2041 uint6_t rsvd;
2042 if (data.unpack(setInProgressFlag, rsvd) != 0 || !data.fullyUnpacked())
2043 {
2044 return ipmi::responseReqDataLenInvalid();
2045 }
2046 if (rsvd)
2047 {
2048 return ipmi::responseInvalidFieldRequest();
2049 }
2050 if ((transferStatus == setInProgress) &&
2051 (static_cast<uint8_t>(setInProgressFlag) != setComplete))
2052 {
2053 return ipmi::response(IPMI_CC_FAIL_SET_IN_PROGRESS);
2054 }
2055 transferStatus = static_cast<uint8_t>(setInProgressFlag);
2056 return ipmi::responseSuccess();
2057 }
2058
shgoupfd84fbbf2015-12-17 10:05:51 +08002059 /* 000101
2060 * Parameter #5 means boot flags. Please refer to 28.13 of ipmi doc.
2061 * This is the only parameter used by petitboot.
2062 */
Ratan Guptafd28dd72016-08-01 04:58:01 -05002063
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07002064 if (types::enum_cast<BootOptionParameter>(parameterSelector) ==
2065 BootOptionParameter::bootFlags)
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002066 {
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002067 uint5_t rsvd;
2068 bool validFlag;
2069 bool permanent;
2070 bool biosBootType;
2071 bool lockOutResetButton;
2072 bool screenBlank;
2073 uint4_t bootDeviceSelector;
2074 bool lockKeyboard;
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002075 uint8_t data3;
2076 uint4_t biosInfo;
2077 uint4_t rsvd1;
2078 uint5_t deviceInstance;
2079 uint3_t rsvd2;
2080
2081 if (data.unpack(rsvd, biosBootType, permanent, validFlag,
2082 lockOutResetButton, screenBlank, bootDeviceSelector,
2083 lockKeyboard, cmosClear, data3, biosInfo, rsvd1,
2084 deviceInstance, rsvd2) != 0 ||
2085 !data.fullyUnpacked())
2086 {
2087 return ipmi::responseReqDataLenInvalid();
2088 }
2089 if (rsvd || rsvd1 || rsvd2)
2090 {
2091 return ipmi::responseInvalidFieldRequest();
2092 }
2093
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002094 using namespace chassis::internal;
2095 using namespace chassis::internal::cache;
shgoupfd84fbbf2015-12-17 10:05:51 +08002096
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002097 try
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002098 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002099 rc = setBootOneTime(ctx, !permanent);
2100 if (rc != ipmi::ccSuccess)
Konstantin Aladyshev69e8e842021-06-18 17:01:18 +03002101 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002102 return ipmi::response(rc);
2103 }
Vernon Maueryafd45db2021-07-29 16:27:25 +00002104
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002105 rc = setBootEnable(ctx, validFlag);
2106 if (rc != ipmi::ccSuccess)
2107 {
2108 return ipmi::response(rc);
Tom Joseph57e8eb72017-09-25 18:05:02 +05302109 }
2110
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002111 auto modeItr =
2112 modeIpmiToDbus.find(static_cast<uint8_t>(bootDeviceSelector));
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002113 auto typeItr =
2114 typeIpmiToDbus.find(static_cast<uint8_t>(biosBootType));
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002115 auto sourceItr =
2116 sourceIpmiToDbus.find(static_cast<uint8_t>(bootDeviceSelector));
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002117 if (sourceIpmiToDbus.end() != sourceItr)
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002118 {
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03002119 rc = setBootSource(ctx, sourceItr->second);
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002120 if (rc != ipmi::ccSuccess)
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002121 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002122 return ipmi::response(rc);
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002123 }
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002124 // If a set boot device is mapping to a boot source, then reset
2125 // the boot mode D-Bus property to default.
2126 // This way the ipmid code can determine which property is not
2127 // at the default value
Patrick Venture0b02be92018-08-31 11:55:55 -07002128 if (sourceItr->second != Source::Sources::Default)
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002129 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002130 rc = setBootMode(ctx, Mode::Modes::Regular);
2131 if (rc != ipmi::ccSuccess)
2132 {
2133 return ipmi::response(rc);
2134 }
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002135 }
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002136 }
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002137
2138 if (typeIpmiToDbus.end() != typeItr)
2139 {
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03002140 rc = setBootType(ctx, typeItr->second);
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002141 if (rc != ipmi::ccSuccess)
2142 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002143 return ipmi::response(rc);
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002144 }
2145 }
2146
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002147 if (modeIpmiToDbus.end() != modeItr)
2148 {
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03002149 rc = setBootMode(ctx, modeItr->second);
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002150 if (rc != ipmi::ccSuccess)
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002151 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002152 return ipmi::response(rc);
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002153 }
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002154 // If a set boot device is mapping to a boot mode, then reset
2155 // the boot source D-Bus property to default.
2156 // This way the ipmid code can determine which property is not
2157 // at the default value
Patrick Venture0b02be92018-08-31 11:55:55 -07002158 if (modeItr->second != Mode::Modes::Regular)
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002159 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002160 rc = setBootSource(ctx, Source::Sources::Default);
2161 if (rc != ipmi::ccSuccess)
2162 {
2163 return ipmi::response(rc);
2164 }
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002165 }
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002166 }
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08002167 if ((modeIpmiToDbus.end() == modeItr) &&
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002168 (typeIpmiToDbus.end() == typeItr) &&
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08002169 (sourceIpmiToDbus.end() == sourceItr))
2170 {
2171 // return error if boot option is not supported
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002172 log<level::ERR>(
2173 "ipmiChassisSetSysBootOptions: Boot option not supported");
2174 return ipmi::responseInvalidFieldRequest();
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08002175 }
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002176 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -05002177 catch (const sdbusplus::exception_t& e)
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002178 {
James Feist225dec82019-11-26 16:25:06 -08002179 objectsPtr.reset();
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002180 report<InternalFailure>();
Aditya Saripalli5fb14602017-11-09 14:46:27 +05302181 log<level::ERR>(
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002182 "ipmiChassisSetSysBootOptions: Error in setting Boot "
2183 "flag parameters");
2184 return ipmi::responseUnspecifiedError();
Ratan Guptafd28dd72016-08-01 04:58:01 -05002185 }
Patrick Venture0b02be92018-08-31 11:55:55 -07002186 }
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07002187 else if (types::enum_cast<BootOptionParameter>(parameterSelector) ==
2188 BootOptionParameter::bootInfo)
Patrick Venture0b02be92018-08-31 11:55:55 -07002189 {
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002190 uint8_t writeMak;
Hieu Huynh38ffafc2021-05-14 08:40:14 +00002191 uint5_t bootInfoAck;
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002192 uint3_t rsvd;
2193
Hieu Huynh38ffafc2021-05-14 08:40:14 +00002194 if (data.unpack(writeMak, bootInfoAck, rsvd) != 0 ||
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002195 !data.fullyUnpacked())
2196 {
2197 return ipmi::responseReqDataLenInvalid();
2198 }
2199 if (rsvd)
2200 {
2201 return ipmi::responseInvalidFieldRequest();
2202 }
Hieu Huynh38ffafc2021-05-14 08:40:14 +00002203 bootInitiatorAckData &= ~writeMak;
2204 bootInitiatorAckData |= (writeMak & bootInfoAck);
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002205 log<level::INFO>("ipmiChassisSetSysBootOptions: bootInfo parameter set "
2206 "successfully");
2207 data.trailingOk = true;
2208 return ipmi::responseSuccess();
Patrick Venture0b02be92018-08-31 11:55:55 -07002209 }
Chen Yugang86ac4992021-06-25 08:14:52 +08002210 else if (types::enum_cast<BootOptionParameter>(parameterSelector) ==
2211 BootOptionParameter::bootFlagValidClr)
2212 {
2213 uint5_t bootFlagValidClr;
2214 uint3_t rsvd;
2215
2216 if (data.unpack(bootFlagValidClr, rsvd) != 0 || !data.fullyUnpacked())
2217 {
2218 return ipmi::responseReqDataLenInvalid();
2219 }
2220 if (rsvd)
2221 {
2222 return ipmi::responseInvalidFieldRequest();
2223 }
2224 // store boot flag valid bits clear value
2225 bootFlagValidBitClr = static_cast<uint8_t>(bootFlagValidClr);
2226 log<level::INFO>(
2227 "ipmiChassisSetSysBootOptions: bootFlagValidBits parameter set "
2228 "successfully",
2229 entry("value=0x%x", bootFlagValidBitClr));
2230 return ipmi::responseSuccess();
2231 }
Patrick Venture0b02be92018-08-31 11:55:55 -07002232 else
2233 {
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002234 if ((parameterSelector >= static_cast<uint7_t>(oemParmStart)) &&
2235 (parameterSelector <= static_cast<uint7_t>(oemParmEnd)))
2236 {
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07002237 if (types::enum_cast<BootOptionParameter>(parameterSelector) ==
2238 BootOptionParameter::opalNetworkSettings)
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002239 {
2240 ipmi::Cc ret = setHostNetworkData(data);
2241 if (ret != ipmi::ccSuccess)
2242 {
2243 log<level::ERR>("ipmiChassisSetSysBootOptions: Error in "
2244 "setHostNetworkData");
2245 data.trailingOk = true;
2246 return ipmi::response(ret);
2247 }
2248 data.trailingOk = true;
2249 return ipmi::responseSuccess();
2250 }
2251 else
2252 {
2253 log<level::ERR>(
2254 "ipmiChassisSetSysBootOptions: Unsupported parameters",
2255 entry("PARAM=0x%x",
2256 static_cast<uint8_t>(parameterSelector)));
2257 data.trailingOk = true;
2258 return ipmi::responseParmNotSupported();
2259 }
2260 }
2261 data.trailingOk = true;
2262 return ipmi::responseParmNotSupported();
Adriana Kobylak40814c62015-10-27 15:58:44 -05002263 }
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002264 return ipmi::responseSuccess();
Adriana Kobylak40814c62015-10-27 15:58:44 -05002265}
2266
anil kumar appanaa5a76eb2019-04-30 14:57:24 +00002267/** @brief implements Get POH counter command
2268 * @parameter
2269 * - none
2270 * @returns IPMI completion code plus response data
2271 * - minPerCount - Minutes per count
2272 * - counterReading - counter reading
2273 */
2274ipmi::RspType<uint8_t, // Minutes per count
2275 uint32_t // Counter reading
2276 >
2277 ipmiGetPOHCounter()
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002278{
2279 // sd_bus error
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002280 try
2281 {
anil kumar appanaa5a76eb2019-04-30 14:57:24 +00002282 return ipmi::responseSuccess(static_cast<uint8_t>(poh::minutesPerCount),
2283 getPOHCounter());
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002284 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -05002285 catch (const std::exception& e)
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002286 {
2287 log<level::ERR>(e.what());
anil kumar appanaa5a76eb2019-04-30 14:57:24 +00002288 return ipmi::responseUnspecifiedError();
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002289 }
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002290}
2291
Jason M. Billsbc996a32019-06-17 15:46:37 -07002292ipmi::RspType<uint3_t, // policy support
2293 uint5_t // reserved
2294 >
Vernon Mauerye278ead2018-10-09 09:23:43 -07002295 ipmiChassisSetPowerRestorePolicy(boost::asio::yield_context yield,
Jason M. Billsbc996a32019-06-17 15:46:37 -07002296 uint3_t policy, uint5_t reserved)
Yong Lic6713cf2018-09-12 12:35:13 +08002297{
Yong Lic6713cf2018-09-12 12:35:13 +08002298 power_policy::DbusValue value =
2299 power_policy::RestorePolicy::Policy::AlwaysOff;
2300
Jason M. Billsbc996a32019-06-17 15:46:37 -07002301 if (reserved || (policy > power_policy::noChange))
Yong Lic6713cf2018-09-12 12:35:13 +08002302 {
Vernon Mauerye278ead2018-10-09 09:23:43 -07002303 phosphor::logging::log<level::ERR>(
2304 "Reserved request parameter",
2305 entry("REQ=0x%x", static_cast<int>(policy)));
Jason M. Billsbc996a32019-06-17 15:46:37 -07002306 return ipmi::responseInvalidFieldRequest();
Yong Lic6713cf2018-09-12 12:35:13 +08002307 }
2308
Vernon Mauerye278ead2018-10-09 09:23:43 -07002309 if (policy == power_policy::noChange)
Yong Lic6713cf2018-09-12 12:35:13 +08002310 {
2311 // just return the supported policy
Jason M. Billsbc996a32019-06-17 15:46:37 -07002312 return ipmi::responseSuccess(power_policy::allSupport, reserved);
Yong Lic6713cf2018-09-12 12:35:13 +08002313 }
2314
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05002315 for (const auto& it : power_policy::dbusToIpmi)
Yong Lic6713cf2018-09-12 12:35:13 +08002316 {
Vernon Mauerye278ead2018-10-09 09:23:43 -07002317 if (it.second == policy)
Yong Lic6713cf2018-09-12 12:35:13 +08002318 {
2319 value = it.first;
2320 break;
2321 }
2322 }
2323
2324 try
2325 {
James Feist225dec82019-11-26 16:25:06 -08002326 settings::Objects& objects = chassis::internal::cache::getObjects();
Yong Lic6713cf2018-09-12 12:35:13 +08002327 const settings::Path& powerRestoreSetting =
James Feist225dec82019-11-26 16:25:06 -08002328 objects.map.at(chassis::internal::powerRestoreIntf).front();
Vernon Mauery16b86932019-05-01 08:36:11 -07002329 std::variant<std::string> property = convertForMessage(value);
Yong Lic6713cf2018-09-12 12:35:13 +08002330
Vernon Mauerye278ead2018-10-09 09:23:43 -07002331 auto sdbusp = getSdBus();
2332 boost::system::error_code ec;
2333 sdbusp->yield_method_call<void>(
2334 yield, ec,
James Feist225dec82019-11-26 16:25:06 -08002335 objects
Yong Lic6713cf2018-09-12 12:35:13 +08002336 .service(powerRestoreSetting,
2337 chassis::internal::powerRestoreIntf)
2338 .c_str(),
Vernon Mauerye278ead2018-10-09 09:23:43 -07002339 powerRestoreSetting, ipmi::PROP_INTF, "Set",
2340 chassis::internal::powerRestoreIntf, "PowerRestorePolicy",
2341 property);
2342 if (ec)
Yong Lic6713cf2018-09-12 12:35:13 +08002343 {
2344 phosphor::logging::log<level::ERR>("Unspecified Error");
Vernon Mauerye278ead2018-10-09 09:23:43 -07002345 return ipmi::responseUnspecifiedError();
Yong Lic6713cf2018-09-12 12:35:13 +08002346 }
2347 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -05002348 catch (const InternalFailure& e)
Yong Lic6713cf2018-09-12 12:35:13 +08002349 {
James Feist225dec82019-11-26 16:25:06 -08002350 chassis::internal::cache::objectsPtr.reset();
Yong Lic6713cf2018-09-12 12:35:13 +08002351 report<InternalFailure>();
Vernon Mauerye278ead2018-10-09 09:23:43 -07002352 return ipmi::responseUnspecifiedError();
Yong Lic6713cf2018-09-12 12:35:13 +08002353 }
2354
Jason M. Billsbc996a32019-06-17 15:46:37 -07002355 return ipmi::responseSuccess(power_policy::allSupport, reserved);
Yong Lic6713cf2018-09-12 12:35:13 +08002356}
2357
Willy Tu11d68892022-01-20 10:37:34 -08002358ipmi::RspType<> ipmiSetFrontPanelButtonEnables(ipmi::Context::ptr ctx,
2359 bool disablePowerButton,
2360 bool disableResetButton, bool,
2361 bool, uint4_t)
Kuiying Wang21addc52019-01-04 10:50:21 +08002362{
2363 using namespace chassis::internal;
2364
2365 // set power button Enabled property
2366 bool success = setButtonEnabled(ctx, powerButtonPath, powerButtonIntf,
2367 !disablePowerButton);
2368
2369 // set reset button Enabled property
2370 success &= setButtonEnabled(ctx, resetButtonPath, resetButtonIntf,
2371 !disableResetButton);
2372
2373 if (!success)
2374 {
2375 // not all buttons were successfully set
2376 return ipmi::responseUnspecifiedError();
2377 }
2378 return ipmi::responseSuccess();
2379}
2380
Adriana Kobylak40814c62015-10-27 15:58:44 -05002381void register_netfn_chassis_functions()
2382{
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05002383 createIdentifyTimer();
2384
Tom05732372016-09-06 17:21:23 +05302385 // Get Chassis Capabilities
anil kumar appana43263c62019-05-27 12:45:04 +00002386 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2387 ipmi::chassis::cmdGetChassisCapabilities,
2388 ipmi::Privilege::User, ipmiGetChassisCap);
Nan Li8d15fb42016-08-16 22:29:40 +08002389
Kuiying Wang21addc52019-01-04 10:50:21 +08002390 // Set Front Panel Button Enables
2391 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2392 ipmi::chassis::cmdSetFrontPanelButtonEnables,
2393 ipmi::Privilege::Admin,
2394 ipmiSetFrontPanelButtonEnables);
2395
Yong Liae4b0402018-11-02 11:12:14 +08002396 // Set Chassis Capabilities
anil kumar appana894d0222019-05-27 16:32:14 +00002397 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2398 ipmi::chassis::cmdSetChassisCapabilities,
2399 ipmi::Privilege::User, ipmiSetChassisCap);
Yong Liae4b0402018-11-02 11:12:14 +08002400
Tom05732372016-09-06 17:21:23 +05302401 // <Get System Boot Options>
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002402 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2403 ipmi::chassis::cmdGetSystemBootOptions,
2404 ipmi::Privilege::Operator,
2405 ipmiChassisGetSysBootOptions);
Adriana Kobylak40814c62015-10-27 15:58:44 -05002406
Tom05732372016-09-06 17:21:23 +05302407 // <Get Chassis Status>
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07002408 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2409 ipmi::chassis::cmdGetChassisStatus,
2410 ipmi::Privilege::User, ipmiGetChassisStatus);
Nan Lifdd8ec52016-08-28 03:57:40 +08002411
Vijay Khemka074f64d2020-03-03 15:08:43 -08002412 // <Chassis Get System Restart Cause>
2413 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2414 ipmi::chassis::cmdGetSystemRestartCause,
2415 ipmi::Privilege::User, ipmiGetSystemRestartCause);
2416
Tom05732372016-09-06 17:21:23 +05302417 // <Chassis Control>
anil kumar appanadafff5f2019-04-27 18:06:00 +00002418 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2419 ipmi::chassis::cmdChassisControl,
2420 ipmi::Privilege::Operator, ipmiChassisControl);
shgoupfd84fbbf2015-12-17 10:05:51 +08002421
Tom Joseph5110c122018-03-23 17:55:40 +05302422 // <Chassis Identify>
Vernon Mauery400cc782018-10-09 13:49:53 -07002423 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2424 ipmi::chassis::cmdChassisIdentify,
2425 ipmi::Privilege::Operator, ipmiChassisIdentify);
Tom Joseph5110c122018-03-23 17:55:40 +05302426
Tom05732372016-09-06 17:21:23 +05302427 // <Set System Boot Options>
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002428 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2429 ipmi::chassis::cmdSetSystemBootOptions,
2430 ipmi::Privilege::Operator,
2431 ipmiChassisSetSysBootOptions);
2432
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002433 // <Get POH Counter>
anil kumar appanaa5a76eb2019-04-30 14:57:24 +00002434 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2435 ipmi::chassis::cmdGetPohCounter,
2436 ipmi::Privilege::User, ipmiGetPOHCounter);
Yong Lic6713cf2018-09-12 12:35:13 +08002437
2438 // <Set Power Restore Policy>
Vernon Mauerye278ead2018-10-09 09:23:43 -07002439 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2440 ipmi::chassis::cmdSetPowerRestorePolicy,
2441 ipmi::Privilege::Operator,
2442 ipmiChassisSetPowerRestorePolicy);
vishwa36993272015-11-20 12:43:49 -06002443}