blob: ec49443e1f456667766408bcf7d72cc5cf3566c9 [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
Ratan Guptafd28dd72016-08-01 04:58:01 -050011#include <array>
Patrick Venture0b02be92018-08-31 11:55:55 -070012#include <chrono>
Patrick Ventureb51bf9c2018-09-10 15:53:14 -070013#include <cstring>
Vernon Mauerybdda8002019-02-26 10:18:51 -080014#include <filesystem>
Andrew Geisslera6e3a302017-05-31 19:34:00 -050015#include <fstream>
Tom Joseph5110c122018-03-23 17:55:40 +053016#include <future>
Vernon Mauerye08fbff2019-04-03 09:19:34 -070017#include <ipmid/api.hpp>
Vernon Mauery33250242019-03-12 16:49:26 -070018#include <ipmid/types.hpp>
Vernon Mauery6a98fe72019-03-11 15:57:48 -070019#include <ipmid/utils.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070020#include <map>
21#include <phosphor-logging/elog-errors.hpp>
22#include <phosphor-logging/log.hpp>
23#include <sdbusplus/bus.hpp>
William A. Kennington III4c008022018-10-12 17:18:14 -070024#include <sdbusplus/message/types.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070025#include <sdbusplus/server/object.hpp>
Vernon Mauery1181af72018-10-08 12:05:00 -070026#include <sdbusplus/timer.hpp>
Vernon Mauerye278ead2018-10-09 09:23:43 -070027#include <settings.hpp>
Patrick Venture0b02be92018-08-31 11:55:55 -070028#include <sstream>
Patrick Venture3a5071a2018-09-12 13:27:42 -070029#include <string>
30#include <xyz/openbmc_project/Common/error.hpp>
31#include <xyz/openbmc_project/Control/Boot/Mode/server.hpp>
32#include <xyz/openbmc_project/Control/Boot/Source/server.hpp>
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +030033#include <xyz/openbmc_project/Control/Boot/Type/server.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070034#include <xyz/openbmc_project/Control/Power/RestorePolicy/server.hpp>
35#include <xyz/openbmc_project/State/Host/server.hpp>
36#include <xyz/openbmc_project/State/PowerOnHours/server.hpp>
37
Lei YU4b0ddb62019-01-25 16:43:50 +080038std::unique_ptr<phosphor::Timer> identifyTimer
39 __attribute__((init_priority(101)));
Marri Devender Rao6706c1c2018-05-14 00:29:38 -050040
Yong Lif4e38512019-05-21 14:46:55 +080041static ChassisIDState chassisIDState = ChassisIDState::reserved;
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +000042static constexpr uint8_t setParmVersion = 0x01;
Yong Lif4e38512019-05-21 14:46:55 +080043
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +000044constexpr size_t sizeVersion = 2;
Tom Joseph5110c122018-03-23 17:55:40 +053045constexpr size_t DEFAULT_IDENTIFY_TIME_OUT = 15;
Ratan Gupta6ec7daa2017-07-15 14:13:01 +053046
Patrick Venture0b02be92018-08-31 11:55:55 -070047// PetiBoot-Specific
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +000048static constexpr uint8_t netConfInitialBytes[] = {0x80, 0x21, 0x70, 0x62,
49 0x21, 0x00, 0x01, 0x06};
50static constexpr uint8_t oemParmStart = 96;
51static constexpr uint8_t oemParmEnd = 127;
Ratan Guptafd28dd72016-08-01 04:58:01 -050052
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +000053static constexpr size_t cookieOffset = 1;
54static constexpr size_t versionOffset = 5;
55static constexpr size_t addrSizeOffset = 8;
56static constexpr size_t macOffset = 9;
57static constexpr size_t addrTypeOffset = 16;
58static constexpr size_t ipAddrOffset = 17;
ratagupta6f6bff2016-04-04 06:20:11 -050059
Marri Devender Rao6706c1c2018-05-14 00:29:38 -050060static constexpr size_t encIdentifyObjectsSize = 1;
61static constexpr size_t chassisIdentifyReqLength = 2;
62static constexpr size_t identifyIntervalPos = 0;
63static constexpr size_t forceIdentifyPos = 1;
shgoupfd84fbbf2015-12-17 10:05:51 +080064
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +000065namespace ipmi
66{
67constexpr Cc ccParmNotSupported = 0x80;
68
69static inline auto responseParmNotSupported()
70{
71 return response(ccParmNotSupported);
72}
73} // namespace ipmi
74
Adriana Kobylak40814c62015-10-27 15:58:44 -050075void register_netfn_chassis_functions() __attribute__((constructor));
76
shgoupfd84fbbf2015-12-17 10:05:51 +080077// Host settings in dbus
78// Service name should be referenced by connection name got via object mapper
Patrick Venture0b02be92018-08-31 11:55:55 -070079const char* settings_object_name = "/org/openbmc/settings/host0";
80const char* settings_intf_name = "org.freedesktop.DBus.Properties";
Patrick Venture0b02be92018-08-31 11:55:55 -070081const char* identify_led_object_name =
Tom Joseph5110c122018-03-23 17:55:40 +053082 "/xyz/openbmc_project/led/groups/enclosure_identify";
shgoupfd84fbbf2015-12-17 10:05:51 +080083
Ratan Guptadcb10672017-07-10 10:33:50 +053084constexpr auto SETTINGS_ROOT = "/";
85constexpr auto SETTINGS_MATCH = "host0";
Ratan Guptadcb10672017-07-10 10:33:50 +053086
87constexpr auto IP_INTERFACE = "xyz.openbmc_project.Network.IP";
88constexpr auto MAC_INTERFACE = "xyz.openbmc_project.Network.MACAddress";
89
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -050090static constexpr auto chassisStateRoot = "/xyz/openbmc_project/state";
91static constexpr auto chassisPOHStateIntf =
Patrick Venture0b02be92018-08-31 11:55:55 -070092 "xyz.openbmc_project.State.PowerOnHours";
Patrick Williams7345ac42021-04-30 20:57:39 -050093static constexpr auto pohCounterProperty = "POHCounter";
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -050094static constexpr auto match = "chassis0";
Yong Liae4b0402018-11-02 11:12:14 +080095const static constexpr char chassisCapIntf[] =
96 "xyz.openbmc_project.Control.ChassisCapabilities";
Karthick Sundarrajan86d8bd72019-11-26 12:48:50 -080097const static constexpr char chassisIntrusionProp[] = "ChassisIntrusionEnabled";
98const static constexpr char chassisFrontPanelLockoutProp[] =
99 "ChassisFrontPanelLockoutEnabled";
100const static constexpr char chassisNMIProp[] = "ChassisNMIEnabled";
101const static constexpr char chassisPowerInterlockProp[] =
102 "ChassisPowerInterlockEnabled";
Yong Liae4b0402018-11-02 11:12:14 +0800103const static constexpr char chassisFRUDevAddrProp[] = "FRUDeviceAddress";
104const static constexpr char chassisSDRDevAddrProp[] = "SDRDeviceAddress";
105const static constexpr char chassisSELDevAddrProp[] = "SELDeviceAddress";
106const static constexpr char chassisSMDevAddrProp[] = "SMDeviceAddress";
107const static constexpr char chassisBridgeDevAddrProp[] = "BridgeDeviceAddress";
108static constexpr uint8_t chassisCapFlagMask = 0x0f;
109static constexpr uint8_t chassisCapAddrMask = 0xfe;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700110static constexpr const char* powerButtonIntf =
111 "xyz.openbmc_project.Chassis.Buttons.Power";
112static constexpr const char* powerButtonPath =
113 "/xyz/openbmc_project/Chassis/Buttons/Power0";
114static constexpr const char* resetButtonIntf =
115 "xyz.openbmc_project.Chassis.Buttons.Reset";
116static constexpr const char* resetButtonPath =
117 "/xyz/openbmc_project/Chassis/Buttons/Reset0";
Ratan Guptadcb10672017-07-10 10:33:50 +0530118
Vishwanatha Subbannab12b0c02017-03-07 18:17:19 +0530119// Phosphor Host State manager
120namespace State = sdbusplus::xyz::openbmc_project::State::server;
121
Vernon Mauery185b9f82018-07-20 10:52:36 -0700122namespace fs = std::filesystem;
Andrew Geisslera6e3a302017-05-31 19:34:00 -0500123
Ratan Guptadcb10672017-07-10 10:33:50 +0530124using namespace phosphor::logging;
125using namespace sdbusplus::xyz::openbmc_project::Common::Error;
Marri Devender Rao81719702018-05-07 00:53:48 -0500126using namespace sdbusplus::xyz::openbmc_project::Control::Boot::server;
William A. Kennington III4c008022018-10-12 17:18:14 -0700127
Deepak Kodihalli8cc19362017-07-21 11:18:38 -0500128namespace chassis
129{
130namespace internal
131{
132
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +0300133constexpr auto bootSettingsPath = "/xyz/openbmc_project/control/host0/boot";
134constexpr auto bootEnableIntf = "xyz.openbmc_project.Object.Enable";
Deepak Kodihalli8cc19362017-07-21 11:18:38 -0500135constexpr auto bootModeIntf = "xyz.openbmc_project.Control.Boot.Mode";
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +0300136constexpr auto bootTypeIntf = "xyz.openbmc_project.Control.Boot.Type";
Deepak Kodihalli8cc19362017-07-21 11:18:38 -0500137constexpr auto bootSourceIntf = "xyz.openbmc_project.Control.Boot.Source";
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +0300138constexpr auto bootSettingsOneTimePath =
139 "/xyz/openbmc_project/control/host0/boot/one_time";
140constexpr auto bootOneTimeIntf = "xyz.openbmc_project.Object.Enable";
141
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500142constexpr auto powerRestoreIntf =
143 "xyz.openbmc_project.Control.Power.RestorePolicy";
Deepak Kodihalli8cc19362017-07-21 11:18:38 -0500144sdbusplus::bus::bus dbus(ipmid_get_sd_bus_connection());
145
146namespace cache
147{
148
James Feist225dec82019-11-26 16:25:06 -0800149std::unique_ptr<settings::Objects> objectsPtr = nullptr;
150
151settings::Objects& getObjects()
152{
153 if (objectsPtr == nullptr)
154 {
155 objectsPtr = std::make_unique<settings::Objects>(
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +0300156 dbus, std::vector<std::string>{bootModeIntf, bootTypeIntf,
157 bootSourceIntf, powerRestoreIntf});
James Feist225dec82019-11-26 16:25:06 -0800158 }
159 return *objectsPtr;
160}
Deepak Kodihalli8cc19362017-07-21 11:18:38 -0500161
162} // namespace cache
163} // namespace internal
164} // namespace chassis
165
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500166namespace poh
167{
168
169constexpr auto minutesPerCount = 60;
170
171} // namespace poh
172
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000173int getHostNetworkData(ipmi::message::Payload& payload)
Ratan Guptafd28dd72016-08-01 04:58:01 -0500174{
Ratan Guptadcb10672017-07-10 10:33:50 +0530175 ipmi::PropertyMap properties;
176 int rc = 0;
Ratan Gupta8c31d232017-08-13 05:49:43 +0530177 uint8_t addrSize = ipmi::network::IPV4_ADDRESS_SIZE_BYTE;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500178
Ratan Guptadcb10672017-07-10 10:33:50 +0530179 try
180 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700181 // TODO There may be cases where an interface is implemented by multiple
Ratan Guptadcb10672017-07-10 10:33:50 +0530182 // objects,to handle such cases we are interested on that object
183 // which are on interested busname.
184 // Currenlty mapper doesn't give the readable busname(gives busid)
185 // so we can't match with bus name so giving some object specific info
186 // as SETTINGS_MATCH.
187 // Later SETTINGS_MATCH will be replaced with busname.
Ratan Guptafd28dd72016-08-01 04:58:01 -0500188
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530189 sdbusplus::bus::bus bus(ipmid_get_sd_bus_connection());
Ratan Guptadcb10672017-07-10 10:33:50 +0530190
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530191 auto ipObjectInfo = ipmi::getDbusObject(bus, IP_INTERFACE,
192 SETTINGS_ROOT, SETTINGS_MATCH);
193
194 auto macObjectInfo = ipmi::getDbusObject(bus, MAC_INTERFACE,
195 SETTINGS_ROOT, SETTINGS_MATCH);
196
Patrick Venture0b02be92018-08-31 11:55:55 -0700197 properties = ipmi::getAllDbusProperties(
198 bus, ipObjectInfo.second, ipObjectInfo.first, IP_INTERFACE);
199 auto variant = ipmi::getDbusProperty(bus, macObjectInfo.second,
200 macObjectInfo.first, MAC_INTERFACE,
201 "MACAddress");
Ratan Guptadcb10672017-07-10 10:33:50 +0530202
Vernon Maueryf442e112019-04-09 11:44:36 -0700203 auto ipAddress = std::get<std::string>(properties["Address"]);
Ratan Guptad70f4532017-08-04 02:07:31 +0530204
Vernon Maueryf442e112019-04-09 11:44:36 -0700205 auto gateway = std::get<std::string>(properties["Gateway"]);
Ratan Guptad70f4532017-08-04 02:07:31 +0530206
Vernon Maueryf442e112019-04-09 11:44:36 -0700207 auto prefix = std::get<uint8_t>(properties["PrefixLength"]);
Ratan Guptad70f4532017-08-04 02:07:31 +0530208
Patrick Venture0b02be92018-08-31 11:55:55 -0700209 uint8_t isStatic =
Vernon Maueryf442e112019-04-09 11:44:36 -0700210 (std::get<std::string>(properties["Origin"]) ==
Patrick Venture0b02be92018-08-31 11:55:55 -0700211 "xyz.openbmc_project.Network.IP.AddressOrigin.Static")
212 ? 1
213 : 0;
Ratan Guptad70f4532017-08-04 02:07:31 +0530214
Vernon Maueryf442e112019-04-09 11:44:36 -0700215 auto MACAddress = std::get<std::string>(variant);
Ratan Guptacc8feb42017-07-25 21:52:10 +0530216
Ratan Guptad70f4532017-08-04 02:07:31 +0530217 // it is expected here that we should get the valid data
218 // but we may also get the default values.
219 // Validation of the data is done by settings.
220 //
221 // if mac address is default mac address then
222 // don't send blank override.
Ratan Gupta8c31d232017-08-13 05:49:43 +0530223 if ((MACAddress == ipmi::network::DEFAULT_MAC_ADDRESS))
Ratan Guptad70f4532017-08-04 02:07:31 +0530224 {
Ratan Guptad70f4532017-08-04 02:07:31 +0530225 rc = -1;
226 return rc;
227 }
228 // if addr is static then ipaddress,gateway,prefix
229 // should not be default one,don't send blank override.
230 if (isStatic)
231 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700232 if ((ipAddress == ipmi::network::DEFAULT_ADDRESS) ||
233 (gateway == ipmi::network::DEFAULT_ADDRESS) || (!prefix))
Ratan Guptad70f4532017-08-04 02:07:31 +0530234 {
Ratan Guptad70f4532017-08-04 02:07:31 +0530235 rc = -1;
236 return rc;
237 }
238 }
239
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000240 std::string token;
241 std::stringstream ss(MACAddress);
Ratan Guptadcb10672017-07-10 10:33:50 +0530242
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000243 // First pack macOffset no of bytes in payload.
244 // Latter this PetiBoot-Specific data will be populated.
245 std::vector<uint8_t> payloadInitialBytes(macOffset);
246 payload.pack(payloadInitialBytes);
Ratan Guptadcb10672017-07-10 10:33:50 +0530247
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000248 while (std::getline(ss, token, ':'))
249 {
250 payload.pack(stoi(token, nullptr, 16));
251 }
252
253 payload.pack(0x00);
254
255 payload.pack(isStatic);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530256
Vernon Maueryf442e112019-04-09 11:44:36 -0700257 uint8_t addressFamily = (std::get<std::string>(properties["Type"]) ==
258 "xyz.openbmc_project.Network.IP.Protocol.IPv4")
259 ? AF_INET
260 : AF_INET6;
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530261
Patrick Venture0b02be92018-08-31 11:55:55 -0700262 addrSize = (addressFamily == AF_INET)
263 ? ipmi::network::IPV4_ADDRESS_SIZE_BYTE
264 : ipmi::network::IPV6_ADDRESS_SIZE_BYTE;
Ratan Guptadcb10672017-07-10 10:33:50 +0530265
266 // ipaddress and gateway would be in IPv4 format
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000267 std::vector<uint8_t> addrInBinary(addrSize);
Ratan Guptad70f4532017-08-04 02:07:31 +0530268 inet_pton(addressFamily, ipAddress.c_str(),
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000269 reinterpret_cast<void*>(addrInBinary.data()));
Ratan Guptadcb10672017-07-10 10:33:50 +0530270
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000271 payload.pack(addrInBinary);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530272
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000273 payload.pack(prefix);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530274
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000275 std::vector<uint8_t> gatewayDetails(addrSize);
Ratan Guptad70f4532017-08-04 02:07:31 +0530276 inet_pton(addressFamily, gateway.c_str(),
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000277 reinterpret_cast<void*>(gatewayDetails.data()));
278 payload.pack(gatewayDetails);
Ratan Guptadcb10672017-07-10 10:33:50 +0530279 }
280 catch (InternalFailure& e)
281 {
282 commit<InternalFailure>();
Ratan Guptadcb10672017-07-10 10:33:50 +0530283 rc = -1;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500284 return rc;
285 }
286
Patrick Venture0b02be92018-08-31 11:55:55 -0700287 // PetiBoot-Specific
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000288 // If success then copy the first 9 bytes to the payload message
289 // payload first 2 bytes contain the parameter values. Skip that 2 bytes.
290 uint8_t skipFirstTwoBytes = 2;
291 size_t payloadSize = payload.size();
292 uint8_t* configDataStartingAddress = payload.data() + skipFirstTwoBytes;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500293
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000294 if (payloadSize < skipFirstTwoBytes + sizeof(netConfInitialBytes))
295 {
296 log<level::ERR>("Invalid net config ");
297 rc = -1;
298 return rc;
299 }
300 std::copy(netConfInitialBytes,
301 netConfInitialBytes + sizeof(netConfInitialBytes),
302 configDataStartingAddress);
303
304 if (payloadSize < skipFirstTwoBytes + addrSizeOffset + sizeof(addrSize))
305 {
306 log<level::ERR>("Invalid length of address size");
307 rc = -1;
308 return rc;
309 }
310 std::copy(&addrSize, &(addrSize) + sizeof(addrSize),
311 configDataStartingAddress + addrSizeOffset);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530312
Ratan Guptafd28dd72016-08-01 04:58:01 -0500313#ifdef _IPMI_DEBUG_
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700314 std::printf("\n===Printing the IPMI Formatted Data========\n");
Ratan Guptafd28dd72016-08-01 04:58:01 -0500315
Ratan Guptadcb10672017-07-10 10:33:50 +0530316 for (uint8_t pos = 0; pos < index; pos++)
317 {
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000318 std::printf("%02x ", payloadStartingAddress[pos]);
Ratan Guptadcb10672017-07-10 10:33:50 +0530319 }
Ratan Guptafd28dd72016-08-01 04:58:01 -0500320#endif
321
Ratan Guptafd28dd72016-08-01 04:58:01 -0500322 return rc;
323}
324
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530325/** @brief convert IPv4 and IPv6 addresses from binary to text form.
326 * @param[in] family - IPv4/Ipv6
327 * @param[in] data - req data pointer.
328 * @param[in] offset - offset in the data.
329 * @param[in] addrSize - size of the data which needs to be read from offset.
330 * @returns address in text form.
331 */
332
Patrick Venture0b02be92018-08-31 11:55:55 -0700333std::string getAddrStr(uint8_t family, uint8_t* data, uint8_t offset,
334 uint8_t addrSize)
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530335{
336 char ipAddr[INET6_ADDRSTRLEN] = {};
337
Patrick Venture0b02be92018-08-31 11:55:55 -0700338 switch (family)
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530339 {
340 case AF_INET:
341 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700342 struct sockaddr_in addr4
343 {
344 };
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700345 std::memcpy(&addr4.sin_addr.s_addr, &data[offset], addrSize);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530346
Patrick Venture0b02be92018-08-31 11:55:55 -0700347 inet_ntop(AF_INET, &addr4.sin_addr, ipAddr, INET_ADDRSTRLEN);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530348
349 break;
350 }
351 case AF_INET6:
352 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700353 struct sockaddr_in6 addr6
354 {
355 };
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
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530531 sdbusplus::bus::bus bus(ipmid_get_sd_bus_connection());
532
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 }
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000555 catch (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{
567 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
568
Patrick Venture0b02be92018-08-31 11:55:55 -0700569 auto chassisStateObj =
570 ipmi::getDbusObject(bus, chassisPOHStateIntf, chassisStateRoot, match);
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500571
Patrick Venture0b02be92018-08-31 11:55:55 -0700572 auto service =
573 ipmi::getService(bus, chassisPOHStateIntf, chassisStateObj.first);
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500574
Patrick Venture0b02be92018-08-31 11:55:55 -0700575 auto propValue =
576 ipmi::getDbusProperty(bus, service, chassisStateObj.first,
Patrick Williams7345ac42021-04-30 20:57:39 -0500577 chassisPOHStateIntf, 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 {
608 sdbusplus::bus::bus 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
anil kumar appana43263c62019-05-27 12:45:04 +0000625 properties =
626 ipmi::getAllDbusProperties(bus, chassisCapObject.second,
627 chassisCapObject.first, chassisCapIntf);
Yong Liae4b0402018-11-02 11:12:14 +0800628 }
629 catch (std::exception& e)
630 {
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
732 // check input data
anil kumar appana894d0222019-05-27 16:32:14 +0000733 if (reserved1 != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800734 {
anil kumar appana894d0222019-05-27 16:32:14 +0000735 log<level::ERR>("Unsupported request parameter");
736 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800737 }
738
anil kumar appana894d0222019-05-27 16:32:14 +0000739 if ((fruDeviceAddr & ~chassisCapAddrMask) != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800740 {
741 log<level::ERR>("Unsupported request parameter(FRU Addr)",
anil kumar appana894d0222019-05-27 16:32:14 +0000742 entry("REQ=0x%x", fruDeviceAddr));
743 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800744 }
anil kumar appana894d0222019-05-27 16:32:14 +0000745 if ((sdrDeviceAddr & ~chassisCapAddrMask) != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800746 {
747 log<level::ERR>("Unsupported request parameter(SDR Addr)",
anil kumar appana894d0222019-05-27 16:32:14 +0000748 entry("REQ=0x%x", sdrDeviceAddr));
749 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800750 }
751
anil kumar appana894d0222019-05-27 16:32:14 +0000752 if ((selDeviceAddr & ~chassisCapAddrMask) != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800753 {
754 log<level::ERR>("Unsupported request parameter(SEL Addr)",
anil kumar appana894d0222019-05-27 16:32:14 +0000755 entry("REQ=0x%x", selDeviceAddr));
756 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800757 }
758
anil kumar appana894d0222019-05-27 16:32:14 +0000759 if ((smDeviceAddr & ~chassisCapAddrMask) != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800760 {
anil kumar appana894d0222019-05-27 16:32:14 +0000761 log<level::ERR>("Unsupported request parameter(SM Addr)",
762 entry("REQ=0x%x", smDeviceAddr));
763 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800764 }
765
anil kumar appana894d0222019-05-27 16:32:14 +0000766 if ((bridgeDeviceAddr & ~chassisCapAddrMask) != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800767 {
768 log<level::ERR>("Unsupported request parameter(Bridge Addr)",
anil kumar appana894d0222019-05-27 16:32:14 +0000769 entry("REQ=0x%x", bridgeDeviceAddr));
770 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800771 }
772
773 try
774 {
775 sdbusplus::bus::bus bus(ipmid_get_sd_bus_connection());
776 ipmi::DbusObjectInfo chassisCapObject =
777 ipmi::getDbusObject(bus, chassisCapIntf);
778
779 ipmi::setDbusProperty(bus, chassisCapObject.second,
780 chassisCapObject.first, chassisCapIntf,
Karthick Sundarrajan86d8bd72019-11-26 12:48:50 -0800781 chassisIntrusionProp, intrusion);
782
783 ipmi::setDbusProperty(bus, chassisCapObject.second,
784 chassisCapObject.first, chassisCapIntf,
785 chassisFrontPanelLockoutProp, fpLockout);
Yong Liae4b0402018-11-02 11:12:14 +0800786
787 ipmi::setDbusProperty(bus, chassisCapObject.second,
788 chassisCapObject.first, chassisCapIntf,
anil kumar appana894d0222019-05-27 16:32:14 +0000789 chassisFRUDevAddrProp, fruDeviceAddr);
Yong Liae4b0402018-11-02 11:12:14 +0800790
791 ipmi::setDbusProperty(bus, chassisCapObject.second,
792 chassisCapObject.first, chassisCapIntf,
anil kumar appana894d0222019-05-27 16:32:14 +0000793 chassisSDRDevAddrProp, sdrDeviceAddr);
Yong Liae4b0402018-11-02 11:12:14 +0800794
795 ipmi::setDbusProperty(bus, chassisCapObject.second,
796 chassisCapObject.first, chassisCapIntf,
anil kumar appana894d0222019-05-27 16:32:14 +0000797 chassisSELDevAddrProp, selDeviceAddr);
Yong Liae4b0402018-11-02 11:12:14 +0800798
799 ipmi::setDbusProperty(bus, chassisCapObject.second,
800 chassisCapObject.first, chassisCapIntf,
anil kumar appana894d0222019-05-27 16:32:14 +0000801 chassisSMDevAddrProp, smDeviceAddr);
Yong Liae4b0402018-11-02 11:12:14 +0800802
803 ipmi::setDbusProperty(bus, chassisCapObject.second,
804 chassisCapObject.first, chassisCapIntf,
anil kumar appana894d0222019-05-27 16:32:14 +0000805 chassisBridgeDevAddrProp, bridgeDeviceAddr);
Yong Liae4b0402018-11-02 11:12:14 +0800806 }
807 catch (std::exception& e)
808 {
809 log<level::ERR>(e.what());
anil kumar appana894d0222019-05-27 16:32:14 +0000810 return ipmi::responseUnspecifiedError();
Yong Liae4b0402018-11-02 11:12:14 +0800811 }
anil kumar appana894d0222019-05-27 16:32:14 +0000812 return ipmi::responseSuccess();
Nan Li8d15fb42016-08-16 22:29:40 +0800813}
814
Vishwanatha Subbannab12b0c02017-03-07 18:17:19 +0530815//------------------------------------------
816// Calls into Host State Manager Dbus object
817//------------------------------------------
818int initiate_state_transition(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
Patrick Venture0b02be92018-08-31 11:55:55 -0700821 constexpr auto HOST_STATE_MANAGER_ROOT = "/xyz/openbmc_project/state/host0";
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500822 constexpr auto HOST_STATE_MANAGER_IFACE = "xyz.openbmc_project.State.Host";
Patrick Venture0b02be92018-08-31 11:55:55 -0700823 constexpr auto DBUS_PROPERTY_IFACE = "org.freedesktop.DBus.Properties";
824 constexpr auto PROPERTY = "RequestedHostTransition";
Vishwanatha Subbannab12b0c02017-03-07 18:17:19 +0530825
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500826 // sd_bus error
827 int rc = 0;
Patrick Venture0b02be92018-08-31 11:55:55 -0700828 char* busname = NULL;
vishwa36993272015-11-20 12:43:49 -0600829
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500830 // SD Bus error report mechanism.
831 sd_bus_error bus_error = SD_BUS_ERROR_NULL;
vishwa36993272015-11-20 12:43:49 -0600832
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500833 // Gets a hook onto either a SYSTEM or SESSION bus
Patrick Venture0b02be92018-08-31 11:55:55 -0700834 sd_bus* bus_type = ipmid_get_sd_bus_connection();
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500835 rc = mapper_get_service(bus_type, HOST_STATE_MANAGER_ROOT, &busname);
836 if (rc < 0)
837 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700838 log<level::ERR>(
839 "Failed to get bus name",
840 entry("ERRNO=0x%X, OBJPATH=%s", -rc, HOST_STATE_MANAGER_ROOT));
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500841 return rc;
842 }
Vishwanatha Subbannab12b0c02017-03-07 18:17:19 +0530843
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500844 // Convert to string equivalent of the passed in transition enum.
845 auto request = State::convertForMessage(transition);
Vishwanatha Subbannab12b0c02017-03-07 18:17:19 +0530846
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500847 rc = sd_bus_call_method(bus_type, // On the system bus
848 busname, // Service to contact
849 HOST_STATE_MANAGER_ROOT, // Object path
850 DBUS_PROPERTY_IFACE, // Interface name
851 "Set", // Method to be called
852 &bus_error, // object to return error
853 nullptr, // Response buffer if any
854 "ssv", // Takes 3 arguments
Patrick Venture0b02be92018-08-31 11:55:55 -0700855 HOST_STATE_MANAGER_IFACE, PROPERTY, "s",
856 request.c_str());
857 if (rc < 0)
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500858 {
859 log<level::ERR>("Failed to initiate transition",
Aditya Saripalli5fb14602017-11-09 14:46:27 +0530860 entry("ERRNO=0x%X, REQUEST=%s", -rc, request.c_str()));
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500861 }
862 else
863 {
864 log<level::INFO>("Transition request initiated successfully");
865 }
vishwa36993272015-11-20 12:43:49 -0600866
867 sd_bus_error_free(&bus_error);
Sergey Solomineb9b8142016-08-23 09:07:28 -0500868 free(busname);
vishwa36993272015-11-20 12:43:49 -0600869
Sergey Solomineb9b8142016-08-23 09:07:28 -0500870 return rc;
vishwa36993272015-11-20 12:43:49 -0600871}
872
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +0800873//------------------------------------------
874// Set Enabled property to inform NMI source
875// handling to trigger a NMI_OUT BSOD.
876//------------------------------------------
877int setNmiProperty(const bool value)
878{
879 constexpr const char* nmiSourceObjPath =
880 "/xyz/openbmc_project/Chassis/Control/NMISource";
881 constexpr const char* nmiSourceIntf =
882 "xyz.openbmc_project.Chassis.Control.NMISource";
883 std::string bmcSourceSignal = "xyz.openbmc_project.Chassis.Control."
884 "NMISource.BMCSourceSignal.ChassisCmd";
885 std::shared_ptr<sdbusplus::asio::connection> busp = getSdBus();
886
887 try
888 {
889 auto service = ipmi::getService(*busp, nmiSourceIntf, nmiSourceObjPath);
890 ipmi::setDbusProperty(*busp, service, nmiSourceObjPath, nmiSourceIntf,
891 "BMCSource", bmcSourceSignal);
892 ipmi::setDbusProperty(*busp, service, nmiSourceObjPath, nmiSourceIntf,
893 "Enabled", value);
894 }
895 catch (std::exception& e)
896 {
897 log<level::ERR>("Failed to trigger NMI_OUT",
898 entry("EXCEPTION=%s", e.what()));
899 return -1;
900 }
901
902 return 0;
903}
904
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500905namespace power_policy
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500906{
Nan Lifdd8ec52016-08-28 03:57:40 +0800907
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500908using namespace sdbusplus::xyz::openbmc_project::Control::Power::server;
909using IpmiValue = uint8_t;
910using DbusValue = RestorePolicy::Policy;
Nan Lifdd8ec52016-08-28 03:57:40 +0800911
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700912const std::map<DbusValue, IpmiValue> dbusToIpmi = {
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500913 {RestorePolicy::Policy::AlwaysOff, 0x00},
914 {RestorePolicy::Policy::Restore, 0x01},
Patrick Venture0b02be92018-08-31 11:55:55 -0700915 {RestorePolicy::Policy::AlwaysOn, 0x02}};
Nan Lifdd8ec52016-08-28 03:57:40 +0800916
Yong Lic6713cf2018-09-12 12:35:13 +0800917static constexpr uint8_t noChange = 0x03;
918static constexpr uint8_t allSupport = 0x01 | 0x02 | 0x04;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700919
920/* helper function for Get Chassis Status Command
921 */
922std::optional<uint2_t> getPowerRestorePolicy()
923{
924 uint2_t restorePolicy = 0;
925 using namespace chassis::internal;
926
James Feist225dec82019-11-26 16:25:06 -0800927 settings::Objects& objects = cache::getObjects();
928
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700929 try
930 {
931 const auto& powerRestoreSetting =
James Feist225dec82019-11-26 16:25:06 -0800932 objects.map.at(powerRestoreIntf).front();
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700933 ipmi::Value result = ipmi::getDbusProperty(
934 *getSdBus(),
James Feist225dec82019-11-26 16:25:06 -0800935 objects.service(powerRestoreSetting, powerRestoreIntf).c_str(),
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700936 powerRestoreSetting.c_str(), powerRestoreIntf,
937 "PowerRestorePolicy");
938 auto powerRestore = RestorePolicy::convertPolicyFromString(
939 std::get<std::string>(result));
940 restorePolicy = dbusToIpmi.at(powerRestore);
941 }
942 catch (const std::exception& e)
943 {
944 log<level::ERR>(
945 "Failed to fetch pgood property", entry("ERROR=%s", e.what()),
James Feist225dec82019-11-26 16:25:06 -0800946 entry("PATH=%s", objects.map.at(powerRestoreIntf).front().c_str()),
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700947 entry("INTERFACE=%s", powerRestoreIntf));
James Feist225dec82019-11-26 16:25:06 -0800948 cache::objectsPtr.reset();
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700949 return std::nullopt;
950 }
951 return std::make_optional(restorePolicy);
952}
953
954/*
955 * getPowerStatus
956 * helper function for Get Chassis Status Command
957 * return - optional value for pgood (no value on error)
958 */
959std::optional<bool> getPowerStatus()
960{
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700961 bool powerGood = false;
962 std::shared_ptr<sdbusplus::asio::connection> busp = getSdBus();
963 try
964 {
Jason M. Bills3de424c2019-05-21 09:57:16 -0700965 constexpr const char* chassisStatePath =
966 "/xyz/openbmc_project/state/chassis0";
967 constexpr const char* chassisStateIntf =
968 "xyz.openbmc_project.State.Chassis";
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700969 auto service =
Jason M. Bills3de424c2019-05-21 09:57:16 -0700970 ipmi::getService(*busp, chassisStateIntf, chassisStatePath);
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700971
Jason M. Bills3de424c2019-05-21 09:57:16 -0700972 ipmi::Value powerState =
973 ipmi::getDbusProperty(*busp, service, chassisStatePath,
974 chassisStateIntf, "CurrentPowerState");
975 powerGood = std::get<std::string>(powerState) ==
976 "xyz.openbmc_project.State.Chassis.PowerState.On";
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700977 }
978 catch (const std::exception& e)
979 {
980 try
981 {
982 // FIXME: some legacy modules use the older path; try that next
983 constexpr const char* legacyPwrCtrlObj =
984 "/org/openbmc/control/power0";
985 constexpr const char* legacyPwrCtrlIntf =
986 "org.openbmc.control.Power";
987 auto service =
988 ipmi::getService(*busp, legacyPwrCtrlIntf, legacyPwrCtrlObj);
989
990 ipmi::Value variant = ipmi::getDbusProperty(
991 *busp, service, legacyPwrCtrlObj, legacyPwrCtrlIntf, "pgood");
992 powerGood = static_cast<bool>(std::get<int>(variant));
993 }
994 catch (const std::exception& e)
995 {
996 log<level::ERR>("Failed to fetch pgood property",
Jason M. Bills3de424c2019-05-21 09:57:16 -0700997 entry("ERROR=%s", e.what()));
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700998 return std::nullopt;
999 }
1000 }
1001 return std::make_optional(powerGood);
1002}
1003
Yong Li70ce7352019-05-16 21:15:27 +08001004/*
1005 * getACFailStatus
1006 * helper function for Get Chassis Status Command
1007 * return - bool value for ACFail (false on error)
1008 */
1009bool getACFailStatus()
1010{
1011 constexpr const char* powerControlObj =
1012 "/xyz/openbmc_project/Chassis/Control/Power0";
1013 constexpr const char* powerControlIntf =
1014 "xyz.openbmc_project.Chassis.Control.Power";
1015 bool acFail = false;
1016 std::shared_ptr<sdbusplus::asio::connection> bus = getSdBus();
1017 try
1018 {
1019 auto service =
1020 ipmi::getService(*bus, powerControlIntf, powerControlObj);
1021
1022 ipmi::Value variant = ipmi::getDbusProperty(
1023 *bus, service, powerControlObj, powerControlIntf, "PFail");
1024 acFail = std::get<bool>(variant);
1025 }
1026 catch (const std::exception& e)
1027 {
1028 log<level::ERR>("Failed to fetch PFail property",
1029 entry("ERROR=%s", e.what()),
1030 entry("PATH=%s", powerControlObj),
1031 entry("INTERFACE=%s", powerControlIntf));
1032 }
1033 return acFail;
1034}
Deepak Kodihalli18b70d12017-07-21 13:36:33 -05001035} // namespace power_policy
Nan Lifdd8ec52016-08-28 03:57:40 +08001036
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001037static std::optional<bool> getButtonEnabled(const std::string& buttonPath,
1038 const std::string& buttonIntf)
1039{
1040 std::shared_ptr<sdbusplus::asio::connection> busp = getSdBus();
1041 bool buttonDisabled = false;
1042 try
1043 {
1044 auto service = ipmi::getService(*busp, buttonIntf, buttonPath);
1045 ipmi::Value enabled = ipmi::getDbusProperty(*busp, service, buttonPath,
1046 buttonIntf, "Enabled");
1047 buttonDisabled = !std::get<bool>(enabled);
1048 }
1049 catch (sdbusplus::exception::SdBusError& e)
1050 {
1051 log<level::ERR>("Fail to get button Enabled property",
1052 entry("PATH=%s", buttonPath.c_str()),
1053 entry("ERROR=%s", e.what()));
1054 return std::nullopt;
1055 }
1056 return std::make_optional(buttonDisabled);
1057}
1058
Kuiying Wang21addc52019-01-04 10:50:21 +08001059static bool setButtonEnabled(ipmi::Context::ptr& ctx,
1060 const std::string& buttonPath,
1061 const std::string& buttonIntf, bool enable)
1062{
1063 std::string service;
1064 boost::system::error_code ec;
1065 ec = ipmi::getService(ctx, buttonIntf, buttonPath, service);
1066 if (!ec)
1067 {
1068 ec = ipmi::setDbusProperty(ctx, service, buttonPath, buttonIntf,
1069 "Enabled", enable);
1070 }
1071 if (ec)
1072 {
1073 log<level::ERR>("Fail to set button Enabled property",
1074 entry("SERVICE=%s", service.c_str()),
1075 entry("PATH=%s", buttonPath.c_str()),
1076 entry("ERROR=%s", ec.message().c_str()));
1077 return false;
1078 }
1079 return true;
1080}
1081
Nan Lifdd8ec52016-08-28 03:57:40 +08001082//----------------------------------------------------------------------
1083// Get Chassis Status commands
1084//----------------------------------------------------------------------
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001085ipmi::RspType<bool, // Power is on
1086 bool, // Power overload
1087 bool, // Interlock
1088 bool, // power fault
1089 bool, // power control fault
1090 uint2_t, // power restore policy
1091 bool, // reserved
1092
1093 bool, // AC failed
1094 bool, // last power down caused by a Power overload
1095 bool, // last power down caused by a power interlock
1096 bool, // last power down caused by power fault
1097 bool, // last ‘Power is on’ state was entered via IPMI command
1098 uint3_t, // reserved
1099
1100 bool, // Chassis intrusion active
1101 bool, // Front Panel Lockout active
1102 bool, // Drive Fault
1103 bool, // Cooling/fan fault detected
1104 uint2_t, // Chassis Identify State
1105 bool, // Chassis Identify command and state info supported
1106 bool, // reserved
1107
1108 bool, // Power off button disabled
1109 bool, // Reset button disabled
1110 bool, // Diagnostic Interrupt button disabled
1111 bool, // Standby (sleep) button disabled
1112 bool, // Power off button disable allowed
1113 bool, // Reset button disable allowed
1114 bool, // Diagnostic Interrupt button disable allowed
1115 bool // Standby (sleep) button disable allowed
1116 >
1117 ipmiGetChassisStatus()
Nan Lifdd8ec52016-08-28 03:57:40 +08001118{
Deepak Kodihalli18b70d12017-07-21 13:36:33 -05001119 using namespace chassis::internal;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001120 std::optional<uint2_t> restorePolicy =
1121 power_policy::getPowerRestorePolicy();
1122 std::optional<bool> powerGood = power_policy::getPowerStatus();
1123 if (!restorePolicy || !powerGood)
Deepak Kodihalli18b70d12017-07-21 13:36:33 -05001124 {
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001125 return ipmi::responseUnspecifiedError();
Deepak Kodihalli18b70d12017-07-21 13:36:33 -05001126 }
Nan Lifdd8ec52016-08-28 03:57:40 +08001127
1128 // Front Panel Button Capabilities and disable/enable status(Optional)
Vernon Mauery6d5b2f72019-05-16 14:48:47 -07001129 std::optional<bool> powerButtonReading =
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001130 getButtonEnabled(powerButtonPath, powerButtonIntf);
Vernon Mauery6d5b2f72019-05-16 14:48:47 -07001131 // allow disable if the interface is present
1132 bool powerButtonDisableAllow = static_cast<bool>(powerButtonReading);
1133 // default return the button is enabled (not disabled)
1134 bool powerButtonDisabled = false;
1135 if (powerButtonDisableAllow)
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001136 {
Vernon Mauery6d5b2f72019-05-16 14:48:47 -07001137 // return the real value of the button status, if present
1138 powerButtonDisabled = *powerButtonReading;
1139 }
1140
1141 std::optional<bool> resetButtonReading =
1142 getButtonEnabled(resetButtonPath, resetButtonIntf);
1143 // allow disable if the interface is present
1144 bool resetButtonDisableAllow = static_cast<bool>(resetButtonReading);
1145 // default return the button is enabled (not disabled)
1146 bool resetButtonDisabled = false;
1147 if (resetButtonDisableAllow)
1148 {
1149 // return the real value of the button status, if present
1150 resetButtonDisabled = *resetButtonReading;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001151 }
Nan Lifdd8ec52016-08-28 03:57:40 +08001152
Yong Li70ce7352019-05-16 21:15:27 +08001153 bool powerDownAcFailed = power_policy::getACFailStatus();
1154
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001155 // This response has a lot of hard-coded, unsupported fields
1156 // They are set to false or 0
1157 constexpr bool powerOverload = false;
1158 constexpr bool chassisInterlock = false;
1159 constexpr bool powerFault = false;
1160 constexpr bool powerControlFault = false;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001161 constexpr bool powerDownOverload = false;
1162 constexpr bool powerDownInterlock = false;
1163 constexpr bool powerDownPowerFault = false;
1164 constexpr bool powerStatusIPMI = false;
1165 constexpr bool chassisIntrusionActive = false;
1166 constexpr bool frontPanelLockoutActive = false;
1167 constexpr bool driveFault = false;
1168 constexpr bool coolingFanFault = false;
1169 // chassisIdentifySupport set because this command is implemented
1170 constexpr bool chassisIdentifySupport = true;
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001171 uint2_t chassisIdentifyState = types::enum_cast<uint2_t>(chassisIDState);
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001172 constexpr bool diagButtonDisabled = false;
1173 constexpr bool sleepButtonDisabled = false;
1174 constexpr bool diagButtonDisableAllow = false;
1175 constexpr bool sleepButtonDisableAllow = false;
1176
1177 return ipmi::responseSuccess(
1178 *powerGood, powerOverload, chassisInterlock, powerFault,
1179 powerControlFault, *restorePolicy,
1180 false, // reserved
1181
1182 powerDownAcFailed, powerDownOverload, powerDownInterlock,
1183 powerDownPowerFault, powerStatusIPMI,
1184 uint3_t(0), // reserved
1185
1186 chassisIntrusionActive, frontPanelLockoutActive, driveFault,
1187 coolingFanFault, chassisIdentifyState, chassisIdentifySupport,
1188 false, // reserved
1189
Vernon Mauery6d5b2f72019-05-16 14:48:47 -07001190 powerButtonDisabled, resetButtonDisabled, diagButtonDisabled,
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001191 sleepButtonDisabled, powerButtonDisableAllow, resetButtonDisableAllow,
1192 diagButtonDisableAllow, sleepButtonDisableAllow);
Nan Lifdd8ec52016-08-28 03:57:40 +08001193}
Chris Austen7888c4d2015-12-03 15:26:20 -06001194
Vijay Khemka074f64d2020-03-03 15:08:43 -08001195enum class IpmiRestartCause
1196{
1197 Unknown = 0x0,
1198 RemoteCommand = 0x1,
1199 ResetButton = 0x2,
1200 PowerButton = 0x3,
1201 WatchdogTimer = 0x4,
1202 PowerPolicyAlwaysOn = 0x6,
1203 PowerPolicyPreviousState = 0x7,
1204 SoftReset = 0xa,
1205};
1206
1207static IpmiRestartCause
1208 restartCauseToIpmiRestartCause(State::Host::RestartCause cause)
1209{
1210 switch (cause)
1211 {
1212 case State::Host::RestartCause::Unknown:
1213 {
1214 return IpmiRestartCause::Unknown;
1215 }
1216 case State::Host::RestartCause::RemoteCommand:
1217 {
1218 return IpmiRestartCause::RemoteCommand;
1219 }
1220 case State::Host::RestartCause::ResetButton:
1221 {
1222 return IpmiRestartCause::ResetButton;
1223 }
1224 case State::Host::RestartCause::PowerButton:
1225 {
1226 return IpmiRestartCause::PowerButton;
1227 }
1228 case State::Host::RestartCause::WatchdogTimer:
1229 {
1230 return IpmiRestartCause::WatchdogTimer;
1231 }
1232 case State::Host::RestartCause::PowerPolicyAlwaysOn:
1233 {
1234 return IpmiRestartCause::PowerPolicyAlwaysOn;
1235 }
1236 case State::Host::RestartCause::PowerPolicyPreviousState:
1237 {
1238 return IpmiRestartCause::PowerPolicyPreviousState;
1239 }
1240 case State::Host::RestartCause::SoftReset:
1241 {
1242 return IpmiRestartCause::SoftReset;
1243 }
1244 default:
1245 {
1246 return IpmiRestartCause::Unknown;
1247 }
1248 }
1249}
1250
1251/*
1252 * getRestartCause
1253 * helper function for Get Host restart cause Command
1254 * return - optional value for RestartCause (no value on error)
1255 */
1256static std::optional<uint4_t> getRestartCause(ipmi::Context::ptr ctx)
1257{
1258 constexpr const char* restartCausePath =
1259 "/xyz/openbmc_project/control/host0/restart_cause";
1260 constexpr const char* restartCauseIntf =
1261 "xyz.openbmc_project.Control.Host.RestartCause";
1262
1263 std::string service;
1264 boost::system::error_code ec =
1265 ipmi::getService(ctx, restartCauseIntf, restartCausePath, service);
1266 if (!ec)
1267 {
1268 std::string restartCauseStr;
1269 ec = ipmi::getDbusProperty<std::string>(
1270 ctx, service, restartCausePath, restartCauseIntf, "RestartCause",
1271 restartCauseStr);
1272 if (!ec)
1273 {
1274 auto cause =
1275 State::Host::convertRestartCauseFromString(restartCauseStr);
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001276 return types::enum_cast<uint4_t>(
1277 restartCauseToIpmiRestartCause(cause));
Vijay Khemka074f64d2020-03-03 15:08:43 -08001278 }
1279 }
1280
1281 log<level::ERR>("Failed to fetch RestartCause property",
1282 entry("ERROR=%s", ec.message().c_str()),
1283 entry("PATH=%s", restartCausePath),
1284 entry("INTERFACE=%s", restartCauseIntf));
1285 return std::nullopt;
1286}
1287
1288ipmi::RspType<uint4_t, // Restart Cause
1289 uint4_t, // reserved
1290 uint8_t // channel number (not supported)
1291 >
1292 ipmiGetSystemRestartCause(ipmi::Context::ptr ctx)
1293{
1294 std::optional<uint4_t> cause = getRestartCause(ctx);
1295 if (!cause)
1296 {
1297 return ipmi::responseUnspecifiedError();
1298 }
1299
Vernon Mauery916d4232021-03-29 13:42:16 -07001300 constexpr uint4_t reserved = 0;
1301 auto channel = static_cast<uint8_t>(ctx->channel);
1302 return ipmi::responseSuccess(cause.value(), reserved, channel);
Vijay Khemka074f64d2020-03-03 15:08:43 -08001303}
1304
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301305//-------------------------------------------------------------
1306// Send a command to SoftPowerOff application to stop any timer
1307//-------------------------------------------------------------
1308int stop_soft_off_timer()
1309{
Patrick Venture0b02be92018-08-31 11:55:55 -07001310 constexpr auto iface = "org.freedesktop.DBus.Properties";
1311 constexpr auto soft_off_iface = "xyz.openbmc_project.Ipmi.Internal."
1312 "SoftPowerOff";
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301313
Patrick Venture0b02be92018-08-31 11:55:55 -07001314 constexpr auto property = "ResponseReceived";
1315 constexpr auto value = "xyz.openbmc_project.Ipmi.Internal."
1316 "SoftPowerOff.HostResponse.HostShutdown";
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301317
1318 // Get the system bus where most system services are provided.
1319 auto bus = ipmid_get_sd_bus_connection();
1320
1321 // Get the service name
Andrew Geissler2b4e4592017-06-08 11:18:35 -05001322 // TODO openbmc/openbmc#1661 - Mapper refactor
1323 //
1324 // See openbmc/openbmc#1743 for some details but high level summary is that
1325 // for now the code will directly call the soft off interface due to a
1326 // race condition with mapper usage
1327 //
Patrick Venture0b02be92018-08-31 11:55:55 -07001328 // char *busname = nullptr;
1329 // auto r = mapper_get_service(bus, SOFTOFF_OBJPATH, &busname);
1330 // if (r < 0)
Andrew Geissler2b4e4592017-06-08 11:18:35 -05001331 //{
1332 // fprintf(stderr, "Failed to get %s bus name: %s\n",
Aditya Saripalli5fb14602017-11-09 14:46:27 +05301333 // SOFTOFF_OBJPATH, -r);
Andrew Geissler2b4e4592017-06-08 11:18:35 -05001334 // return r;
1335 //}
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301336
1337 // No error object or reply expected.
Andrew Geissler2b4e4592017-06-08 11:18:35 -05001338 int rc = sd_bus_call_method(bus, SOFTOFF_BUSNAME, SOFTOFF_OBJPATH, iface,
Patrick Venture0b02be92018-08-31 11:55:55 -07001339 "Set", nullptr, nullptr, "ssv", soft_off_iface,
1340 property, "s", value);
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301341 if (rc < 0)
1342 {
Aditya Saripalli5fb14602017-11-09 14:46:27 +05301343 log<level::ERR>("Failed to set property in SoftPowerOff object",
1344 entry("ERRNO=0x%X", -rc));
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301345 }
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001346
Patrick Venture0b02be92018-08-31 11:55:55 -07001347 // TODO openbmc/openbmc#1661 - Mapper refactor
1348 // free(busname);
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301349 return rc;
1350}
1351
vishwa36993272015-11-20 12:43:49 -06001352//----------------------------------------------------------------------
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001353// Create file to indicate there is no need for softoff notification to host
1354//----------------------------------------------------------------------
1355void indicate_no_softoff_needed()
1356{
1357 fs::path path{HOST_INBAND_REQUEST_DIR};
1358 if (!fs::is_directory(path))
1359 {
1360 fs::create_directory(path);
1361 }
1362
1363 // Add the host instance (default 0 for now) to the file name
1364 std::string file{HOST_INBAND_REQUEST_FILE};
Patrick Venture0b02be92018-08-31 11:55:55 -07001365 auto size = std::snprintf(nullptr, 0, file.c_str(), 0);
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001366 size++; // null
1367 std::unique_ptr<char[]> buf(new char[size]);
Patrick Venture0b02be92018-08-31 11:55:55 -07001368 std::snprintf(buf.get(), size, file.c_str(), 0);
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001369
1370 // Append file name to directory and create it
1371 path /= buf.get();
1372 std::ofstream(path.c_str());
1373}
1374
anil kumar appanadafff5f2019-04-27 18:06:00 +00001375/** @brief Implementation of chassis control command
1376 *
1377 * @param - chassisControl command byte
1378 *
1379 * @return Success or InvalidFieldRequest.
1380 */
1381ipmi::RspType<> ipmiChassisControl(uint8_t chassisControl)
vishwa36993272015-11-20 12:43:49 -06001382{
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001383 int rc = 0;
anil kumar appanadafff5f2019-04-27 18:06:00 +00001384 switch (chassisControl)
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001385 {
1386 case CMD_POWER_ON:
1387 rc = initiate_state_transition(State::Host::Transition::On);
1388 break;
1389 case CMD_POWER_OFF:
Vishwanatha Subbanna8b26d352017-08-04 18:35:18 +05301390 // This path would be hit in 2 conditions.
1391 // 1: When user asks for power off using ipmi chassis command 0x04
1392 // 2: Host asking for power off post shutting down.
1393
1394 // If it's a host requested power off, then need to nudge Softoff
1395 // application that it needs to stop the watchdog timer if running.
1396 // If it is a user requested power off, then this is not really
1397 // needed. But then we need to differentiate between user and host
1398 // calling this same command
1399
1400 // For now, we are going ahead with trying to nudge the soft off and
1401 // interpret the failure to do so as a non softoff case
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001402 rc = stop_soft_off_timer();
Vishwanatha Subbanna8b26d352017-08-04 18:35:18 +05301403
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001404 // Only request the Off transition if the soft power off
1405 // application is not running
1406 if (rc < 0)
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001407 {
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001408 // First create a file to indicate to the soft off application
Vishwanatha Subbanna8b26d352017-08-04 18:35:18 +05301409 // that it should not run. Not doing this will result in State
1410 // manager doing a default soft power off when asked for power
1411 // off.
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001412 indicate_no_softoff_needed();
1413
1414 // Now request the shutdown
1415 rc = initiate_state_transition(State::Host::Transition::Off);
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001416 }
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001417 else
1418 {
Vishwanatha Subbanna8b26d352017-08-04 18:35:18 +05301419 log<level::INFO>("Soft off is running, so let shutdown target "
1420 "stop the host");
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001421 }
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001422 break;
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301423
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001424 case CMD_HARD_RESET:
1425 case CMD_POWER_CYCLE:
1426 // SPEC has a section that says certain implementations can trigger
1427 // PowerOn if power is Off when a command to power cycle is
1428 // requested
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001429
1430 // First create a file to indicate to the soft off application
1431 // that it should not run since this is a direct user initiated
1432 // power reboot request (i.e. a reboot request that is not
1433 // originating via a soft power off SMS request)
1434 indicate_no_softoff_needed();
1435
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001436 rc = initiate_state_transition(State::Host::Transition::Reboot);
1437 break;
Vishwanatha Subbanna8b26d352017-08-04 18:35:18 +05301438
1439 case CMD_SOFT_OFF_VIA_OVER_TEMP:
1440 // Request Host State Manager to do a soft power off
1441 rc = initiate_state_transition(State::Host::Transition::Off);
1442 break;
1443
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +08001444 case CMD_PULSE_DIAGNOSTIC_INTR:
1445 rc = setNmiProperty(true);
1446 break;
1447
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001448 default:
1449 {
Aditya Saripalli5fb14602017-11-09 14:46:27 +05301450 log<level::ERR>("Invalid Chassis Control command",
anil kumar appanadafff5f2019-04-27 18:06:00 +00001451 entry("CMD=0x%X", chassisControl));
1452 return ipmi::responseInvalidFieldRequest();
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001453 }
1454 }
vishwa36993272015-11-20 12:43:49 -06001455
anil kumar appanadafff5f2019-04-27 18:06:00 +00001456 return ((rc < 0) ? ipmi::responseUnspecifiedError()
1457 : ipmi::responseSuccess());
vishwa36993272015-11-20 12:43:49 -06001458}
1459
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001460/** @brief Return D-Bus connection string to enclosure identify LED object
1461 *
1462 * @param[in, out] connection - connection to D-Bus object
1463 * @return a IPMI return code
1464 */
1465std::string getEnclosureIdentifyConnection()
Tom Joseph5110c122018-03-23 17:55:40 +05301466{
Tom Joseph5110c122018-03-23 17:55:40 +05301467 // lookup enclosure_identify group owner(s) in mapper
1468 auto mapperCall = chassis::internal::dbus.new_method_call(
Patrick Venture0b02be92018-08-31 11:55:55 -07001469 ipmi::MAPPER_BUS_NAME, ipmi::MAPPER_OBJ, ipmi::MAPPER_INTF,
1470 "GetObject");
Tom Joseph5110c122018-03-23 17:55:40 +05301471
1472 mapperCall.append(identify_led_object_name);
Patrick Venture0b02be92018-08-31 11:55:55 -07001473 static const std::vector<std::string> interfaces = {
1474 "xyz.openbmc_project.Led.Group"};
Tom Joseph5110c122018-03-23 17:55:40 +05301475 mapperCall.append(interfaces);
1476 auto mapperReply = chassis::internal::dbus.call(mapperCall);
1477 if (mapperReply.is_method_error())
1478 {
1479 log<level::ERR>("Chassis Identify: Error communicating to mapper.");
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001480 elog<InternalFailure>();
Tom Joseph5110c122018-03-23 17:55:40 +05301481 }
1482 std::vector<std::pair<std::string, std::vector<std::string>>> mapperResp;
1483 mapperReply.read(mapperResp);
1484
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001485 if (mapperResp.size() != encIdentifyObjectsSize)
Tom Joseph5110c122018-03-23 17:55:40 +05301486 {
Patrick Venture0b02be92018-08-31 11:55:55 -07001487 log<level::ERR>(
1488 "Invalid number of enclosure identify objects.",
1489 entry("ENC_IDENTITY_OBJECTS_SIZE=%d", mapperResp.size()));
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001490 elog<InternalFailure>();
1491 }
1492 auto pair = mapperResp[encIdentifyObjectsSize - 1];
1493 return pair.first;
1494}
Tom Joseph5110c122018-03-23 17:55:40 +05301495
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001496/** @brief Turn On/Off enclosure identify LED
1497 *
1498 * @param[in] flag - true to turn on LED, false to turn off
1499 * @return a IPMI return code
1500 */
1501void enclosureIdentifyLed(bool flag)
1502{
1503 using namespace chassis::internal;
1504 std::string connection = std::move(getEnclosureIdentifyConnection());
Vernon Mauery400cc782018-10-09 13:49:53 -07001505 auto msg = std::string("enclosureIdentifyLed(") +
1506 boost::lexical_cast<std::string>(flag) + ")";
1507 log<level::DEBUG>(msg.c_str());
Patrick Venture0b02be92018-08-31 11:55:55 -07001508 auto led =
1509 dbus.new_method_call(connection.c_str(), identify_led_object_name,
1510 "org.freedesktop.DBus.Properties", "Set");
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001511 led.append("xyz.openbmc_project.Led.Group", "Asserted",
Vernon Mauery16b86932019-05-01 08:36:11 -07001512 std::variant<bool>(flag));
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001513 auto ledReply = dbus.call(led);
1514 if (ledReply.is_method_error())
1515 {
1516 log<level::ERR>("Chassis Identify: Error Setting State On/Off\n",
Patrick Venture0b02be92018-08-31 11:55:55 -07001517 entry("LED_STATE=%d", flag));
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001518 elog<InternalFailure>();
1519 }
1520}
1521
1522/** @brief Callback method to turn off LED
1523 */
1524void enclosureIdentifyLedOff()
1525{
1526 try
1527 {
Yong Lif4e38512019-05-21 14:46:55 +08001528 chassisIDState = ChassisIDState::off;
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001529 enclosureIdentifyLed(false);
1530 }
1531 catch (const InternalFailure& e)
1532 {
1533 report<InternalFailure>();
1534 }
1535}
1536
1537/** @brief Create timer to turn on and off the enclosure LED
1538 */
1539void createIdentifyTimer()
1540{
1541 if (!identifyTimer)
1542 {
Vernon Mauery1181af72018-10-08 12:05:00 -07001543 identifyTimer =
1544 std::make_unique<phosphor::Timer>(enclosureIdentifyLedOff);
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001545 }
1546}
1547
Vernon Mauery400cc782018-10-09 13:49:53 -07001548ipmi::RspType<> ipmiChassisIdentify(std::optional<uint8_t> interval,
1549 std::optional<uint8_t> force)
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001550{
Vernon Mauery400cc782018-10-09 13:49:53 -07001551 uint8_t identifyInterval = interval.value_or(DEFAULT_IDENTIFY_TIME_OUT);
1552 bool forceIdentify = force.value_or(0) & 0x01;
Tom Josephbed26992018-07-31 23:00:24 +05301553
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001554 if (identifyInterval || forceIdentify)
1555 {
Vernon Mauery400cc782018-10-09 13:49:53 -07001556 // stop the timer if already started;
1557 // for force identify we should not turn off LED
Vernon Mauery1181af72018-10-08 12:05:00 -07001558 identifyTimer->stop();
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001559 try
Tom Joseph5110c122018-03-23 17:55:40 +05301560 {
Yong Lif4e38512019-05-21 14:46:55 +08001561 chassisIDState = ChassisIDState::temporaryOn;
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001562 enclosureIdentifyLed(true);
1563 }
1564 catch (const InternalFailure& e)
1565 {
1566 report<InternalFailure>();
Vernon Mauery400cc782018-10-09 13:49:53 -07001567 return ipmi::responseResponseError();
Tom Joseph5110c122018-03-23 17:55:40 +05301568 }
1569
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001570 if (forceIdentify)
Tom Joseph5110c122018-03-23 17:55:40 +05301571 {
Yong Lif4e38512019-05-21 14:46:55 +08001572 chassisIDState = ChassisIDState::indefiniteOn;
Vernon Mauery400cc782018-10-09 13:49:53 -07001573 return ipmi::responseSuccess();
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001574 }
1575 // start the timer
1576 auto time = std::chrono::duration_cast<std::chrono::microseconds>(
Patrick Venture0b02be92018-08-31 11:55:55 -07001577 std::chrono::seconds(identifyInterval));
Vernon Mauery1181af72018-10-08 12:05:00 -07001578 identifyTimer->start(time);
Tom Joseph5110c122018-03-23 17:55:40 +05301579 }
Tom Josephbed26992018-07-31 23:00:24 +05301580 else if (!identifyInterval)
1581 {
Vernon Mauery1181af72018-10-08 12:05:00 -07001582 identifyTimer->stop();
Tom Josephbed26992018-07-31 23:00:24 +05301583 enclosureIdentifyLedOff();
1584 }
Vernon Mauery400cc782018-10-09 13:49:53 -07001585 return ipmi::responseSuccess();
Tom Joseph5110c122018-03-23 17:55:40 +05301586}
1587
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001588namespace boot_options
1589{
1590
1591using namespace sdbusplus::xyz::openbmc_project::Control::Boot::server;
1592using IpmiValue = uint8_t;
1593constexpr auto ipmiDefault = 0;
1594
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001595std::map<IpmiValue, Type::Types> typeIpmiToDbus = {{0x00, Type::Types::Legacy},
1596 {0x01, Type::Types::EFI}};
1597
Patrick Venture0b02be92018-08-31 11:55:55 -07001598std::map<IpmiValue, Source::Sources> sourceIpmiToDbus = {
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001599 {0x01, Source::Sources::Network},
1600 {0x02, Source::Sources::Disk},
1601 {0x05, Source::Sources::ExternalMedia},
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08001602 {0x0f, Source::Sources::RemovableMedia},
Patrick Venture0b02be92018-08-31 11:55:55 -07001603 {ipmiDefault, Source::Sources::Default}};
shgoupfd84fbbf2015-12-17 10:05:51 +08001604
Patrick Venture0b02be92018-08-31 11:55:55 -07001605std::map<IpmiValue, Mode::Modes> modeIpmiToDbus = {
Yong Li5833cb62019-10-30 13:27:12 +08001606#ifdef ENABLE_BOOT_FLAG_SAFE_MODE_SUPPORT
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001607 {0x03, Mode::Modes::Safe},
Yong Li5833cb62019-10-30 13:27:12 +08001608#endif // ENABLE_BOOT_SAFE_MODE_SUPPORT
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001609 {0x06, Mode::Modes::Setup},
Patrick Venture0b02be92018-08-31 11:55:55 -07001610 {ipmiDefault, Mode::Modes::Regular}};
shgoupfd84fbbf2015-12-17 10:05:51 +08001611
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001612std::map<Type::Types, IpmiValue> typeDbusToIpmi = {{Type::Types::Legacy, 0x00},
1613 {Type::Types::EFI, 0x01}};
1614
Patrick Venture0b02be92018-08-31 11:55:55 -07001615std::map<Source::Sources, IpmiValue> sourceDbusToIpmi = {
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001616 {Source::Sources::Network, 0x01},
1617 {Source::Sources::Disk, 0x02},
1618 {Source::Sources::ExternalMedia, 0x05},
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08001619 {Source::Sources::RemovableMedia, 0x0f},
Patrick Venture0b02be92018-08-31 11:55:55 -07001620 {Source::Sources::Default, ipmiDefault}};
shgoupfd84fbbf2015-12-17 10:05:51 +08001621
Patrick Venture0b02be92018-08-31 11:55:55 -07001622std::map<Mode::Modes, IpmiValue> modeDbusToIpmi = {
Yong Li5833cb62019-10-30 13:27:12 +08001623#ifdef ENABLE_BOOT_FLAG_SAFE_MODE_SUPPORT
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001624 {Mode::Modes::Safe, 0x03},
Yong Li5833cb62019-10-30 13:27:12 +08001625#endif // ENABLE_BOOT_SAFE_MODE_SUPPORT
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001626 {Mode::Modes::Setup, 0x06},
Patrick Venture0b02be92018-08-31 11:55:55 -07001627 {Mode::Modes::Regular, ipmiDefault}};
shgoupfd84fbbf2015-12-17 10:05:51 +08001628
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001629} // namespace boot_options
shgoupfd84fbbf2015-12-17 10:05:51 +08001630
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001631/** @brief Get the property value for boot source
1632 * @param[in] ctx - context pointer
1633 * @param[out] source - boot source value
1634 * @return On failure return IPMI error.
1635 */
1636static ipmi::Cc getBootSource(ipmi::Context::ptr& ctx, Source::Sources& source)
1637{
1638 using namespace chassis::internal;
1639 std::string result;
1640 std::string service;
1641 boost::system::error_code ec =
1642 getService(ctx, bootSourceIntf, bootSettingsPath, service);
1643 if (!ec)
1644 {
1645 ec = ipmi::getDbusProperty(ctx, service, bootSettingsPath,
1646 bootSourceIntf, "BootSource", result);
1647 if (!ec)
1648 {
1649 source = Source::convertSourcesFromString(result);
1650 return ipmi::ccSuccess;
1651 }
1652 }
1653 log<level::ERR>("Error in BootSource Get",
1654 entry("ERROR=%s", ec.message().c_str()));
1655 return ipmi::ccUnspecifiedError;
1656}
1657
Marri Devender Rao81719702018-05-07 00:53:48 -05001658/** @brief Set the property value for boot source
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001659 * @param[in] ctx - context pointer
Marri Devender Rao81719702018-05-07 00:53:48 -05001660 * @param[in] source - boot source value
1661 * @return On failure return IPMI error.
1662 */
Jayaprakash Mutyala6088e9f2021-07-14 07:40:29 +00001663static ipmi::Cc setBootSource(ipmi::Context::ptr& ctx,
1664 const Source::Sources& source)
Marri Devender Rao81719702018-05-07 00:53:48 -05001665{
1666 using namespace chassis::internal;
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001667 std::string service;
1668 boost::system::error_code ec =
1669 getService(ctx, bootSourceIntf, bootSettingsPath, service);
1670 if (!ec)
Marri Devender Rao81719702018-05-07 00:53:48 -05001671 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001672 ec = ipmi::setDbusProperty(ctx, service, bootSettingsPath,
1673 bootSourceIntf, "BootSource",
1674 convertForMessage(source));
1675 if (!ec)
1676 {
1677 return ipmi::ccSuccess;
1678 }
Marri Devender Rao81719702018-05-07 00:53:48 -05001679 }
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001680 log<level::ERR>("Error in BootSource Set",
1681 entry("ERROR=%s", ec.message().c_str()));
1682 return ipmi::ccUnspecifiedError;
1683}
1684
1685/** @brief Get the property value for boot mode
1686 * @param[in] ctx - context pointer
1687 * @param[out] mode - boot mode value
1688 * @return On failure return IPMI error.
1689 */
1690static ipmi::Cc getBootMode(ipmi::Context::ptr& ctx, Mode::Modes& mode)
1691{
1692 using namespace chassis::internal;
1693 std::string result;
1694 std::string service;
1695 boost::system::error_code ec =
1696 getService(ctx, bootModeIntf, bootSettingsPath, service);
1697 if (!ec)
1698 {
1699 ec = ipmi::getDbusProperty(ctx, service, bootSettingsPath, bootModeIntf,
1700 "BootMode", result);
1701 if (!ec)
1702 {
1703 mode = Mode::convertModesFromString(result);
1704 return ipmi::ccSuccess;
1705 }
1706 }
1707 log<level::ERR>("Error in BootMode Get",
1708 entry("ERROR=%s", ec.message().c_str()));
1709 return ipmi::ccUnspecifiedError;
Marri Devender Rao81719702018-05-07 00:53:48 -05001710}
1711
Patrick Venture0b02be92018-08-31 11:55:55 -07001712/** @brief Set the property value for boot mode
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001713 * @param[in] ctx - context pointer
Marri Devender Rao81719702018-05-07 00:53:48 -05001714 * @param[in] mode - boot mode value
1715 * @return On failure return IPMI error.
1716 */
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001717static ipmi::Cc setBootMode(ipmi::Context::ptr& ctx, const Mode::Modes& mode)
Marri Devender Rao81719702018-05-07 00:53:48 -05001718{
1719 using namespace chassis::internal;
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001720 std::string service;
1721 boost::system::error_code ec =
1722 getService(ctx, bootModeIntf, bootSettingsPath, service);
1723 if (!ec)
Marri Devender Rao81719702018-05-07 00:53:48 -05001724 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001725 ec = ipmi::setDbusProperty(ctx, service, bootSettingsPath, bootModeIntf,
1726 "BootMode", convertForMessage(mode));
1727 if (!ec)
1728 {
1729 return ipmi::ccSuccess;
1730 }
Marri Devender Rao81719702018-05-07 00:53:48 -05001731 }
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001732 log<level::ERR>("Error in BootMode Set",
1733 entry("ERROR=%s", ec.message().c_str()));
1734 return ipmi::ccUnspecifiedError;
1735}
1736
1737/** @brief Get the property value for boot type
1738 * @param[in] ctx - context pointer
1739 * @param[out] type - boot type value
1740 * @return On failure return IPMI error.
1741 */
1742static ipmi::Cc getBootType(ipmi::Context::ptr& ctx, Type::Types& type)
1743{
1744 using namespace chassis::internal;
1745 std::string result;
1746 std::string service;
1747 boost::system::error_code ec =
1748 getService(ctx, bootTypeIntf, bootSettingsPath, service);
1749
1750 // Don't throw error if BootType interface is not present.
1751 // This interface is not relevant for some Host architectures
1752 // (for example POWER). In this case we don't won't IPMI to
1753 // return an error, but simply return bootType as EFI.
1754 type = Type::Types::EFI;
1755 if (!ec)
1756 {
1757 ec = ipmi::getDbusProperty(ctx, service, bootSettingsPath, bootTypeIntf,
1758 "BootType", result);
1759 if (ec)
1760 {
1761 log<level::ERR>("Error in BootType Get",
1762 entry("ERROR=%s", ec.message().c_str()));
1763 return ipmi::ccUnspecifiedError;
1764 }
1765 type = Type::convertTypesFromString(result);
1766 }
1767
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00001768 return ipmi::ccSuccess;
Marri Devender Rao81719702018-05-07 00:53:48 -05001769}
1770
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001771/** @brief Set the property value for boot type
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001772 * @param[in] ctx - context pointer
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001773 * @param[in] type - boot type value
1774 * @return On failure return IPMI error.
1775 */
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001776static ipmi::Cc setBootType(ipmi::Context::ptr& ctx, const Type::Types& type)
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001777{
1778 using namespace chassis::internal;
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001779 std::string service;
1780 boost::system::error_code ec =
1781 getService(ctx, bootTypeIntf, bootSettingsPath, service);
1782 if (!ec)
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001783 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001784 ec = ipmi::setDbusProperty(ctx, service, bootSettingsPath, bootTypeIntf,
1785 "BootType", convertForMessage(type));
1786 if (ec)
1787 {
1788 log<level::ERR>("Error in BootType Set",
1789 entry("ERROR=%s", ec.message().c_str()));
1790 return ipmi::ccUnspecifiedError;
1791 }
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001792 }
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001793 // Don't throw error if BootType interface is not present.
1794 // This interface is not relevant for some Host architectures
1795 // (for example POWER). In this case we don't won't IPMI to
1796 // return an error, but want to just skip this function.
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001797 return ipmi::ccSuccess;
1798}
1799
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001800/** @brief Get the property value for boot override enable
1801 * @param[in] ctx - context pointer
1802 * @param[out] enable - boot override enable
1803 * @return On failure return IPMI error.
1804 */
1805static ipmi::Cc getBootEnable(ipmi::Context::ptr& ctx, bool& enable)
1806{
1807 using namespace chassis::internal;
1808 std::string result;
1809 std::string service;
1810 boost::system::error_code ec =
1811 getService(ctx, bootEnableIntf, bootSettingsPath, service);
1812 if (!ec)
1813 {
1814 ec = ipmi::getDbusProperty(ctx, service, bootSettingsPath,
1815 bootEnableIntf, "Enabled", enable);
1816 if (!ec)
1817 {
1818 return ipmi::ccSuccess;
1819 }
1820 }
1821 log<level::ERR>("Error in Boot Override Enable Get",
1822 entry("ERROR=%s", ec.message().c_str()));
1823 return ipmi::ccUnspecifiedError;
1824}
1825
1826/** @brief Set the property value for boot override enable
1827 * @param[in] ctx - context pointer
1828 * @param[in] enable - boot override enable
1829 * @return On failure return IPMI error.
1830 */
1831static ipmi::Cc setBootEnable(ipmi::Context::ptr& ctx, const bool& enable)
1832{
1833 using namespace chassis::internal;
1834 std::string service;
1835 boost::system::error_code ec =
1836 getService(ctx, bootEnableIntf, bootSettingsPath, service);
1837 if (!ec)
1838 {
1839 ec = ipmi::setDbusProperty(ctx, service, bootSettingsPath,
1840 bootEnableIntf, "Enabled", enable);
1841 if (!ec)
1842 {
1843 return ipmi::ccSuccess;
1844 }
1845 }
1846 log<level::ERR>("Error in Boot Source Override Enable Set",
1847 entry("ERROR=%s", ec.message().c_str()));
1848 return ipmi::ccUnspecifiedError;
1849}
1850
1851/** @brief Get the property value for boot override one-time
1852 * @param[in] ctx - context pointer
1853 * @param[out] onetime - boot override one-time
1854 * @return On failure return IPMI error.
1855 */
1856static ipmi::Cc getBootOneTime(ipmi::Context::ptr& ctx, bool& onetime)
1857{
1858 using namespace chassis::internal;
1859 std::string result;
1860 std::string service;
1861 boost::system::error_code ec =
1862 getService(ctx, bootOneTimeIntf, bootSettingsOneTimePath, service);
1863 if (!ec)
1864 {
1865 ec = ipmi::getDbusProperty(ctx, service, bootSettingsOneTimePath,
1866 bootOneTimeIntf, "Enabled", onetime);
1867 if (!ec)
1868 {
1869 return ipmi::ccSuccess;
1870 }
1871 }
1872 log<level::ERR>("Error in Boot Override OneTime Get",
1873 entry("ERROR=%s", ec.message().c_str()));
1874 return ipmi::ccUnspecifiedError;
1875}
1876
1877/** @brief Set the property value for boot override one-time
1878 * @param[in] ctx - context pointer
1879 * @param[in] onetime - boot override one-time
1880 * @return On failure return IPMI error.
1881 */
1882static ipmi::Cc setBootOneTime(ipmi::Context::ptr& ctx, const bool& onetime)
1883{
1884 using namespace chassis::internal;
1885 std::string service;
1886 boost::system::error_code ec =
1887 getService(ctx, bootOneTimeIntf, bootSettingsOneTimePath, service);
1888 if (!ec)
1889 {
1890 ec = ipmi::setDbusProperty(ctx, service, bootSettingsOneTimePath,
1891 bootOneTimeIntf, "Enabled", onetime);
1892 if (!ec)
1893 {
1894 return ipmi::ccSuccess;
1895 }
1896 }
1897 log<level::ERR>("Error in Boot Source Override OneTime Set",
1898 entry("ERROR=%s", ec.message().c_str()));
1899 return ipmi::ccUnspecifiedError;
1900}
1901
huangheab369282020-10-10 14:40:00 +08001902static constexpr uint8_t setComplete = 0x0;
1903static constexpr uint8_t setInProgress = 0x1;
1904static uint8_t transferStatus = setComplete;
Chen Yugang86ac4992021-06-25 08:14:52 +08001905static uint8_t bootFlagValidBitClr = 0;
huangheab369282020-10-10 14:40:00 +08001906
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001907/** @brief implements the Get Chassis system boot option
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001908 * @param ctx - context pointer
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001909 * @param bootOptionParameter - boot option parameter selector
1910 * @param reserved1 - reserved bit
1911 * @param setSelector - selects a particular block or set of parameters
1912 * under the given parameter selector
1913 * write as 00h if parameter doesn't use a setSelector
1914 * @param blockSelector- selects a particular block within a set of
1915 * parameters write as 00h if parameter doesn't use a
1916 * blockSelector
1917 *
1918 * @return IPMI completion code plus response data
1919 * @return Payload contains below parameters:
1920 * version - parameter version
1921 * bootOptionParameter - boot option parameter selector
Patrick Venture8b1c3032020-09-15 09:43:03 -07001922 * parmIndicator - parameter valid/invalid indicator
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001923 * data - configuration parameter data
1924 */
1925ipmi::RspType<ipmi::message::Payload>
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001926 ipmiChassisGetSysBootOptions(ipmi::Context::ptr ctx,
1927 uint7_t bootOptionParameter, bool reserved1,
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001928
1929 uint8_t setSelector, uint8_t blockSelector)
Adriana Kobylak40814c62015-10-27 15:58:44 -05001930{
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001931 ipmi::Cc rc;
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001932 if (reserved1)
1933 {
1934 return ipmi::responseInvalidFieldRequest();
1935 }
1936
1937 constexpr uint4_t version = 0x01;
1938 ipmi::message::Payload response;
1939 response.pack(version, uint4_t{});
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001940 using namespace boot_options;
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001941
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001942 IpmiValue bootOption = ipmiDefault;
Adriana Kobylak40814c62015-10-27 15:58:44 -05001943
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001944 if (types::enum_cast<BootOptionParameter>(bootOptionParameter) ==
1945 BootOptionParameter::setInProgress)
huangheab369282020-10-10 14:40:00 +08001946 {
1947 response.pack(bootOptionParameter, reserved1, transferStatus);
1948 return ipmi::responseSuccess(std::move(response));
1949 }
1950
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001951 if (types::enum_cast<BootOptionParameter>(bootOptionParameter) ==
1952 BootOptionParameter::bootInfo)
John Wang0213f902020-12-28 14:49:57 +08001953 {
1954 constexpr uint8_t writeMask = 0;
1955 constexpr uint8_t bootInfoAck = 0;
1956 response.pack(bootOptionParameter, writeMask, bootInfoAck);
1957 return ipmi::responseSuccess(std::move(response));
1958 }
1959
Chen Yugang86ac4992021-06-25 08:14:52 +08001960 if (types::enum_cast<BootOptionParameter>(bootOptionParameter) ==
1961 BootOptionParameter::bootFlagValidClr)
1962 {
1963 response.pack(bootOptionParameter, reserved1,
1964 uint5_t{bootFlagValidBitClr}, uint3_t{});
1965 return ipmi::responseSuccess(std::move(response));
1966 }
1967
shgoupfd84fbbf2015-12-17 10:05:51 +08001968 /*
1969 * Parameter #5 means boot flags. Please refer to 28.13 of ipmi doc.
1970 * This is the only parameter used by petitboot.
1971 */
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001972 if (types::enum_cast<BootOptionParameter>(bootOptionParameter) ==
1973 BootOptionParameter::bootFlags)
Patrick Venture0b02be92018-08-31 11:55:55 -07001974 {
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001975 using namespace chassis::internal;
1976 using namespace chassis::internal::cache;
shgoupfd84fbbf2015-12-17 10:05:51 +08001977
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001978 try
ratagupta6f6bff2016-04-04 06:20:11 -05001979 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001980 Source::Sources bootSource;
1981 rc = getBootSource(ctx, bootSource);
1982 if (rc != ipmi::ccSuccess)
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001983 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001984 return ipmi::response(rc);
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001985 }
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001986
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001987 Type::Types bootType;
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001988 rc = getBootType(ctx, bootType);
1989 if (rc != ipmi::ccSuccess)
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001990 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001991 return ipmi::response(rc);
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001992 }
1993
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001994 Mode::Modes bootMode;
1995 rc = getBootMode(ctx, bootMode);
1996 if (rc != ipmi::ccSuccess)
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001997 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001998 return ipmi::response(rc);
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001999 }
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002000
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002001 bootOption = sourceDbusToIpmi.at(bootSource);
2002 if ((Mode::Modes::Regular == bootMode) &&
2003 (Source::Sources::Default == bootSource))
2004 {
2005 bootOption = ipmiDefault;
2006 }
2007 else if (Source::Sources::Default == bootSource)
2008 {
2009 bootOption = modeDbusToIpmi.at(bootMode);
2010 }
ratagupta6f6bff2016-04-04 06:20:11 -05002011
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002012 IpmiValue biosBootType = typeDbusToIpmi.at(bootType);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002013
2014 bool oneTimeEnabled;
2015 rc = getBootOneTime(ctx, oneTimeEnabled);
2016 if (rc != ipmi::ccSuccess)
2017 {
2018 return ipmi::response(rc);
2019 }
2020
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002021 uint1_t permanent = oneTimeEnabled ? 0 : 1;
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002022
2023 bool valid;
2024 rc = getBootEnable(ctx, valid);
2025 if (rc != ipmi::ccSuccess)
2026 {
2027 return ipmi::response(rc);
2028 }
2029
2030 uint1_t validFlag = valid ? 1 : 0;
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002031
2032 response.pack(bootOptionParameter, reserved1, uint5_t{},
2033 uint1_t{biosBootType}, uint1_t{permanent},
2034 uint1_t{validFlag}, uint2_t{}, uint4_t{bootOption},
2035 uint2_t{}, uint8_t{}, uint8_t{}, uint8_t{});
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002036 return ipmi::responseSuccess(std::move(response));
ratagupta6f6bff2016-04-04 06:20:11 -05002037 }
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002038 catch (InternalFailure& e)
2039 {
James Feist225dec82019-11-26 16:25:06 -08002040 cache::objectsPtr.reset();
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002041 report<InternalFailure>();
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002042 return ipmi::responseUnspecifiedError();
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002043 }
Patrick Venture0b02be92018-08-31 11:55:55 -07002044 }
Patrick Venture0b02be92018-08-31 11:55:55 -07002045 else
2046 {
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002047 if ((bootOptionParameter >= oemParmStart) &&
2048 (bootOptionParameter <= oemParmEnd))
2049 {
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07002050 if (types::enum_cast<BootOptionParameter>(bootOptionParameter) ==
2051 BootOptionParameter::opalNetworkSettings)
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002052 {
2053 response.pack(bootOptionParameter, reserved1);
2054 int ret = getHostNetworkData(response);
2055 if (ret < 0)
2056 {
2057 response.trailingOk = true;
2058 log<level::ERR>(
2059 "getHostNetworkData failed for GetSysBootOptions.");
2060 return ipmi::responseUnspecifiedError();
2061 }
2062 else
2063 {
2064 return ipmi::responseSuccess(std::move(response));
2065 }
2066 }
Jayaprakash Mutyala43a88102021-08-04 16:41:58 +00002067 else
2068 {
2069 log<level::ERR>(
2070 "ipmiChassisGetSysBootOptions: Unsupported parameter",
2071 entry("PARAM=0x%x",
2072 static_cast<uint8_t>(bootOptionParameter)));
2073 return ipmi::responseParmNotSupported();
2074 }
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002075 }
2076 else
2077 {
2078 log<level::ERR>(
2079 "ipmiChassisGetSysBootOptions: Unsupported parameter",
2080 entry("PARAM=0x%x", static_cast<uint8_t>(bootOptionParameter)));
Jayaprakash Mutyala6088e9f2021-07-14 07:40:29 +00002081 return ipmi::responseParmNotSupported();
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002082 }
shgoupfd84fbbf2015-12-17 10:05:51 +08002083 }
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002084 return ipmi::responseUnspecifiedError();
shgoupfd84fbbf2015-12-17 10:05:51 +08002085}
2086
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002087ipmi::RspType<> ipmiChassisSetSysBootOptions(ipmi::Context::ptr ctx,
2088 uint7_t parameterSelector,
2089 bool parameterIsValid,
2090 ipmi::message::Payload& data)
shgoupfd84fbbf2015-12-17 10:05:51 +08002091{
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002092 using namespace boot_options;
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002093 ipmi::Cc rc;
shgoupfd84fbbf2015-12-17 10:05:51 +08002094
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07002095 if (types::enum_cast<BootOptionParameter>(parameterSelector) ==
2096 BootOptionParameter::setInProgress)
huangheab369282020-10-10 14:40:00 +08002097 {
2098 uint2_t setInProgressFlag;
2099 uint6_t rsvd;
2100 if (data.unpack(setInProgressFlag, rsvd) != 0 || !data.fullyUnpacked())
2101 {
2102 return ipmi::responseReqDataLenInvalid();
2103 }
2104 if (rsvd)
2105 {
2106 return ipmi::responseInvalidFieldRequest();
2107 }
2108 if ((transferStatus == setInProgress) &&
2109 (static_cast<uint8_t>(setInProgressFlag) != setComplete))
2110 {
2111 return ipmi::response(IPMI_CC_FAIL_SET_IN_PROGRESS);
2112 }
2113 transferStatus = static_cast<uint8_t>(setInProgressFlag);
2114 return ipmi::responseSuccess();
2115 }
2116
shgoupfd84fbbf2015-12-17 10:05:51 +08002117 /* 000101
2118 * Parameter #5 means boot flags. Please refer to 28.13 of ipmi doc.
2119 * This is the only parameter used by petitboot.
2120 */
Ratan Guptafd28dd72016-08-01 04:58:01 -05002121
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07002122 if (types::enum_cast<BootOptionParameter>(parameterSelector) ==
2123 BootOptionParameter::bootFlags)
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002124 {
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002125 uint5_t rsvd;
2126 bool validFlag;
2127 bool permanent;
2128 bool biosBootType;
2129 bool lockOutResetButton;
2130 bool screenBlank;
2131 uint4_t bootDeviceSelector;
2132 bool lockKeyboard;
2133 bool cmosClear;
2134 uint8_t data3;
2135 uint4_t biosInfo;
2136 uint4_t rsvd1;
2137 uint5_t deviceInstance;
2138 uint3_t rsvd2;
2139
2140 if (data.unpack(rsvd, biosBootType, permanent, validFlag,
2141 lockOutResetButton, screenBlank, bootDeviceSelector,
2142 lockKeyboard, cmosClear, data3, biosInfo, rsvd1,
2143 deviceInstance, rsvd2) != 0 ||
2144 !data.fullyUnpacked())
2145 {
2146 return ipmi::responseReqDataLenInvalid();
2147 }
2148 if (rsvd || rsvd1 || rsvd2)
2149 {
2150 return ipmi::responseInvalidFieldRequest();
2151 }
2152
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002153 using namespace chassis::internal;
2154 using namespace chassis::internal::cache;
shgoupfd84fbbf2015-12-17 10:05:51 +08002155
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002156 try
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002157 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002158 rc = setBootOneTime(ctx, !permanent);
2159 if (rc != ipmi::ccSuccess)
Konstantin Aladyshev69e8e842021-06-18 17:01:18 +03002160 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002161 return ipmi::response(rc);
2162 }
Vernon Maueryafd45db2021-07-29 16:27:25 +00002163
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002164 rc = setBootEnable(ctx, validFlag);
2165 if (rc != ipmi::ccSuccess)
2166 {
2167 return ipmi::response(rc);
Tom Joseph57e8eb72017-09-25 18:05:02 +05302168 }
2169
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002170 auto modeItr =
2171 modeIpmiToDbus.find(static_cast<uint8_t>(bootDeviceSelector));
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002172 auto typeItr =
2173 typeIpmiToDbus.find(static_cast<uint8_t>(biosBootType));
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002174 auto sourceItr =
2175 sourceIpmiToDbus.find(static_cast<uint8_t>(bootDeviceSelector));
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002176 if (sourceIpmiToDbus.end() != sourceItr)
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002177 {
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03002178 rc = setBootSource(ctx, sourceItr->second);
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002179 if (rc != ipmi::ccSuccess)
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002180 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002181 return ipmi::response(rc);
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002182 }
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002183 // If a set boot device is mapping to a boot source, then reset
2184 // the boot mode D-Bus property to default.
2185 // This way the ipmid code can determine which property is not
2186 // at the default value
Patrick Venture0b02be92018-08-31 11:55:55 -07002187 if (sourceItr->second != Source::Sources::Default)
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002188 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002189 rc = setBootMode(ctx, Mode::Modes::Regular);
2190 if (rc != ipmi::ccSuccess)
2191 {
2192 return ipmi::response(rc);
2193 }
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002194 }
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002195 }
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002196
2197 if (typeIpmiToDbus.end() != typeItr)
2198 {
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03002199 rc = setBootType(ctx, typeItr->second);
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002200 if (rc != ipmi::ccSuccess)
2201 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002202 return ipmi::response(rc);
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002203 }
2204 }
2205
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002206 if (modeIpmiToDbus.end() != modeItr)
2207 {
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03002208 rc = setBootMode(ctx, modeItr->second);
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002209 if (rc != ipmi::ccSuccess)
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002210 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002211 return ipmi::response(rc);
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002212 }
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002213 // If a set boot device is mapping to a boot mode, then reset
2214 // the boot source D-Bus property to default.
2215 // This way the ipmid code can determine which property is not
2216 // at the default value
Patrick Venture0b02be92018-08-31 11:55:55 -07002217 if (modeItr->second != Mode::Modes::Regular)
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002218 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002219 rc = setBootSource(ctx, Source::Sources::Default);
2220 if (rc != ipmi::ccSuccess)
2221 {
2222 return ipmi::response(rc);
2223 }
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002224 }
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002225 }
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08002226 if ((modeIpmiToDbus.end() == modeItr) &&
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002227 (typeIpmiToDbus.end() == typeItr) &&
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08002228 (sourceIpmiToDbus.end() == sourceItr))
2229 {
2230 // return error if boot option is not supported
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002231 log<level::ERR>(
2232 "ipmiChassisSetSysBootOptions: Boot option not supported");
2233 return ipmi::responseInvalidFieldRequest();
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08002234 }
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002235 }
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002236 catch (sdbusplus::exception_t& e)
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002237 {
James Feist225dec82019-11-26 16:25:06 -08002238 objectsPtr.reset();
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002239 report<InternalFailure>();
Aditya Saripalli5fb14602017-11-09 14:46:27 +05302240 log<level::ERR>(
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002241 "ipmiChassisSetSysBootOptions: Error in setting Boot "
2242 "flag parameters");
2243 return ipmi::responseUnspecifiedError();
Ratan Guptafd28dd72016-08-01 04:58:01 -05002244 }
Patrick Venture0b02be92018-08-31 11:55:55 -07002245 }
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07002246 else if (types::enum_cast<BootOptionParameter>(parameterSelector) ==
2247 BootOptionParameter::bootInfo)
Patrick Venture0b02be92018-08-31 11:55:55 -07002248 {
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002249 uint8_t writeMak;
2250 uint5_t bootInitiatorAckData;
2251 uint3_t rsvd;
2252
2253 if (data.unpack(writeMak, bootInitiatorAckData, rsvd) != 0 ||
2254 !data.fullyUnpacked())
2255 {
2256 return ipmi::responseReqDataLenInvalid();
2257 }
2258 if (rsvd)
2259 {
2260 return ipmi::responseInvalidFieldRequest();
2261 }
2262 // (ccSuccess). There is no implementation in OpenBMC for this
Tom Josephf536c902017-09-25 18:08:15 +05302263 // parameter. This is added to support the ipmitool command `chassis
2264 // bootdev` which sends set on parameter #4, before setting the boot
2265 // flags.
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002266 log<level::INFO>("ipmiChassisSetSysBootOptions: bootInfo parameter set "
2267 "successfully");
2268 data.trailingOk = true;
2269 return ipmi::responseSuccess();
Patrick Venture0b02be92018-08-31 11:55:55 -07002270 }
Chen Yugang86ac4992021-06-25 08:14:52 +08002271 else if (types::enum_cast<BootOptionParameter>(parameterSelector) ==
2272 BootOptionParameter::bootFlagValidClr)
2273 {
2274 uint5_t bootFlagValidClr;
2275 uint3_t rsvd;
2276
2277 if (data.unpack(bootFlagValidClr, rsvd) != 0 || !data.fullyUnpacked())
2278 {
2279 return ipmi::responseReqDataLenInvalid();
2280 }
2281 if (rsvd)
2282 {
2283 return ipmi::responseInvalidFieldRequest();
2284 }
2285 // store boot flag valid bits clear value
2286 bootFlagValidBitClr = static_cast<uint8_t>(bootFlagValidClr);
2287 log<level::INFO>(
2288 "ipmiChassisSetSysBootOptions: bootFlagValidBits parameter set "
2289 "successfully",
2290 entry("value=0x%x", bootFlagValidBitClr));
2291 return ipmi::responseSuccess();
2292 }
Patrick Venture0b02be92018-08-31 11:55:55 -07002293 else
2294 {
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002295 if ((parameterSelector >= static_cast<uint7_t>(oemParmStart)) &&
2296 (parameterSelector <= static_cast<uint7_t>(oemParmEnd)))
2297 {
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07002298 if (types::enum_cast<BootOptionParameter>(parameterSelector) ==
2299 BootOptionParameter::opalNetworkSettings)
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002300 {
2301 ipmi::Cc ret = setHostNetworkData(data);
2302 if (ret != ipmi::ccSuccess)
2303 {
2304 log<level::ERR>("ipmiChassisSetSysBootOptions: Error in "
2305 "setHostNetworkData");
2306 data.trailingOk = true;
2307 return ipmi::response(ret);
2308 }
2309 data.trailingOk = true;
2310 return ipmi::responseSuccess();
2311 }
2312 else
2313 {
2314 log<level::ERR>(
2315 "ipmiChassisSetSysBootOptions: Unsupported parameters",
2316 entry("PARAM=0x%x",
2317 static_cast<uint8_t>(parameterSelector)));
2318 data.trailingOk = true;
2319 return ipmi::responseParmNotSupported();
2320 }
2321 }
2322 data.trailingOk = true;
2323 return ipmi::responseParmNotSupported();
Adriana Kobylak40814c62015-10-27 15:58:44 -05002324 }
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002325 return ipmi::responseSuccess();
Adriana Kobylak40814c62015-10-27 15:58:44 -05002326}
2327
anil kumar appanaa5a76eb2019-04-30 14:57:24 +00002328/** @brief implements Get POH counter command
2329 * @parameter
2330 * - none
2331 * @returns IPMI completion code plus response data
2332 * - minPerCount - Minutes per count
2333 * - counterReading - counter reading
2334 */
2335ipmi::RspType<uint8_t, // Minutes per count
2336 uint32_t // Counter reading
2337 >
2338 ipmiGetPOHCounter()
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002339{
2340 // sd_bus error
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002341 try
2342 {
anil kumar appanaa5a76eb2019-04-30 14:57:24 +00002343 return ipmi::responseSuccess(static_cast<uint8_t>(poh::minutesPerCount),
2344 getPOHCounter());
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002345 }
2346 catch (std::exception& e)
2347 {
2348 log<level::ERR>(e.what());
anil kumar appanaa5a76eb2019-04-30 14:57:24 +00002349 return ipmi::responseUnspecifiedError();
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002350 }
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002351}
2352
Jason M. Billsbc996a32019-06-17 15:46:37 -07002353ipmi::RspType<uint3_t, // policy support
2354 uint5_t // reserved
2355 >
Vernon Mauerye278ead2018-10-09 09:23:43 -07002356 ipmiChassisSetPowerRestorePolicy(boost::asio::yield_context yield,
Jason M. Billsbc996a32019-06-17 15:46:37 -07002357 uint3_t policy, uint5_t reserved)
Yong Lic6713cf2018-09-12 12:35:13 +08002358{
Yong Lic6713cf2018-09-12 12:35:13 +08002359 power_policy::DbusValue value =
2360 power_policy::RestorePolicy::Policy::AlwaysOff;
2361
Jason M. Billsbc996a32019-06-17 15:46:37 -07002362 if (reserved || (policy > power_policy::noChange))
Yong Lic6713cf2018-09-12 12:35:13 +08002363 {
Vernon Mauerye278ead2018-10-09 09:23:43 -07002364 phosphor::logging::log<level::ERR>(
2365 "Reserved request parameter",
2366 entry("REQ=0x%x", static_cast<int>(policy)));
Jason M. Billsbc996a32019-06-17 15:46:37 -07002367 return ipmi::responseInvalidFieldRequest();
Yong Lic6713cf2018-09-12 12:35:13 +08002368 }
2369
Vernon Mauerye278ead2018-10-09 09:23:43 -07002370 if (policy == power_policy::noChange)
Yong Lic6713cf2018-09-12 12:35:13 +08002371 {
2372 // just return the supported policy
Jason M. Billsbc996a32019-06-17 15:46:37 -07002373 return ipmi::responseSuccess(power_policy::allSupport, reserved);
Yong Lic6713cf2018-09-12 12:35:13 +08002374 }
2375
2376 for (auto const& it : power_policy::dbusToIpmi)
2377 {
Vernon Mauerye278ead2018-10-09 09:23:43 -07002378 if (it.second == policy)
Yong Lic6713cf2018-09-12 12:35:13 +08002379 {
2380 value = it.first;
2381 break;
2382 }
2383 }
2384
2385 try
2386 {
James Feist225dec82019-11-26 16:25:06 -08002387 settings::Objects& objects = chassis::internal::cache::getObjects();
Yong Lic6713cf2018-09-12 12:35:13 +08002388 const settings::Path& powerRestoreSetting =
James Feist225dec82019-11-26 16:25:06 -08002389 objects.map.at(chassis::internal::powerRestoreIntf).front();
Vernon Mauery16b86932019-05-01 08:36:11 -07002390 std::variant<std::string> property = convertForMessage(value);
Yong Lic6713cf2018-09-12 12:35:13 +08002391
Vernon Mauerye278ead2018-10-09 09:23:43 -07002392 auto sdbusp = getSdBus();
2393 boost::system::error_code ec;
2394 sdbusp->yield_method_call<void>(
2395 yield, ec,
James Feist225dec82019-11-26 16:25:06 -08002396 objects
Yong Lic6713cf2018-09-12 12:35:13 +08002397 .service(powerRestoreSetting,
2398 chassis::internal::powerRestoreIntf)
2399 .c_str(),
Vernon Mauerye278ead2018-10-09 09:23:43 -07002400 powerRestoreSetting, ipmi::PROP_INTF, "Set",
2401 chassis::internal::powerRestoreIntf, "PowerRestorePolicy",
2402 property);
2403 if (ec)
Yong Lic6713cf2018-09-12 12:35:13 +08002404 {
2405 phosphor::logging::log<level::ERR>("Unspecified Error");
Vernon Mauerye278ead2018-10-09 09:23:43 -07002406 return ipmi::responseUnspecifiedError();
Yong Lic6713cf2018-09-12 12:35:13 +08002407 }
2408 }
2409 catch (InternalFailure& e)
2410 {
James Feist225dec82019-11-26 16:25:06 -08002411 chassis::internal::cache::objectsPtr.reset();
Yong Lic6713cf2018-09-12 12:35:13 +08002412 report<InternalFailure>();
Vernon Mauerye278ead2018-10-09 09:23:43 -07002413 return ipmi::responseUnspecifiedError();
Yong Lic6713cf2018-09-12 12:35:13 +08002414 }
2415
Jason M. Billsbc996a32019-06-17 15:46:37 -07002416 return ipmi::responseSuccess(power_policy::allSupport, reserved);
Yong Lic6713cf2018-09-12 12:35:13 +08002417}
2418
Kuiying Wang21addc52019-01-04 10:50:21 +08002419ipmi::RspType<> ipmiSetFrontPanelButtonEnables(
2420 ipmi::Context::ptr ctx, bool disablePowerButton, bool disableResetButton,
2421 bool disableDiagButton, bool disableSleepButton, uint4_t reserved)
2422{
2423 using namespace chassis::internal;
2424
2425 // set power button Enabled property
2426 bool success = setButtonEnabled(ctx, powerButtonPath, powerButtonIntf,
2427 !disablePowerButton);
2428
2429 // set reset button Enabled property
2430 success &= setButtonEnabled(ctx, resetButtonPath, resetButtonIntf,
2431 !disableResetButton);
2432
2433 if (!success)
2434 {
2435 // not all buttons were successfully set
2436 return ipmi::responseUnspecifiedError();
2437 }
2438 return ipmi::responseSuccess();
2439}
2440
Adriana Kobylak40814c62015-10-27 15:58:44 -05002441void register_netfn_chassis_functions()
2442{
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05002443 createIdentifyTimer();
2444
Tom05732372016-09-06 17:21:23 +05302445 // Get Chassis Capabilities
anil kumar appana43263c62019-05-27 12:45:04 +00002446 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2447 ipmi::chassis::cmdGetChassisCapabilities,
2448 ipmi::Privilege::User, ipmiGetChassisCap);
Nan Li8d15fb42016-08-16 22:29:40 +08002449
Kuiying Wang21addc52019-01-04 10:50:21 +08002450 // Set Front Panel Button Enables
2451 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2452 ipmi::chassis::cmdSetFrontPanelButtonEnables,
2453 ipmi::Privilege::Admin,
2454 ipmiSetFrontPanelButtonEnables);
2455
Yong Liae4b0402018-11-02 11:12:14 +08002456 // Set Chassis Capabilities
anil kumar appana894d0222019-05-27 16:32:14 +00002457 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2458 ipmi::chassis::cmdSetChassisCapabilities,
2459 ipmi::Privilege::User, ipmiSetChassisCap);
Yong Liae4b0402018-11-02 11:12:14 +08002460
Tom05732372016-09-06 17:21:23 +05302461 // <Get System Boot Options>
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002462 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2463 ipmi::chassis::cmdGetSystemBootOptions,
2464 ipmi::Privilege::Operator,
2465 ipmiChassisGetSysBootOptions);
Adriana Kobylak40814c62015-10-27 15:58:44 -05002466
Tom05732372016-09-06 17:21:23 +05302467 // <Get Chassis Status>
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07002468 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2469 ipmi::chassis::cmdGetChassisStatus,
2470 ipmi::Privilege::User, ipmiGetChassisStatus);
Nan Lifdd8ec52016-08-28 03:57:40 +08002471
Vijay Khemka074f64d2020-03-03 15:08:43 -08002472 // <Chassis Get System Restart Cause>
2473 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2474 ipmi::chassis::cmdGetSystemRestartCause,
2475 ipmi::Privilege::User, ipmiGetSystemRestartCause);
2476
Tom05732372016-09-06 17:21:23 +05302477 // <Chassis Control>
anil kumar appanadafff5f2019-04-27 18:06:00 +00002478 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2479 ipmi::chassis::cmdChassisControl,
2480 ipmi::Privilege::Operator, ipmiChassisControl);
shgoupfd84fbbf2015-12-17 10:05:51 +08002481
Tom Joseph5110c122018-03-23 17:55:40 +05302482 // <Chassis Identify>
Vernon Mauery400cc782018-10-09 13:49:53 -07002483 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2484 ipmi::chassis::cmdChassisIdentify,
2485 ipmi::Privilege::Operator, ipmiChassisIdentify);
Tom Joseph5110c122018-03-23 17:55:40 +05302486
Tom05732372016-09-06 17:21:23 +05302487 // <Set System Boot Options>
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002488 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2489 ipmi::chassis::cmdSetSystemBootOptions,
2490 ipmi::Privilege::Operator,
2491 ipmiChassisSetSysBootOptions);
2492
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002493 // <Get POH Counter>
anil kumar appanaa5a76eb2019-04-30 14:57:24 +00002494 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2495 ipmi::chassis::cmdGetPohCounter,
2496 ipmi::Privilege::User, ipmiGetPOHCounter);
Yong Lic6713cf2018-09-12 12:35:13 +08002497
2498 // <Set Power Restore Policy>
Vernon Mauerye278ead2018-10-09 09:23:43 -07002499 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2500 ipmi::chassis::cmdSetPowerRestorePolicy,
2501 ipmi::Privilege::Operator,
2502 ipmiChassisSetPowerRestorePolicy);
vishwa36993272015-11-20 12:43:49 -06002503}