blob: a0a91d2027980cdf798e423c88f37003d99bc962 [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>
Patrick Venture0b02be92018-08-31 11:55:55 -07008#include <netinet/in.h>
Patrick Venture0b02be92018-08-31 11:55:55 -07009
Vernon Mauerye08fbff2019-04-03 09:19:34 -070010#include <ipmid/api.hpp>
Vernon Mauery33250242019-03-12 16:49:26 -070011#include <ipmid/types.hpp>
Vernon Mauery6a98fe72019-03-11 15:57:48 -070012#include <ipmid/utils.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070013#include <phosphor-logging/elog-errors.hpp>
Vernon Mauery38108d92024-03-11 12:53:55 -070014#include <phosphor-logging/lg2.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070015#include <sdbusplus/bus.hpp>
William A. Kennington III4c008022018-10-12 17:18:14 -070016#include <sdbusplus/message/types.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070017#include <sdbusplus/server/object.hpp>
Vernon Mauery1181af72018-10-08 12:05:00 -070018#include <sdbusplus/timer.hpp>
Vernon Mauerye278ead2018-10-09 09:23:43 -070019#include <settings.hpp>
Chau Ly8c1376c2024-01-05 07:22:10 +000020#include <xyz/openbmc_project/Chassis/Intrusion/client.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070021#include <xyz/openbmc_project/Common/error.hpp>
22#include <xyz/openbmc_project/Control/Boot/Mode/server.hpp>
23#include <xyz/openbmc_project/Control/Boot/Source/server.hpp>
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +030024#include <xyz/openbmc_project/Control/Boot/Type/server.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070025#include <xyz/openbmc_project/Control/Power/RestorePolicy/server.hpp>
Jason M. Billsad588bf2020-01-30 16:18:33 -080026#include <xyz/openbmc_project/State/Chassis/server.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070027#include <xyz/openbmc_project/State/Host/server.hpp>
28#include <xyz/openbmc_project/State/PowerOnHours/server.hpp>
29
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -050030#include <array>
31#include <chrono>
32#include <cstring>
33#include <filesystem>
34#include <fstream>
35#include <future>
36#include <map>
37#include <sstream>
38#include <string>
39
Patrick Williams95655222023-12-05 12:45:02 -060040std::unique_ptr<sdbusplus::Timer> identifyTimer
Lei YU4b0ddb62019-01-25 16:43:50 +080041 __attribute__((init_priority(101)));
Marri Devender Rao6706c1c2018-05-14 00:29:38 -050042
Yong Lif4e38512019-05-21 14:46:55 +080043static ChassisIDState chassisIDState = ChassisIDState::reserved;
44
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +000045constexpr size_t sizeVersion = 2;
Tom Joseph5110c122018-03-23 17:55:40 +053046constexpr size_t DEFAULT_IDENTIFY_TIME_OUT = 15;
Ratan Gupta6ec7daa2017-07-15 14:13:01 +053047
Patrick Venture0b02be92018-08-31 11:55:55 -070048// PetiBoot-Specific
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +000049static constexpr uint8_t netConfInitialBytes[] = {0x80, 0x21, 0x70, 0x62,
50 0x21, 0x00, 0x01, 0x06};
51static constexpr uint8_t oemParmStart = 96;
52static constexpr uint8_t oemParmEnd = 127;
Ratan Guptafd28dd72016-08-01 04:58:01 -050053
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +000054static constexpr size_t cookieOffset = 1;
55static constexpr size_t versionOffset = 5;
56static constexpr size_t addrSizeOffset = 8;
57static constexpr size_t macOffset = 9;
58static constexpr size_t addrTypeOffset = 16;
59static constexpr size_t ipAddrOffset = 17;
ratagupta6f6bff2016-04-04 06:20:11 -050060
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +000061namespace ipmi
62{
63constexpr Cc ccParmNotSupported = 0x80;
George Liuf5dd1022025-07-07 09:13:07 +080064constexpr Cc ccFailSetInProgress = 0x81;
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +000065
66static inline auto responseParmNotSupported()
67{
68 return response(ccParmNotSupported);
69}
George Liuf5dd1022025-07-07 09:13:07 +080070
71static inline auto responsefailSetInProgress()
72{
73 return response(ccFailSetInProgress);
74}
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +000075} // namespace ipmi
76
George Liu5087b072025-03-11 19:28:17 +080077void registerNetFnChassisFunctions() __attribute__((constructor));
Adriana Kobylak40814c62015-10-27 15:58:44 -050078
shgoupfd84fbbf2015-12-17 10:05:51 +080079// Host settings in dbus
80// Service name should be referenced by connection name got via object mapper
Patrick Venture0b02be92018-08-31 11:55:55 -070081const char* settings_object_name = "/org/openbmc/settings/host0";
82const char* settings_intf_name = "org.freedesktop.DBus.Properties";
Patrick Venture0b02be92018-08-31 11:55:55 -070083const char* identify_led_object_name =
Tom Joseph5110c122018-03-23 17:55:40 +053084 "/xyz/openbmc_project/led/groups/enclosure_identify";
shgoupfd84fbbf2015-12-17 10:05:51 +080085
Ratan Guptadcb10672017-07-10 10:33:50 +053086constexpr auto SETTINGS_ROOT = "/";
87constexpr auto SETTINGS_MATCH = "host0";
Ratan Guptadcb10672017-07-10 10:33:50 +053088
89constexpr auto IP_INTERFACE = "xyz.openbmc_project.Network.IP";
90constexpr auto MAC_INTERFACE = "xyz.openbmc_project.Network.MACAddress";
91
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -050092static constexpr auto chassisStateRoot = "/xyz/openbmc_project/state";
93static constexpr auto chassisPOHStateIntf =
Patrick Venture0b02be92018-08-31 11:55:55 -070094 "xyz.openbmc_project.State.PowerOnHours";
Patrick Williams7345ac42021-04-30 20:57:39 -050095static constexpr auto pohCounterProperty = "POHCounter";
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -050096static constexpr auto match = "chassis0";
Yong Liae4b0402018-11-02 11:12:14 +080097const static constexpr char chassisCapIntf[] =
98 "xyz.openbmc_project.Control.ChassisCapabilities";
Karthick Sundarrajan86d8bd72019-11-26 12:48:50 -080099const static constexpr char chassisIntrusionProp[] = "ChassisIntrusionEnabled";
100const static constexpr char chassisFrontPanelLockoutProp[] =
101 "ChassisFrontPanelLockoutEnabled";
102const static constexpr char chassisNMIProp[] = "ChassisNMIEnabled";
103const static constexpr char chassisPowerInterlockProp[] =
104 "ChassisPowerInterlockEnabled";
Yong Liae4b0402018-11-02 11:12:14 +0800105const static constexpr char chassisFRUDevAddrProp[] = "FRUDeviceAddress";
106const static constexpr char chassisSDRDevAddrProp[] = "SDRDeviceAddress";
107const static constexpr char chassisSELDevAddrProp[] = "SELDeviceAddress";
108const static constexpr char chassisSMDevAddrProp[] = "SMDeviceAddress";
109const static constexpr char chassisBridgeDevAddrProp[] = "BridgeDeviceAddress";
Yong Liae4b0402018-11-02 11:12:14 +0800110static constexpr uint8_t chassisCapAddrMask = 0xfe;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700111static constexpr const char* powerButtonIntf =
112 "xyz.openbmc_project.Chassis.Buttons.Power";
113static constexpr const char* powerButtonPath =
114 "/xyz/openbmc_project/Chassis/Buttons/Power0";
115static constexpr const char* resetButtonIntf =
116 "xyz.openbmc_project.Chassis.Buttons.Reset";
117static constexpr const char* resetButtonPath =
118 "/xyz/openbmc_project/Chassis/Buttons/Reset0";
Ratan Guptadcb10672017-07-10 10:33:50 +0530119
Vishwanatha Subbannab12b0c02017-03-07 18:17:19 +0530120// Phosphor Host State manager
Willy Tu523e2d12023-09-05 11:36:48 -0700121namespace State = sdbusplus::server::xyz::openbmc_project::state;
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;
Willy Tu523e2d12023-09-05 11:36:48 -0700125using namespace sdbusplus::error::xyz::openbmc_project::common;
126using namespace sdbusplus::server::xyz::openbmc_project::control::boot;
Chau Ly8c1376c2024-01-05 07:22:10 +0000127using Intrusion = sdbusplus::client::xyz::openbmc_project::chassis::Intrusion<>;
William A. Kennington III4c008022018-10-12 17:18:14 -0700128
Deepak Kodihalli8cc19362017-07-21 11:18:38 -0500129namespace chassis
130{
131namespace internal
132{
133
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +0300134constexpr auto bootSettingsPath = "/xyz/openbmc_project/control/host0/boot";
135constexpr auto bootEnableIntf = "xyz.openbmc_project.Object.Enable";
Deepak Kodihalli8cc19362017-07-21 11:18:38 -0500136constexpr auto bootModeIntf = "xyz.openbmc_project.Control.Boot.Mode";
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +0300137constexpr auto bootTypeIntf = "xyz.openbmc_project.Control.Boot.Type";
Deepak Kodihalli8cc19362017-07-21 11:18:38 -0500138constexpr auto bootSourceIntf = "xyz.openbmc_project.Control.Boot.Source";
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +0300139constexpr auto bootSettingsOneTimePath =
140 "/xyz/openbmc_project/control/host0/boot/one_time";
141constexpr auto bootOneTimeIntf = "xyz.openbmc_project.Object.Enable";
142
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500143constexpr auto powerRestoreIntf =
144 "xyz.openbmc_project.Control.Power.RestorePolicy";
Patrick Williams5d82f472022-07-22 19:26:53 -0500145sdbusplus::bus_t dbus(ipmid_get_sd_bus_connection());
Deepak Kodihalli8cc19362017-07-21 11:18:38 -0500146
147namespace cache
148{
149
James Feist225dec82019-11-26 16:25:06 -0800150std::unique_ptr<settings::Objects> objectsPtr = nullptr;
151
152settings::Objects& getObjects()
153{
154 if (objectsPtr == nullptr)
155 {
156 objectsPtr = std::make_unique<settings::Objects>(
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +0300157 dbus, std::vector<std::string>{bootModeIntf, bootTypeIntf,
158 bootSourceIntf, powerRestoreIntf});
James Feist225dec82019-11-26 16:25:06 -0800159 }
160 return *objectsPtr;
161}
Deepak Kodihalli8cc19362017-07-21 11:18:38 -0500162
163} // namespace cache
164} // namespace internal
165} // namespace chassis
166
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500167namespace poh
168{
169
170constexpr auto minutesPerCount = 60;
171
172} // namespace poh
173
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000174int getHostNetworkData(ipmi::message::Payload& payload)
Ratan Guptafd28dd72016-08-01 04:58:01 -0500175{
Ratan Guptadcb10672017-07-10 10:33:50 +0530176 ipmi::PropertyMap properties;
177 int rc = 0;
Ratan Gupta8c31d232017-08-13 05:49:43 +0530178 uint8_t addrSize = ipmi::network::IPV4_ADDRESS_SIZE_BYTE;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500179
Ratan Guptadcb10672017-07-10 10:33:50 +0530180 try
181 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700182 // TODO There may be cases where an interface is implemented by multiple
Ratan Guptadcb10672017-07-10 10:33:50 +0530183 // objects,to handle such cases we are interested on that object
184 // which are on interested busname.
185 // Currenlty mapper doesn't give the readable busname(gives busid)
186 // so we can't match with bus name so giving some object specific info
187 // as SETTINGS_MATCH.
188 // Later SETTINGS_MATCH will be replaced with busname.
Ratan Guptafd28dd72016-08-01 04:58:01 -0500189
Patrick Williams5d82f472022-07-22 19:26:53 -0500190 sdbusplus::bus_t bus(ipmid_get_sd_bus_connection());
Ratan Guptadcb10672017-07-10 10:33:50 +0530191
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530192 auto ipObjectInfo = ipmi::getDbusObject(bus, IP_INTERFACE,
193 SETTINGS_ROOT, SETTINGS_MATCH);
194
195 auto macObjectInfo = ipmi::getDbusObject(bus, MAC_INTERFACE,
196 SETTINGS_ROOT, SETTINGS_MATCH);
197
Patrick Venture0b02be92018-08-31 11:55:55 -0700198 properties = ipmi::getAllDbusProperties(
199 bus, ipObjectInfo.second, ipObjectInfo.first, IP_INTERFACE);
Patrick Williams1318a5e2024-08-16 15:19:54 -0400200 auto variant = ipmi::getDbusProperty(
201 bus, macObjectInfo.second, macObjectInfo.first, MAC_INTERFACE,
202 "MACAddress");
Ratan Guptadcb10672017-07-10 10:33:50 +0530203
Vernon Maueryf442e112019-04-09 11:44:36 -0700204 auto ipAddress = std::get<std::string>(properties["Address"]);
Ratan Guptad70f4532017-08-04 02:07:31 +0530205
Vernon Maueryf442e112019-04-09 11:44:36 -0700206 auto gateway = std::get<std::string>(properties["Gateway"]);
Ratan Guptad70f4532017-08-04 02:07:31 +0530207
Vernon Maueryf442e112019-04-09 11:44:36 -0700208 auto prefix = std::get<uint8_t>(properties["PrefixLength"]);
Ratan Guptad70f4532017-08-04 02:07:31 +0530209
Patrick Venture0b02be92018-08-31 11:55:55 -0700210 uint8_t isStatic =
Vernon Maueryf442e112019-04-09 11:44:36 -0700211 (std::get<std::string>(properties["Origin"]) ==
Patrick Venture0b02be92018-08-31 11:55:55 -0700212 "xyz.openbmc_project.Network.IP.AddressOrigin.Static")
213 ? 1
214 : 0;
Ratan Guptad70f4532017-08-04 02:07:31 +0530215
Vernon Maueryf442e112019-04-09 11:44:36 -0700216 auto MACAddress = std::get<std::string>(variant);
Ratan Guptacc8feb42017-07-25 21:52:10 +0530217
Ratan Guptad70f4532017-08-04 02:07:31 +0530218 // it is expected here that we should get the valid data
219 // but we may also get the default values.
220 // Validation of the data is done by settings.
221 //
222 // if mac address is default mac address then
223 // don't send blank override.
Ratan Gupta8c31d232017-08-13 05:49:43 +0530224 if ((MACAddress == ipmi::network::DEFAULT_MAC_ADDRESS))
Ratan Guptad70f4532017-08-04 02:07:31 +0530225 {
Ratan Guptad70f4532017-08-04 02:07:31 +0530226 rc = -1;
227 return rc;
228 }
229 // if addr is static then ipaddress,gateway,prefix
230 // should not be default one,don't send blank override.
231 if (isStatic)
232 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700233 if ((ipAddress == ipmi::network::DEFAULT_ADDRESS) ||
234 (gateway == ipmi::network::DEFAULT_ADDRESS) || (!prefix))
Ratan Guptad70f4532017-08-04 02:07:31 +0530235 {
Ratan Guptad70f4532017-08-04 02:07:31 +0530236 rc = -1;
237 return rc;
238 }
239 }
240
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000241 std::string token;
242 std::stringstream ss(MACAddress);
Ratan Guptadcb10672017-07-10 10:33:50 +0530243
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000244 // First pack macOffset no of bytes in payload.
245 // Latter this PetiBoot-Specific data will be populated.
246 std::vector<uint8_t> payloadInitialBytes(macOffset);
247 payload.pack(payloadInitialBytes);
Ratan Guptadcb10672017-07-10 10:33:50 +0530248
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000249 while (std::getline(ss, token, ':'))
250 {
251 payload.pack(stoi(token, nullptr, 16));
252 }
253
254 payload.pack(0x00);
255
256 payload.pack(isStatic);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530257
Vernon Maueryf442e112019-04-09 11:44:36 -0700258 uint8_t addressFamily = (std::get<std::string>(properties["Type"]) ==
259 "xyz.openbmc_project.Network.IP.Protocol.IPv4")
260 ? AF_INET
261 : AF_INET6;
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530262
Patrick Venture0b02be92018-08-31 11:55:55 -0700263 addrSize = (addressFamily == AF_INET)
264 ? ipmi::network::IPV4_ADDRESS_SIZE_BYTE
265 : ipmi::network::IPV6_ADDRESS_SIZE_BYTE;
Ratan Guptadcb10672017-07-10 10:33:50 +0530266
267 // ipaddress and gateway would be in IPv4 format
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000268 std::vector<uint8_t> addrInBinary(addrSize);
Ratan Guptad70f4532017-08-04 02:07:31 +0530269 inet_pton(addressFamily, ipAddress.c_str(),
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000270 reinterpret_cast<void*>(addrInBinary.data()));
Ratan Guptadcb10672017-07-10 10:33:50 +0530271
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000272 payload.pack(addrInBinary);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530273
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000274 payload.pack(prefix);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530275
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000276 std::vector<uint8_t> gatewayDetails(addrSize);
Ratan Guptad70f4532017-08-04 02:07:31 +0530277 inet_pton(addressFamily, gateway.c_str(),
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000278 reinterpret_cast<void*>(gatewayDetails.data()));
279 payload.pack(gatewayDetails);
Ratan Guptadcb10672017-07-10 10:33:50 +0530280 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -0500281 catch (const InternalFailure& e)
Ratan Guptadcb10672017-07-10 10:33:50 +0530282 {
283 commit<InternalFailure>();
Ratan Guptadcb10672017-07-10 10:33:50 +0530284 rc = -1;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500285 return rc;
286 }
287
Patrick Venture0b02be92018-08-31 11:55:55 -0700288 // PetiBoot-Specific
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000289 // If success then copy the first 9 bytes to the payload message
290 // payload first 2 bytes contain the parameter values. Skip that 2 bytes.
291 uint8_t skipFirstTwoBytes = 2;
292 size_t payloadSize = payload.size();
293 uint8_t* configDataStartingAddress = payload.data() + skipFirstTwoBytes;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500294
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000295 if (payloadSize < skipFirstTwoBytes + sizeof(netConfInitialBytes))
296 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700297 lg2::error("Invalid net config");
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000298 rc = -1;
299 return rc;
300 }
301 std::copy(netConfInitialBytes,
302 netConfInitialBytes + sizeof(netConfInitialBytes),
303 configDataStartingAddress);
304
305 if (payloadSize < skipFirstTwoBytes + addrSizeOffset + sizeof(addrSize))
306 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700307 lg2::error("Invalid length of address size");
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000308 rc = -1;
309 return rc;
310 }
311 std::copy(&addrSize, &(addrSize) + sizeof(addrSize),
312 configDataStartingAddress + addrSizeOffset);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530313
Ratan Guptafd28dd72016-08-01 04:58:01 -0500314#ifdef _IPMI_DEBUG_
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700315 std::printf("\n===Printing the IPMI Formatted Data========\n");
Ratan Guptafd28dd72016-08-01 04:58:01 -0500316
Ratan Guptadcb10672017-07-10 10:33:50 +0530317 for (uint8_t pos = 0; pos < index; pos++)
318 {
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +0000319 std::printf("%02x ", payloadStartingAddress[pos]);
Ratan Guptadcb10672017-07-10 10:33:50 +0530320 }
Ratan Guptafd28dd72016-08-01 04:58:01 -0500321#endif
322
Ratan Guptafd28dd72016-08-01 04:58:01 -0500323 return rc;
324}
325
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530326/** @brief convert IPv4 and IPv6 addresses from binary to text form.
327 * @param[in] family - IPv4/Ipv6
328 * @param[in] data - req data pointer.
329 * @param[in] offset - offset in the data.
330 * @param[in] addrSize - size of the data which needs to be read from offset.
331 * @returns address in text form.
332 */
333
Patrick Venture0b02be92018-08-31 11:55:55 -0700334std::string getAddrStr(uint8_t family, uint8_t* data, uint8_t offset,
335 uint8_t addrSize)
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530336{
337 char ipAddr[INET6_ADDRSTRLEN] = {};
338
Patrick Venture0b02be92018-08-31 11:55:55 -0700339 switch (family)
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530340 {
341 case AF_INET:
342 {
Patrick Williams99db6882024-12-18 11:20:17 -0500343 struct sockaddr_in addr4{};
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700344 std::memcpy(&addr4.sin_addr.s_addr, &data[offset], addrSize);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530345
Patrick Venture0b02be92018-08-31 11:55:55 -0700346 inet_ntop(AF_INET, &addr4.sin_addr, ipAddr, INET_ADDRSTRLEN);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530347
348 break;
349 }
350 case AF_INET6:
351 {
Patrick Williams99db6882024-12-18 11:20:17 -0500352 struct sockaddr_in6 addr6{};
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700353 std::memcpy(&addr6.sin6_addr.s6_addr, &data[offset], addrSize);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530354
Patrick Venture0b02be92018-08-31 11:55:55 -0700355 inet_ntop(AF_INET6, &addr6.sin6_addr, ipAddr, INET6_ADDRSTRLEN);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530356
357 break;
358 }
359 default:
360 {
361 return {};
362 }
363 }
364
365 return ipAddr;
366}
367
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000368ipmi::Cc setHostNetworkData(ipmi::message::Payload& data)
Ratan Guptafd28dd72016-08-01 04:58:01 -0500369{
Ratan Guptadcb10672017-07-10 10:33:50 +0530370 using namespace std::string_literals;
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000371 std::string hostNetworkConfig;
372 std::string mac("00:00:00:00:00:00");
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530373 std::string ipAddress, gateway;
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000374 std::string addrOrigin{0};
Patrick Venture0b02be92018-08-31 11:55:55 -0700375 uint8_t addrSize{0};
Ratan Guptadcb10672017-07-10 10:33:50 +0530376 std::string addressOrigin =
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530377 "xyz.openbmc_project.Network.IP.AddressOrigin.DHCP";
Patrick Venture0b02be92018-08-31 11:55:55 -0700378 std::string addressType = "xyz.openbmc_project.Network.IP.Protocol.IPv4";
379 uint8_t prefix{0};
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530380 uint8_t family = AF_INET;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500381
Patrick Venture0b02be92018-08-31 11:55:55 -0700382 // cookie starts from second byte
Ratan Guptafd28dd72016-08-01 04:58:01 -0500383 // version starts from sixth byte
384
Ratan Guptadcb10672017-07-10 10:33:50 +0530385 try
Ratan Guptafd28dd72016-08-01 04:58:01 -0500386 {
Ratan Guptadcb10672017-07-10 10:33:50 +0530387 do
388 {
389 // cookie == 0x21 0x70 0x62 0x21
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000390 data.trailingOk = true;
391 auto msgLen = data.size();
392 std::vector<uint8_t> msgPayloadBytes(msgLen);
393 if (data.unpack(msgPayloadBytes) != 0 || !data.fullyUnpacked())
Ratan Guptadcb10672017-07-10 10:33:50 +0530394 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700395 lg2::error("Error in unpacking message of setHostNetworkData");
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000396 return ipmi::ccReqDataLenInvalid;
397 }
398
399 uint8_t* msgPayloadStartingPos = msgPayloadBytes.data();
400 constexpr size_t cookieSize = 4;
401 if (msgLen < cookieOffset + cookieSize)
402 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700403 lg2::error("Error in cookie getting of setHostNetworkData");
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000404 return ipmi::ccReqDataLenInvalid;
405 }
406 if (std::equal(msgPayloadStartingPos + cookieOffset,
407 msgPayloadStartingPos + cookieOffset + cookieSize,
408 (netConfInitialBytes + cookieOffset)) != 0)
409 {
410 // all cookie == 0
411 if (std::all_of(msgPayloadStartingPos + cookieOffset,
412 msgPayloadStartingPos + cookieOffset +
413 cookieSize,
414 [](int i) { return i == 0; }) == true)
Ratan Guptadcb10672017-07-10 10:33:50 +0530415 {
416 // need to zero out the network settings.
417 break;
418 }
419
Vernon Mauery38108d92024-03-11 12:53:55 -0700420 lg2::error("Invalid Cookie");
Ratan Guptadcb10672017-07-10 10:33:50 +0530421 elog<InternalFailure>();
422 }
423
424 // vesion == 0x00 0x01
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000425 if (msgLen < versionOffset + sizeVersion)
Ratan Guptadcb10672017-07-10 10:33:50 +0530426 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700427 lg2::error("Error in version getting of setHostNetworkData");
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000428 return ipmi::ccReqDataLenInvalid;
429 }
430 if (std::equal(msgPayloadStartingPos + versionOffset,
431 msgPayloadStartingPos + versionOffset + sizeVersion,
432 (netConfInitialBytes + versionOffset)) != 0)
433 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700434 lg2::error("Invalid Version");
Ratan Guptadcb10672017-07-10 10:33:50 +0530435 elog<InternalFailure>();
436 }
437
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000438 if (msgLen < macOffset + 6)
439 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700440 lg2::error(
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000441 "Error in mac address getting of setHostNetworkData");
442 return ipmi::ccReqDataLenInvalid;
443 }
444 std::stringstream result;
445 std::copy((msgPayloadStartingPos + macOffset),
446 (msgPayloadStartingPos + macOffset + 5),
447 std::ostream_iterator<int>(result, ":"));
448 mac = result.str();
Ratan Guptadcb10672017-07-10 10:33:50 +0530449
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000450 if (msgLen < addrTypeOffset + sizeof(decltype(addrOrigin)))
451 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700452 lg2::error(
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000453 "Error in original address getting of setHostNetworkData");
454 return ipmi::ccReqDataLenInvalid;
455 }
456 std::copy(msgPayloadStartingPos + addrTypeOffset,
457 msgPayloadStartingPos + addrTypeOffset +
458 sizeof(decltype(addrOrigin)),
459 std::ostream_iterator<int>(result, ""));
460 addrOrigin = result.str();
Ratan Guptadcb10672017-07-10 10:33:50 +0530461
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000462 if (!addrOrigin.empty())
Ratan Guptadcb10672017-07-10 10:33:50 +0530463 {
464 addressOrigin =
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530465 "xyz.openbmc_project.Network.IP.AddressOrigin.Static";
Ratan Guptadcb10672017-07-10 10:33:50 +0530466 }
467
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000468 if (msgLen < addrSizeOffset + sizeof(decltype(addrSize)))
469 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700470 lg2::error(
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000471 "Error in address size getting of setHostNetworkData");
472 return ipmi::ccReqDataLenInvalid;
473 }
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530474 // Get the address size
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000475 std::copy(msgPayloadStartingPos + addrSizeOffset,
476 (msgPayloadStartingPos + addrSizeOffset +
477 sizeof(decltype(addrSize))),
478 &addrSize);
Ratan Guptadcb10672017-07-10 10:33:50 +0530479
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000480 uint8_t prefixOffset = ipAddrOffset + addrSize;
481 if (msgLen < prefixOffset + sizeof(decltype(prefix)))
482 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700483 lg2::error("Error in prefix getting of setHostNetworkData");
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000484 return ipmi::ccReqDataLenInvalid;
485 }
William A. Kennington III4c521022023-07-28 13:07:30 -0700486 // std::copy(msgPayloadStartingPos + prefixOffset,
487 // msgPayloadStartingPos + prefixOffset +
488 // sizeof(decltype(prefix)),
489 // &prefix);
490 // Workaround compiler misdetecting out of bounds memcpy
491 prefix = msgPayloadStartingPos[prefixOffset];
Ratan Guptadcb10672017-07-10 10:33:50 +0530492
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530493 uint8_t gatewayOffset = prefixOffset + sizeof(decltype(prefix));
Ratan Gupta8c31d232017-08-13 05:49:43 +0530494 if (addrSize != ipmi::network::IPV4_ADDRESS_SIZE_BYTE)
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530495 {
496 addressType = "xyz.openbmc_project.Network.IP.Protocol.IPv6";
497 family = AF_INET6;
498 }
499
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000500 if (msgLen < ipAddrOffset + addrSize)
501 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700502 lg2::error("Error in IP address getting of setHostNetworkData");
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000503 return ipmi::ccReqDataLenInvalid;
504 }
505 ipAddress = getAddrStr(family, msgPayloadStartingPos, ipAddrOffset,
506 addrSize);
Ratan Guptad70f4532017-08-04 02:07:31 +0530507
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000508 if (msgLen < gatewayOffset + addrSize)
509 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700510 lg2::error(
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000511 "Error in gateway address getting of setHostNetworkData");
512 return ipmi::ccReqDataLenInvalid;
513 }
514 gateway = getAddrStr(family, msgPayloadStartingPos, gatewayOffset,
515 addrSize);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530516
Patrick Venture0b02be92018-08-31 11:55:55 -0700517 } while (0);
Ratan Guptadcb10672017-07-10 10:33:50 +0530518
Patrick Venture0b02be92018-08-31 11:55:55 -0700519 // Cookie == 0 or it is a valid cookie
Patrick Williams1318a5e2024-08-16 15:19:54 -0400520 hostNetworkConfig +=
521 "ipaddress="s + ipAddress + ",prefix="s + std::to_string(prefix) +
522 ",gateway="s + gateway + ",mac="s + mac + ",addressOrigin="s +
523 addressOrigin;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500524
Patrick Williams5d82f472022-07-22 19:26:53 -0500525 sdbusplus::bus_t bus(ipmid_get_sd_bus_connection());
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530526
527 auto ipObjectInfo = ipmi::getDbusObject(bus, IP_INTERFACE,
528 SETTINGS_ROOT, SETTINGS_MATCH);
529 auto macObjectInfo = ipmi::getDbusObject(bus, MAC_INTERFACE,
530 SETTINGS_ROOT, SETTINGS_MATCH);
Ratan Guptadcb10672017-07-10 10:33:50 +0530531 // set the dbus property
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530532 ipmi::setDbusProperty(bus, ipObjectInfo.second, ipObjectInfo.first,
Patrick Venture0b02be92018-08-31 11:55:55 -0700533 IP_INTERFACE, "Address", std::string(ipAddress));
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530534 ipmi::setDbusProperty(bus, ipObjectInfo.second, ipObjectInfo.first,
Patrick Venture0b02be92018-08-31 11:55:55 -0700535 IP_INTERFACE, "PrefixLength", prefix);
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530536 ipmi::setDbusProperty(bus, ipObjectInfo.second, ipObjectInfo.first,
Patrick Venture0b02be92018-08-31 11:55:55 -0700537 IP_INTERFACE, "Origin", addressOrigin);
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, "Gateway", std::string(gateway));
540 ipmi::setDbusProperty(
541 bus, ipObjectInfo.second, ipObjectInfo.first, IP_INTERFACE, "Type",
542 std::string("xyz.openbmc_project.Network.IP.Protocol.IPv4"));
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530543 ipmi::setDbusProperty(bus, macObjectInfo.second, macObjectInfo.first,
Patrick Venture0b02be92018-08-31 11:55:55 -0700544 MAC_INTERFACE, "MACAddress", std::string(mac));
Ratan Guptafd28dd72016-08-01 04:58:01 -0500545
Vernon Mauery38108d92024-03-11 12:53:55 -0700546 lg2::debug("Network configuration changed: {NETWORKCONFIG}",
547 "NETWORKCONFIG", hostNetworkConfig);
Ratan Guptafd28dd72016-08-01 04:58:01 -0500548 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -0500549 catch (const sdbusplus::exception_t& e)
Ratan Guptadcb10672017-07-10 10:33:50 +0530550 {
551 commit<InternalFailure>();
Vernon Mauery38108d92024-03-11 12:53:55 -0700552 lg2::error("Error in ipmiChassisSetSysBootOptions call");
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000553 return ipmi::ccUnspecifiedError;
Ratan Guptadcb10672017-07-10 10:33:50 +0530554 }
555
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000556 return ipmi::ccSuccess;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500557}
558
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500559uint32_t getPOHCounter()
560{
Patrick Williams5d82f472022-07-22 19:26:53 -0500561 sdbusplus::bus_t bus{ipmid_get_sd_bus_connection()};
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500562
Patrick Williams1318a5e2024-08-16 15:19:54 -0400563 auto chassisStateObj =
564 ipmi::getDbusObject(bus, chassisPOHStateIntf, chassisStateRoot, match);
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500565
Patrick Williams1318a5e2024-08-16 15:19:54 -0400566 auto service =
567 ipmi::getService(bus, chassisPOHStateIntf, chassisStateObj.first);
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500568
Patrick Williams1318a5e2024-08-16 15:19:54 -0400569 auto propValue =
570 ipmi::getDbusProperty(bus, service, chassisStateObj.first,
571 chassisPOHStateIntf, pohCounterProperty);
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500572
Vernon Maueryf442e112019-04-09 11:44:36 -0700573 return std::get<uint32_t>(propValue);
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500574}
575
anil kumar appana43263c62019-05-27 12:45:04 +0000576/** @brief Implements the get chassis capabilities command
577 *
578 * @returns IPMI completion code plus response data
579 * chassisCapFlags - chassis capability flag
580 * chassisFRUInfoDevAddr - chassis FRU info Device Address
581 * chassisSDRDevAddr - chassis SDR device address
582 * chassisSELDevAddr - chassis SEL device address
583 * chassisSMDevAddr - chassis system management device address
584 * chassisBridgeDevAddr - chassis bridge device address
585 */
Karthick Sundarrajan86d8bd72019-11-26 12:48:50 -0800586ipmi::RspType<bool, // chassis intrusion sensor
587 bool, // chassis Front panel lockout
588 bool, // chassis NMI
589 bool, // chassis power interlock
590 uint4_t, // reserved
anil kumar appana43263c62019-05-27 12:45:04 +0000591 uint8_t, // chassis FRU info Device Address
592 uint8_t, // chassis SDR device address
593 uint8_t, // chassis SEL device address
594 uint8_t, // chassis system management device address
595 uint8_t // chassis bridge device address
596 >
597 ipmiGetChassisCap()
Nan Li8d15fb42016-08-16 22:29:40 +0800598{
anil kumar appana43263c62019-05-27 12:45:04 +0000599 ipmi::PropertyMap properties;
Yong Liae4b0402018-11-02 11:12:14 +0800600 try
601 {
Patrick Williams5d82f472022-07-22 19:26:53 -0500602 sdbusplus::bus_t bus{ipmid_get_sd_bus_connection()};
Nan Li8d15fb42016-08-16 22:29:40 +0800603
Yong Liae4b0402018-11-02 11:12:14 +0800604 ipmi::DbusObjectInfo chassisCapObject =
605 ipmi::getDbusObject(bus, chassisCapIntf);
Nan Li8d15fb42016-08-16 22:29:40 +0800606
Yong Liae4b0402018-11-02 11:12:14 +0800607 // capabilities flags
608 // [7..4] - reserved
609 // [3] – 1b = provides power interlock (IPM 1.5)
610 // [2] – 1b = provides Diagnostic Interrupt (FP NMI)
611 // [1] – 1b = provides “Front Panel Lockout” (indicates that the chassis
612 // has capabilities
613 // to lock out external power control and reset button or
614 // front panel interfaces and/or detect tampering with those
615 // interfaces).
616 // [0] -1b = Chassis provides intrusion (physical security) sensor.
617 // set to default value 0x0.
Nan Li8d15fb42016-08-16 22:29:40 +0800618
Patrick Williams1318a5e2024-08-16 15:19:54 -0400619 properties =
620 ipmi::getAllDbusProperties(bus, chassisCapObject.second,
621 chassisCapObject.first, chassisCapIntf);
Yong Liae4b0402018-11-02 11:12:14 +0800622 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -0500623 catch (const std::exception& e)
Yong Liae4b0402018-11-02 11:12:14 +0800624 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700625 lg2::error("Failed to fetch Chassis Capability properties: {ERROR}",
626 "ERROR", e);
anil kumar appana43263c62019-05-27 12:45:04 +0000627 return ipmi::responseUnspecifiedError();
Yong Liae4b0402018-11-02 11:12:14 +0800628 }
629
Karthick Sundarrajan86d8bd72019-11-26 12:48:50 -0800630 bool* chassisIntrusionFlag =
631 std::get_if<bool>(&properties[chassisIntrusionProp]);
632 if (chassisIntrusionFlag == nullptr)
anil kumar appana43263c62019-05-27 12:45:04 +0000633 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700634 lg2::error("Error to get chassis Intrusion flags");
Karthick Sundarrajan86d8bd72019-11-26 12:48:50 -0800635 return ipmi::responseUnspecifiedError();
636 }
637 bool* chassisFrontPanelFlag =
638 std::get_if<bool>(&properties[chassisFrontPanelLockoutProp]);
639 if (chassisFrontPanelFlag == nullptr)
640 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700641 lg2::error("Error to get chassis intrusion flags");
Karthick Sundarrajan86d8bd72019-11-26 12:48:50 -0800642 return ipmi::responseUnspecifiedError();
643 }
644 bool* chassisNMIFlag = std::get_if<bool>(&properties[chassisNMIProp]);
645 if (chassisNMIFlag == nullptr)
646 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700647 lg2::error("Error to get chassis NMI flags");
Karthick Sundarrajan86d8bd72019-11-26 12:48:50 -0800648 return ipmi::responseUnspecifiedError();
649 }
650 bool* chassisPowerInterlockFlag =
651 std::get_if<bool>(&properties[chassisPowerInterlockProp]);
652 if (chassisPowerInterlockFlag == nullptr)
653 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700654 lg2::error("Error to get chassis power interlock flags");
anil kumar appana43263c62019-05-27 12:45:04 +0000655 return ipmi::responseUnspecifiedError();
656 }
657 uint8_t* chassisFRUInfoDevAddr =
658 std::get_if<uint8_t>(&properties[chassisFRUDevAddrProp]);
659 if (chassisFRUInfoDevAddr == nullptr)
660 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700661 lg2::error("Error to get chassis FRU info device address");
anil kumar appana43263c62019-05-27 12:45:04 +0000662 return ipmi::responseUnspecifiedError();
663 }
664 uint8_t* chassisSDRDevAddr =
665 std::get_if<uint8_t>(&properties[chassisSDRDevAddrProp]);
666 if (chassisSDRDevAddr == nullptr)
667 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700668 lg2::error("Error to get chassis SDR device address");
anil kumar appana43263c62019-05-27 12:45:04 +0000669 return ipmi::responseUnspecifiedError();
670 }
671 uint8_t* chassisSELDevAddr =
672 std::get_if<uint8_t>(&properties[chassisSELDevAddrProp]);
673 if (chassisSELDevAddr == nullptr)
674 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700675 lg2::error("Error to get chassis SEL device address");
anil kumar appana43263c62019-05-27 12:45:04 +0000676 return ipmi::responseUnspecifiedError();
677 }
678 uint8_t* chassisSMDevAddr =
679 std::get_if<uint8_t>(&properties[chassisSMDevAddrProp]);
680 if (chassisSMDevAddr == nullptr)
681 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700682 lg2::error("Error to get chassis SM device address");
anil kumar appana43263c62019-05-27 12:45:04 +0000683 return ipmi::responseUnspecifiedError();
684 }
685 uint8_t* chassisBridgeDevAddr =
686 std::get_if<uint8_t>(&properties[chassisBridgeDevAddrProp]);
687 if (chassisBridgeDevAddr == nullptr)
688 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700689 lg2::error("Error to get chassis bridge device address");
anil kumar appana43263c62019-05-27 12:45:04 +0000690 return ipmi::responseUnspecifiedError();
691 }
692
Patrick Williams1318a5e2024-08-16 15:19:54 -0400693 return ipmi::responseSuccess(
694 *chassisIntrusionFlag, *chassisFrontPanelFlag, *chassisNMIFlag,
695 *chassisPowerInterlockFlag, 0, *chassisFRUInfoDevAddr,
696 *chassisSDRDevAddr, *chassisSELDevAddr, *chassisSMDevAddr,
697 *chassisBridgeDevAddr);
Yong Liae4b0402018-11-02 11:12:14 +0800698}
699
anil kumar appana894d0222019-05-27 16:32:14 +0000700/** @brief implements set chassis capalibities command
701 * @param intrusion - chassis intrusion
702 * @param fpLockout - frontpannel lockout
703 * @param reserved1 - skip one bit
704 * @param fruDeviceAddr - chassis FRU info Device Address
705 * @param sdrDeviceAddr - chassis SDR device address
706 * @param selDeviceAddr - chassis SEL device address
707 * @param smDeviceAddr - chassis system management device address
708 * @param bridgeDeviceAddr - chassis bridge device address
709 *
710 * @returns IPMI completion code
711 */
Patrick Williams1318a5e2024-08-16 15:19:54 -0400712ipmi::RspType<> ipmiSetChassisCap(
713 bool intrusion, bool fpLockout, uint6_t reserved1,
anil kumar appana894d0222019-05-27 16:32:14 +0000714
Patrick Williams1318a5e2024-08-16 15:19:54 -0400715 uint8_t fruDeviceAddr,
anil kumar appana894d0222019-05-27 16:32:14 +0000716
Patrick Williams1318a5e2024-08-16 15:19:54 -0400717 uint8_t sdrDeviceAddr,
anil kumar appana894d0222019-05-27 16:32:14 +0000718
Patrick Williams1318a5e2024-08-16 15:19:54 -0400719 uint8_t selDeviceAddr,
anil kumar appana894d0222019-05-27 16:32:14 +0000720
Patrick Williams1318a5e2024-08-16 15:19:54 -0400721 uint8_t smDeviceAddr,
anil kumar appana894d0222019-05-27 16:32:14 +0000722
Patrick Williams1318a5e2024-08-16 15:19:54 -0400723 uint8_t bridgeDeviceAddr)
Yong Liae4b0402018-11-02 11:12:14 +0800724{
Yong Liae4b0402018-11-02 11:12:14 +0800725 // check input data
anil kumar appana894d0222019-05-27 16:32:14 +0000726 if (reserved1 != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800727 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700728 lg2::error("Unsupported request parameter");
anil kumar appana894d0222019-05-27 16:32:14 +0000729 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800730 }
731
anil kumar appana894d0222019-05-27 16:32:14 +0000732 if ((fruDeviceAddr & ~chassisCapAddrMask) != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800733 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700734 lg2::error("Unsupported request parameter(FRU Addr) for REQ={REQ}",
735 "REQ", lg2::hex, fruDeviceAddr);
anil kumar appana894d0222019-05-27 16:32:14 +0000736 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800737 }
anil kumar appana894d0222019-05-27 16:32:14 +0000738 if ((sdrDeviceAddr & ~chassisCapAddrMask) != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800739 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700740 lg2::error("Unsupported request parameter(SDR Addr) for REQ={REQ}",
741 "REQ", lg2::hex, sdrDeviceAddr);
anil kumar appana894d0222019-05-27 16:32:14 +0000742 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800743 }
744
anil kumar appana894d0222019-05-27 16:32:14 +0000745 if ((selDeviceAddr & ~chassisCapAddrMask) != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800746 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700747 lg2::error("Unsupported request parameter(SEL Addr) for REQ={REQ}",
748 "REQ", lg2::hex, selDeviceAddr);
anil kumar appana894d0222019-05-27 16:32:14 +0000749 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800750 }
751
anil kumar appana894d0222019-05-27 16:32:14 +0000752 if ((smDeviceAddr & ~chassisCapAddrMask) != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800753 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700754 lg2::error("Unsupported request parameter(SM Addr) for REQ={REQ}",
755 "REQ", lg2::hex, smDeviceAddr);
anil kumar appana894d0222019-05-27 16:32:14 +0000756 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800757 }
758
anil kumar appana894d0222019-05-27 16:32:14 +0000759 if ((bridgeDeviceAddr & ~chassisCapAddrMask) != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800760 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700761 lg2::error("Unsupported request parameter(Bridge Addr) for REQ={REQ}",
762 "REQ", lg2::hex, bridgeDeviceAddr);
anil kumar appana894d0222019-05-27 16:32:14 +0000763 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800764 }
765
766 try
767 {
Patrick Williams5d82f472022-07-22 19:26:53 -0500768 sdbusplus::bus_t bus(ipmid_get_sd_bus_connection());
Yong Liae4b0402018-11-02 11:12:14 +0800769 ipmi::DbusObjectInfo chassisCapObject =
770 ipmi::getDbusObject(bus, chassisCapIntf);
771
772 ipmi::setDbusProperty(bus, chassisCapObject.second,
773 chassisCapObject.first, chassisCapIntf,
Karthick Sundarrajan86d8bd72019-11-26 12:48:50 -0800774 chassisIntrusionProp, intrusion);
775
776 ipmi::setDbusProperty(bus, chassisCapObject.second,
777 chassisCapObject.first, chassisCapIntf,
778 chassisFrontPanelLockoutProp, fpLockout);
Yong Liae4b0402018-11-02 11:12:14 +0800779
780 ipmi::setDbusProperty(bus, chassisCapObject.second,
781 chassisCapObject.first, chassisCapIntf,
anil kumar appana894d0222019-05-27 16:32:14 +0000782 chassisFRUDevAddrProp, fruDeviceAddr);
Yong Liae4b0402018-11-02 11:12:14 +0800783
784 ipmi::setDbusProperty(bus, chassisCapObject.second,
785 chassisCapObject.first, chassisCapIntf,
anil kumar appana894d0222019-05-27 16:32:14 +0000786 chassisSDRDevAddrProp, sdrDeviceAddr);
Yong Liae4b0402018-11-02 11:12:14 +0800787
788 ipmi::setDbusProperty(bus, chassisCapObject.second,
789 chassisCapObject.first, chassisCapIntf,
anil kumar appana894d0222019-05-27 16:32:14 +0000790 chassisSELDevAddrProp, selDeviceAddr);
Yong Liae4b0402018-11-02 11:12:14 +0800791
792 ipmi::setDbusProperty(bus, chassisCapObject.second,
793 chassisCapObject.first, chassisCapIntf,
anil kumar appana894d0222019-05-27 16:32:14 +0000794 chassisSMDevAddrProp, smDeviceAddr);
Yong Liae4b0402018-11-02 11:12:14 +0800795
796 ipmi::setDbusProperty(bus, chassisCapObject.second,
797 chassisCapObject.first, chassisCapIntf,
anil kumar appana894d0222019-05-27 16:32:14 +0000798 chassisBridgeDevAddrProp, bridgeDeviceAddr);
Yong Liae4b0402018-11-02 11:12:14 +0800799 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -0500800 catch (const std::exception& e)
Yong Liae4b0402018-11-02 11:12:14 +0800801 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700802 lg2::error("Failed to set chassis capability properties: {ERR}", "ERR",
803 e);
anil kumar appana894d0222019-05-27 16:32:14 +0000804 return ipmi::responseUnspecifiedError();
Yong Liae4b0402018-11-02 11:12:14 +0800805 }
anil kumar appana894d0222019-05-27 16:32:14 +0000806 return ipmi::responseSuccess();
Nan Li8d15fb42016-08-16 22:29:40 +0800807}
808
Vishwanatha Subbannab12b0c02017-03-07 18:17:19 +0530809//------------------------------------------
810// Calls into Host State Manager Dbus object
811//------------------------------------------
Jason M. Bills664e1c32020-01-30 16:02:39 -0800812int initiateHostStateTransition(ipmi::Context::ptr& ctx,
813 State::Host::Transition transition)
vishwa36993272015-11-20 12:43:49 -0600814{
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500815 // OpenBMC Host State Manager dbus framework
Jason M. Bills664e1c32020-01-30 16:02:39 -0800816 constexpr auto hostStatePath = "/xyz/openbmc_project/state/host0";
817 constexpr auto hostStateIntf = "xyz.openbmc_project.State.Host";
Vishwanatha Subbannab12b0c02017-03-07 18:17:19 +0530818
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500819 // Convert to string equivalent of the passed in transition enum.
Willy Tu523e2d12023-09-05 11:36:48 -0700820 auto request =
821 sdbusplus::common::xyz::openbmc_project::state::convertForMessage(
822 transition);
Vishwanatha Subbannab12b0c02017-03-07 18:17:19 +0530823
Jason M. Bills664e1c32020-01-30 16:02:39 -0800824 std::string service;
Patrick Williams1318a5e2024-08-16 15:19:54 -0400825 boost::system::error_code ec =
826 ipmi::getService(ctx, hostStateIntf, hostStatePath, service);
Jason M. Bills664e1c32020-01-30 16:02:39 -0800827
828 if (!ec)
829 {
830 ec = ipmi::setDbusProperty(ctx, service, hostStatePath, hostStateIntf,
831 "RequestedHostTransition", request);
832 }
833 if (ec)
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500834 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700835 lg2::error(
836 "Failed to initiate transition for request {REQUEST}: {EXCEPTION}",
837 "REQUEST", request, "EXCEPTION", ec.message());
Jason M. Bills664e1c32020-01-30 16:02:39 -0800838 return -1;
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500839 }
Vernon Mauery38108d92024-03-11 12:53:55 -0700840 lg2::info(
841 "Transition request {REQUEST} initiated successfully by user {USERID}",
842 "REQUEST", request, "USERID", ctx->userId);
Jason M. Bills664e1c32020-01-30 16:02:39 -0800843 return 0;
vishwa36993272015-11-20 12:43:49 -0600844}
845
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +0800846//------------------------------------------
Jason M. Billsad588bf2020-01-30 16:18:33 -0800847// Calls into Chassis State Manager Dbus object
848//------------------------------------------
849int initiateChassisStateTransition(ipmi::Context::ptr& ctx,
850 State::Chassis::Transition transition)
851{
852 // OpenBMC Chassis State Manager dbus framework
853 constexpr auto chassisStatePath = "/xyz/openbmc_project/state/chassis0";
854 constexpr auto chassisStateIntf = "xyz.openbmc_project.State.Chassis";
855
856 std::string service;
Patrick Williams1318a5e2024-08-16 15:19:54 -0400857 boost::system::error_code ec =
858 ipmi::getService(ctx, chassisStateIntf, chassisStatePath, service);
Jason M. Billsad588bf2020-01-30 16:18:33 -0800859
860 // Convert to string equivalent of the passed in transition enum.
Willy Tu523e2d12023-09-05 11:36:48 -0700861 auto request =
862 sdbusplus::common::xyz::openbmc_project::state::convertForMessage(
863 transition);
Jason M. Billsad588bf2020-01-30 16:18:33 -0800864
865 if (!ec)
866 {
867 ec = ipmi::setDbusProperty(ctx, service, chassisStatePath,
868 chassisStateIntf, "RequestedPowerTransition",
869 request);
870 }
871 if (ec)
872 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700873 lg2::error("Failed to initiate transition {REQUEST}: {EXCEPTION}",
874 "REQUEST", request, "EXCEPTION", ec.message());
875
Jason M. Billsad588bf2020-01-30 16:18:33 -0800876 return -1;
877 }
878
879 return 0;
880}
881
882//------------------------------------------
Zev Weiss337a0972024-03-08 08:31:15 +0000883// Trigger an NMI on the host via dbus
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +0800884//------------------------------------------
Zev Weiss337a0972024-03-08 08:31:15 +0000885static int doNmi(ipmi::Context::ptr& ctx)
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +0800886{
Zev Weiss337a0972024-03-08 08:31:15 +0000887 constexpr const char* nmiIntfName = "xyz.openbmc_project.Control.Host.NMI";
888 ipmi::DbusObjectInfo nmiObj{};
889 boost::system::error_code ec;
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +0800890
Zev Weiss337a0972024-03-08 08:31:15 +0000891 ec = ipmi::getDbusObject(ctx, nmiIntfName, nmiObj);
Vernon Mauery9bb4a382021-11-05 12:46:19 -0700892 if (ec)
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +0800893 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700894 lg2::error("Failed to find NMI service: {ERROR}", "ERROR",
895 ec.message());
Zev Weiss337a0972024-03-08 08:31:15 +0000896 return -1;
897 }
898
George Liude1420d2025-03-03 15:14:25 +0800899 ec = ipmi::callDbusMethod(ctx, nmiObj.second, nmiObj.first, nmiIntfName,
900 "NMI");
Zev Weiss337a0972024-03-08 08:31:15 +0000901 if (ec)
902 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700903 lg2::error("NMI call failed: {ERROR}", "ERROR", ec.message());
Zev Weiss337a0972024-03-08 08:31:15 +0000904 elog<InternalFailure>();
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +0800905 return -1;
906 }
907
908 return 0;
909}
910
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500911namespace power_policy
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500912{
Nan Lifdd8ec52016-08-28 03:57:40 +0800913
Willy Tu523e2d12023-09-05 11:36:48 -0700914using namespace sdbusplus::server::xyz::openbmc_project::control::power;
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500915using IpmiValue = uint8_t;
916using DbusValue = RestorePolicy::Policy;
Nan Lifdd8ec52016-08-28 03:57:40 +0800917
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700918const std::map<DbusValue, IpmiValue> dbusToIpmi = {
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500919 {RestorePolicy::Policy::AlwaysOff, 0x00},
920 {RestorePolicy::Policy::Restore, 0x01},
George Liue561d3e2024-02-04 15:19:30 +0800921 {RestorePolicy::Policy::AlwaysOn, 0x02},
922 {RestorePolicy::Policy::None, 0x03}};
Nan Lifdd8ec52016-08-28 03:57:40 +0800923
Yong Lic6713cf2018-09-12 12:35:13 +0800924static constexpr uint8_t noChange = 0x03;
925static constexpr uint8_t allSupport = 0x01 | 0x02 | 0x04;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700926
927/* helper function for Get Chassis Status Command
928 */
929std::optional<uint2_t> getPowerRestorePolicy()
930{
931 uint2_t restorePolicy = 0;
932 using namespace chassis::internal;
933
James Feist225dec82019-11-26 16:25:06 -0800934 settings::Objects& objects = cache::getObjects();
935
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700936 try
937 {
938 const auto& powerRestoreSetting =
James Feist225dec82019-11-26 16:25:06 -0800939 objects.map.at(powerRestoreIntf).front();
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700940 ipmi::Value result = ipmi::getDbusProperty(
941 *getSdBus(),
James Feist225dec82019-11-26 16:25:06 -0800942 objects.service(powerRestoreSetting, powerRestoreIntf).c_str(),
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700943 powerRestoreSetting.c_str(), powerRestoreIntf,
944 "PowerRestorePolicy");
945 auto powerRestore = RestorePolicy::convertPolicyFromString(
946 std::get<std::string>(result));
947 restorePolicy = dbusToIpmi.at(powerRestore);
948 }
949 catch (const std::exception& e)
950 {
Vernon Mauery38108d92024-03-11 12:53:55 -0700951 lg2::error(
952 "Failed to fetch pgood property ({PATH}/{INTERFACE}): {ERROR}",
953 "PATH", objects.map.at(powerRestoreIntf).front(), "INTERFACE",
954 powerRestoreIntf, "ERROR", e);
James Feist225dec82019-11-26 16:25:06 -0800955 cache::objectsPtr.reset();
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700956 return std::nullopt;
957 }
958 return std::make_optional(restorePolicy);
959}
960
961/*
962 * getPowerStatus
963 * helper function for Get Chassis Status Command
964 * return - optional value for pgood (no value on error)
965 */
966std::optional<bool> getPowerStatus()
967{
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700968 bool powerGood = false;
969 std::shared_ptr<sdbusplus::asio::connection> busp = getSdBus();
970 try
971 {
Jason M. Bills3de424c2019-05-21 09:57:16 -0700972 constexpr const char* chassisStatePath =
973 "/xyz/openbmc_project/state/chassis0";
974 constexpr const char* chassisStateIntf =
975 "xyz.openbmc_project.State.Chassis";
Patrick Williams1318a5e2024-08-16 15:19:54 -0400976 auto service =
977 ipmi::getService(*busp, chassisStateIntf, chassisStatePath);
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700978
Jason M. Bills3de424c2019-05-21 09:57:16 -0700979 ipmi::Value powerState =
980 ipmi::getDbusProperty(*busp, service, chassisStatePath,
981 chassisStateIntf, "CurrentPowerState");
Chau Lyee3983b2024-01-05 07:33:45 +0000982 std::string powerStateStr = std::get<std::string>(powerState);
983 if (powerStateStr.ends_with(".On") ||
984 powerStateStr.ends_with(".TransitioningToOff"))
985 {
986 powerGood = true;
987 }
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700988 }
989 catch (const std::exception& e)
990 {
991 try
992 {
993 // FIXME: some legacy modules use the older path; try that next
994 constexpr const char* legacyPwrCtrlObj =
995 "/org/openbmc/control/power0";
996 constexpr const char* legacyPwrCtrlIntf =
997 "org.openbmc.control.Power";
Patrick Williams1318a5e2024-08-16 15:19:54 -0400998 auto service =
999 ipmi::getService(*busp, legacyPwrCtrlIntf, legacyPwrCtrlObj);
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001000
1001 ipmi::Value variant = ipmi::getDbusProperty(
1002 *busp, service, legacyPwrCtrlObj, legacyPwrCtrlIntf, "pgood");
1003 powerGood = static_cast<bool>(std::get<int>(variant));
1004 }
1005 catch (const std::exception& e)
1006 {
Vernon Mauery38108d92024-03-11 12:53:55 -07001007 lg2::error("Failed to fetch pgood property: {ERROR}", "ERROR", e);
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001008 return std::nullopt;
1009 }
1010 }
1011 return std::make_optional(powerGood);
1012}
1013
Yong Li70ce7352019-05-16 21:15:27 +08001014/*
1015 * getACFailStatus
1016 * helper function for Get Chassis Status Command
1017 * return - bool value for ACFail (false on error)
1018 */
1019bool getACFailStatus()
1020{
1021 constexpr const char* powerControlObj =
1022 "/xyz/openbmc_project/Chassis/Control/Power0";
1023 constexpr const char* powerControlIntf =
1024 "xyz.openbmc_project.Chassis.Control.Power";
1025 bool acFail = false;
1026 std::shared_ptr<sdbusplus::asio::connection> bus = getSdBus();
1027 try
1028 {
Patrick Williams1318a5e2024-08-16 15:19:54 -04001029 auto service =
1030 ipmi::getService(*bus, powerControlIntf, powerControlObj);
Yong Li70ce7352019-05-16 21:15:27 +08001031
1032 ipmi::Value variant = ipmi::getDbusProperty(
1033 *bus, service, powerControlObj, powerControlIntf, "PFail");
1034 acFail = std::get<bool>(variant);
1035 }
1036 catch (const std::exception& e)
1037 {
Vernon Mauery38108d92024-03-11 12:53:55 -07001038 lg2::error(
Konstantin Aladyshev37de2e12025-01-29 11:49:26 +03001039 "Failed to fetch PFail property ({PATH}/{INTERFACE}): {ERROR}",
Vernon Mauery38108d92024-03-11 12:53:55 -07001040 "PATH", powerControlObj, "INTERFACE", powerControlIntf, "ERROR", e);
Yong Li70ce7352019-05-16 21:15:27 +08001041 }
1042 return acFail;
1043}
Deepak Kodihalli18b70d12017-07-21 13:36:33 -05001044} // namespace power_policy
Nan Lifdd8ec52016-08-28 03:57:40 +08001045
Patrick Williams615a14e2025-04-07 17:07:24 -04001046static std::optional<bool> getButtonDisabled(ipmi::Context::ptr& ctx,
1047 const std::string& buttonPath,
1048 const std::string& buttonIntf)
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001049{
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001050 bool buttonDisabled = false;
Konstantin Aladyshev2738b9e2025-02-15 00:56:19 +03001051 boost::system::error_code ec;
1052 std::string service;
1053 ec = ipmi::getService(ctx, buttonIntf, buttonPath, service);
1054 if (!ec)
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001055 {
Konstantin Aladyshev2738b9e2025-02-15 00:56:19 +03001056 bool enabled;
1057 ec = ipmi::getDbusProperty(ctx, service, buttonPath, buttonIntf,
1058 "Enabled", enabled);
1059 buttonDisabled = !enabled;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001060 }
Konstantin Aladyshev2738b9e2025-02-15 00:56:19 +03001061
1062 if (ec)
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001063 {
Vernon Mauery38108d92024-03-11 12:53:55 -07001064 lg2::error("Fail to get button Enabled property ({PATH}): {ERROR}",
Konstantin Aladyshev2738b9e2025-02-15 00:56:19 +03001065 "PATH", buttonPath, "ERROR", ec.message());
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001066 return std::nullopt;
1067 }
1068 return std::make_optional(buttonDisabled);
1069}
1070
Konstantin Aladyshev305d8642025-02-15 00:36:54 +03001071static bool setButtonDisabled(ipmi::Context::ptr& ctx,
1072 const std::string& buttonPath,
1073 const std::string& buttonIntf, bool disable)
Kuiying Wang21addc52019-01-04 10:50:21 +08001074{
1075 std::string service;
1076 boost::system::error_code ec;
1077 ec = ipmi::getService(ctx, buttonIntf, buttonPath, service);
1078 if (!ec)
1079 {
1080 ec = ipmi::setDbusProperty(ctx, service, buttonPath, buttonIntf,
Konstantin Aladyshev305d8642025-02-15 00:36:54 +03001081 "Enabled", !disable);
Kuiying Wang21addc52019-01-04 10:50:21 +08001082 }
1083 if (ec)
1084 {
Vernon Mauery38108d92024-03-11 12:53:55 -07001085 lg2::error(
1086 "Fail to set button Enabled property ({SERVICE}:{PATH}): {ERROR}",
1087 "SERVICE", service, "PATH", buttonPath, "ERROR", ec.message());
Kuiying Wang21addc52019-01-04 10:50:21 +08001088 return false;
1089 }
1090 return true;
1091}
1092
Chau Ly9e666cd2023-03-06 08:46:14 +00001093static std::optional<bool> getChassisIntrusionStatus(ipmi::Context::ptr& ctx)
1094{
Chau Ly8c1376c2024-01-05 07:22:10 +00001095 std::vector<std::string> interfaces = {std::string(Intrusion::interface)};
1096 ipmi::ObjectTree objs;
1097 std::string propVal;
1098 std::optional<bool> ret = std::nullopt;
Chau Ly9e666cd2023-03-06 08:46:14 +00001099
Chau Ly8c1376c2024-01-05 07:22:10 +00001100 boost::system::error_code ec =
1101 ipmi::getSubTree(ctx, interfaces, std::string("/"), 0, objs);
1102
1103 if (ec)
Chau Ly9e666cd2023-03-06 08:46:14 +00001104 {
Chau Ly8c1376c2024-01-05 07:22:10 +00001105 lg2::error("Fail to find Chassis Intrusion Interface on D-Bus "
1106 "({INTERFACE}): {ERROR}",
1107 "INTERFACE", Intrusion::interface, "ERROR", ec.message());
1108 return ret;
1109 }
1110
1111 for (const auto& [path, map] : objs)
1112 {
1113 for (const auto& [service, intfs] : map)
Chau Ly9e666cd2023-03-06 08:46:14 +00001114 {
Chau Ly8c1376c2024-01-05 07:22:10 +00001115 ec = ipmi::getDbusProperty<std::string>(
1116 ctx, service, path, Intrusion::interface, "Status", propVal);
Jayanth Othayoth195d5522025-06-07 02:28:07 -05001117
Chau Ly8c1376c2024-01-05 07:22:10 +00001118 if (ec)
1119 {
Jayanth Othayoth195d5522025-06-07 02:28:07 -05001120 lg2::error("Failed to get Chassis Intrusion Status property "
Chau Ly8c1376c2024-01-05 07:22:10 +00001121 "({SERVICE}/{PATH}/{INTERFACE}): {ERROR}",
1122 "SERVICE", service, "PATH", path, "INTERFACE",
1123 Intrusion::interface, "ERROR", ec.message());
Jayanth Othayoth195d5522025-06-07 02:28:07 -05001124 continue;
Chau Ly8c1376c2024-01-05 07:22:10 +00001125 }
Jayanth Othayoth195d5522025-06-07 02:28:07 -05001126
1127 auto statusOpt =
1128 sdbusplus::message::convert_from_string<Intrusion::Status>(
1129 propVal);
1130 if (statusOpt)
Chau Ly8c1376c2024-01-05 07:22:10 +00001131 {
Jayanth Othayoth195d5522025-06-07 02:28:07 -05001132 if (*statusOpt == Intrusion::Status::Normal)
Chau Ly8c1376c2024-01-05 07:22:10 +00001133 {
1134 ret = std::make_optional(false);
1135 }
1136 else
1137 {
1138 ret = std::make_optional(true);
Jayanth Othayoth195d5522025-06-07 02:28:07 -05001139 return ret; // Early return on first non-Normal status
Chau Ly8c1376c2024-01-05 07:22:10 +00001140 }
1141 }
Jayanth Othayoth195d5522025-06-07 02:28:07 -05001142 else
1143 {
1144 lg2::warning(
1145 "Invalid Intrusion::Status value received: {VALUE}",
1146 "VALUE", propVal);
1147 return std::nullopt;
1148 }
Chau Ly9e666cd2023-03-06 08:46:14 +00001149 }
1150 }
Chau Ly8c1376c2024-01-05 07:22:10 +00001151 return ret;
Chau Ly9e666cd2023-03-06 08:46:14 +00001152}
1153
Nan Lifdd8ec52016-08-28 03:57:40 +08001154//----------------------------------------------------------------------
1155// Get Chassis Status commands
1156//----------------------------------------------------------------------
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001157ipmi::RspType<bool, // Power is on
1158 bool, // Power overload
1159 bool, // Interlock
1160 bool, // power fault
1161 bool, // power control fault
1162 uint2_t, // power restore policy
1163 bool, // reserved
1164
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05001165 bool, // AC failed
1166 bool, // last power down caused by a Power overload
1167 bool, // last power down caused by a power interlock
1168 bool, // last power down caused by power fault
Patrick Williams99db6882024-12-18 11:20:17 -05001169 bool, // last ‘Power is on’ state was entered via IPMI command
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001170 uint3_t, // reserved
1171
1172 bool, // Chassis intrusion active
1173 bool, // Front Panel Lockout active
1174 bool, // Drive Fault
1175 bool, // Cooling/fan fault detected
1176 uint2_t, // Chassis Identify State
1177 bool, // Chassis Identify command and state info supported
1178 bool, // reserved
1179
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05001180 bool, // Power off button disabled
1181 bool, // Reset button disabled
1182 bool, // Diagnostic Interrupt button disabled
1183 bool, // Standby (sleep) button disabled
1184 bool, // Power off button disable allowed
1185 bool, // Reset button disable allowed
1186 bool, // Diagnostic Interrupt button disable allowed
1187 bool // Standby (sleep) button disable allowed
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001188 >
Chau Ly9e666cd2023-03-06 08:46:14 +00001189 ipmiGetChassisStatus(ipmi::Context::ptr& ctx)
Nan Lifdd8ec52016-08-28 03:57:40 +08001190{
Deepak Kodihalli18b70d12017-07-21 13:36:33 -05001191 using namespace chassis::internal;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001192 std::optional<uint2_t> restorePolicy =
1193 power_policy::getPowerRestorePolicy();
1194 std::optional<bool> powerGood = power_policy::getPowerStatus();
1195 if (!restorePolicy || !powerGood)
Deepak Kodihalli18b70d12017-07-21 13:36:33 -05001196 {
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001197 return ipmi::responseUnspecifiedError();
Deepak Kodihalli18b70d12017-07-21 13:36:33 -05001198 }
Nan Lifdd8ec52016-08-28 03:57:40 +08001199
1200 // Front Panel Button Capabilities and disable/enable status(Optional)
Patrick Williams1318a5e2024-08-16 15:19:54 -04001201 std::optional<bool> powerButtonReading =
Konstantin Aladyshev2738b9e2025-02-15 00:56:19 +03001202 getButtonDisabled(ctx, powerButtonPath, powerButtonIntf);
Vernon Mauery6d5b2f72019-05-16 14:48:47 -07001203 // allow disable if the interface is present
1204 bool powerButtonDisableAllow = static_cast<bool>(powerButtonReading);
1205 // default return the button is enabled (not disabled)
1206 bool powerButtonDisabled = false;
1207 if (powerButtonDisableAllow)
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001208 {
Vernon Mauery6d5b2f72019-05-16 14:48:47 -07001209 // return the real value of the button status, if present
1210 powerButtonDisabled = *powerButtonReading;
1211 }
1212
Patrick Williams1318a5e2024-08-16 15:19:54 -04001213 std::optional<bool> resetButtonReading =
Konstantin Aladyshev2738b9e2025-02-15 00:56:19 +03001214 getButtonDisabled(ctx, resetButtonPath, resetButtonIntf);
Vernon Mauery6d5b2f72019-05-16 14:48:47 -07001215 // allow disable if the interface is present
1216 bool resetButtonDisableAllow = static_cast<bool>(resetButtonReading);
1217 // default return the button is enabled (not disabled)
1218 bool resetButtonDisabled = false;
1219 if (resetButtonDisableAllow)
1220 {
1221 // return the real value of the button status, if present
1222 resetButtonDisabled = *resetButtonReading;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001223 }
Nan Lifdd8ec52016-08-28 03:57:40 +08001224
Yong Li70ce7352019-05-16 21:15:27 +08001225 bool powerDownAcFailed = power_policy::getACFailStatus();
1226
Chau Ly9e666cd2023-03-06 08:46:14 +00001227 bool chassisIntrusionActive = false;
1228 std::optional<bool> chassisIntrusionStatus = getChassisIntrusionStatus(ctx);
1229 if (chassisIntrusionStatus)
1230 {
1231 chassisIntrusionActive = chassisIntrusionStatus.value();
1232 }
1233
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001234 // This response has a lot of hard-coded, unsupported fields
1235 // They are set to false or 0
1236 constexpr bool powerOverload = false;
1237 constexpr bool chassisInterlock = false;
1238 constexpr bool powerFault = false;
1239 constexpr bool powerControlFault = false;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001240 constexpr bool powerDownOverload = false;
1241 constexpr bool powerDownInterlock = false;
1242 constexpr bool powerDownPowerFault = false;
1243 constexpr bool powerStatusIPMI = false;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001244 constexpr bool frontPanelLockoutActive = false;
1245 constexpr bool driveFault = false;
1246 constexpr bool coolingFanFault = false;
1247 // chassisIdentifySupport set because this command is implemented
1248 constexpr bool chassisIdentifySupport = true;
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001249 uint2_t chassisIdentifyState = types::enum_cast<uint2_t>(chassisIDState);
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001250 constexpr bool diagButtonDisabled = false;
1251 constexpr bool sleepButtonDisabled = false;
1252 constexpr bool diagButtonDisableAllow = false;
1253 constexpr bool sleepButtonDisableAllow = false;
1254
1255 return ipmi::responseSuccess(
1256 *powerGood, powerOverload, chassisInterlock, powerFault,
1257 powerControlFault, *restorePolicy,
1258 false, // reserved
1259
1260 powerDownAcFailed, powerDownOverload, powerDownInterlock,
1261 powerDownPowerFault, powerStatusIPMI,
1262 uint3_t(0), // reserved
1263
1264 chassisIntrusionActive, frontPanelLockoutActive, driveFault,
1265 coolingFanFault, chassisIdentifyState, chassisIdentifySupport,
1266 false, // reserved
1267
Vernon Mauery6d5b2f72019-05-16 14:48:47 -07001268 powerButtonDisabled, resetButtonDisabled, diagButtonDisabled,
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001269 sleepButtonDisabled, powerButtonDisableAllow, resetButtonDisableAllow,
1270 diagButtonDisableAllow, sleepButtonDisableAllow);
Nan Lifdd8ec52016-08-28 03:57:40 +08001271}
Chris Austen7888c4d2015-12-03 15:26:20 -06001272
Vijay Khemka074f64d2020-03-03 15:08:43 -08001273enum class IpmiRestartCause
1274{
1275 Unknown = 0x0,
1276 RemoteCommand = 0x1,
1277 ResetButton = 0x2,
1278 PowerButton = 0x3,
1279 WatchdogTimer = 0x4,
1280 PowerPolicyAlwaysOn = 0x6,
1281 PowerPolicyPreviousState = 0x7,
1282 SoftReset = 0xa,
1283};
1284
Patrick Williams69b4c282025-03-03 11:19:13 -05001285static IpmiRestartCause restartCauseToIpmiRestartCause(
1286 State::Host::RestartCause cause)
Vijay Khemka074f64d2020-03-03 15:08:43 -08001287{
1288 switch (cause)
1289 {
1290 case State::Host::RestartCause::Unknown:
1291 {
1292 return IpmiRestartCause::Unknown;
1293 }
1294 case State::Host::RestartCause::RemoteCommand:
1295 {
1296 return IpmiRestartCause::RemoteCommand;
1297 }
1298 case State::Host::RestartCause::ResetButton:
1299 {
1300 return IpmiRestartCause::ResetButton;
1301 }
1302 case State::Host::RestartCause::PowerButton:
1303 {
1304 return IpmiRestartCause::PowerButton;
1305 }
1306 case State::Host::RestartCause::WatchdogTimer:
1307 {
1308 return IpmiRestartCause::WatchdogTimer;
1309 }
1310 case State::Host::RestartCause::PowerPolicyAlwaysOn:
1311 {
1312 return IpmiRestartCause::PowerPolicyAlwaysOn;
1313 }
1314 case State::Host::RestartCause::PowerPolicyPreviousState:
1315 {
1316 return IpmiRestartCause::PowerPolicyPreviousState;
1317 }
1318 case State::Host::RestartCause::SoftReset:
1319 {
1320 return IpmiRestartCause::SoftReset;
1321 }
1322 default:
1323 {
1324 return IpmiRestartCause::Unknown;
1325 }
1326 }
1327}
1328
1329/*
1330 * getRestartCause
1331 * helper function for Get Host restart cause Command
1332 * return - optional value for RestartCause (no value on error)
1333 */
1334static std::optional<uint4_t> getRestartCause(ipmi::Context::ptr ctx)
1335{
okashanyced0ddf2023-05-18 18:35:09 +00001336 constexpr const char* restartCausePath = "/xyz/openbmc_project/state/host0";
1337 constexpr const char* restartCauseIntf = "xyz.openbmc_project.State.Host";
Vijay Khemka074f64d2020-03-03 15:08:43 -08001338
1339 std::string service;
Patrick Williams1318a5e2024-08-16 15:19:54 -04001340 boost::system::error_code ec =
1341 ipmi::getService(ctx, restartCauseIntf, restartCausePath, service);
Vijay Khemka074f64d2020-03-03 15:08:43 -08001342 if (!ec)
1343 {
1344 std::string restartCauseStr;
1345 ec = ipmi::getDbusProperty<std::string>(
1346 ctx, service, restartCausePath, restartCauseIntf, "RestartCause",
1347 restartCauseStr);
1348 if (!ec)
1349 {
1350 auto cause =
1351 State::Host::convertRestartCauseFromString(restartCauseStr);
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001352 return types::enum_cast<uint4_t>(
1353 restartCauseToIpmiRestartCause(cause));
Vijay Khemka074f64d2020-03-03 15:08:43 -08001354 }
1355 }
1356
Vernon Mauery38108d92024-03-11 12:53:55 -07001357 lg2::error(
1358 "Failed to fetch RestartCause property ({PATH}/{INTERFACE}): {ERROR}",
1359 "ERROR", ec.message(), "PATH", restartCausePath, "INTERFACE",
1360 restartCauseIntf);
Vijay Khemka074f64d2020-03-03 15:08:43 -08001361 return std::nullopt;
1362}
1363
1364ipmi::RspType<uint4_t, // Restart Cause
1365 uint4_t, // reserved
1366 uint8_t // channel number (not supported)
1367 >
1368 ipmiGetSystemRestartCause(ipmi::Context::ptr ctx)
1369{
1370 std::optional<uint4_t> cause = getRestartCause(ctx);
1371 if (!cause)
1372 {
1373 return ipmi::responseUnspecifiedError();
1374 }
1375
Vernon Mauery916d4232021-03-29 13:42:16 -07001376 constexpr uint4_t reserved = 0;
1377 auto channel = static_cast<uint8_t>(ctx->channel);
1378 return ipmi::responseSuccess(cause.value(), reserved, channel);
Vijay Khemka074f64d2020-03-03 15:08:43 -08001379}
anil kumar appanadafff5f2019-04-27 18:06:00 +00001380/** @brief Implementation of chassis control command
1381 *
1382 * @param - chassisControl command byte
1383 *
1384 * @return Success or InvalidFieldRequest.
1385 */
Jason M. Bills664e1c32020-01-30 16:02:39 -08001386ipmi::RspType<> ipmiChassisControl(ipmi::Context::ptr& ctx,
1387 uint8_t chassisControl)
vishwa36993272015-11-20 12:43:49 -06001388{
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001389 int rc = 0;
anil kumar appanadafff5f2019-04-27 18:06:00 +00001390 switch (chassisControl)
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001391 {
George Liu8f4717c2025-07-03 09:22:34 +08001392 case cmdPowerOn:
Jason M. Bills664e1c32020-01-30 16:02:39 -08001393 rc = initiateHostStateTransition(ctx, State::Host::Transition::On);
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001394 break;
George Liu8f4717c2025-07-03 09:22:34 +08001395 case cmdPowerOff:
Jason M. Billsc2c3a402020-01-30 16:22:24 -08001396 rc = initiateChassisStateTransition(
1397 ctx, State::Chassis::Transition::Off);
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001398 break;
George Liu8f4717c2025-07-03 09:22:34 +08001399 case cmdHardReset:
Jason M. Bills664e1c32020-01-30 16:02:39 -08001400 rc = initiateHostStateTransition(
1401 ctx, State::Host::Transition::ForceWarmReboot);
Chanh Nguyend0a7fcd2021-07-16 22:59:28 +07001402 break;
George Liu8f4717c2025-07-03 09:22:34 +08001403 case cmdPowerCycle:
Jason M. Bills664e1c32020-01-30 16:02:39 -08001404 rc = initiateHostStateTransition(ctx,
1405 State::Host::Transition::Reboot);
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001406 break;
George Liu8f4717c2025-07-03 09:22:34 +08001407 case cmdSoftOffViaOverTemp:
Jason M. Bills664e1c32020-01-30 16:02:39 -08001408 rc = initiateHostStateTransition(ctx, State::Host::Transition::Off);
Vishwanatha Subbanna8b26d352017-08-04 18:35:18 +05301409 break;
George Liu8f4717c2025-07-03 09:22:34 +08001410 case cmdPulseDiagnosticInterrupt:
Zev Weiss337a0972024-03-08 08:31:15 +00001411 rc = doNmi(ctx);
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +08001412 break;
1413
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001414 default:
1415 {
Vernon Mauery38108d92024-03-11 12:53:55 -07001416 lg2::error("Invalid Chassis Control command: {CMD}", "CMD",
1417 lg2::hex, chassisControl);
anil kumar appanadafff5f2019-04-27 18:06:00 +00001418 return ipmi::responseInvalidFieldRequest();
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001419 }
1420 }
vishwa36993272015-11-20 12:43:49 -06001421
anil kumar appanadafff5f2019-04-27 18:06:00 +00001422 return ((rc < 0) ? ipmi::responseUnspecifiedError()
1423 : ipmi::responseSuccess());
vishwa36993272015-11-20 12:43:49 -06001424}
1425
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001426/** @brief Return D-Bus connection string to enclosure identify LED object
1427 *
1428 * @param[in, out] connection - connection to D-Bus object
1429 * @return a IPMI return code
1430 */
1431std::string getEnclosureIdentifyConnection()
Tom Joseph5110c122018-03-23 17:55:40 +05301432{
Tom Joseph5110c122018-03-23 17:55:40 +05301433 // lookup enclosure_identify group owner(s) in mapper
George Liu3e3cc352023-07-26 15:59:31 +08001434 try
Tom Joseph5110c122018-03-23 17:55:40 +05301435 {
George Liu3e3cc352023-07-26 15:59:31 +08001436 return ipmi::getService(*getSdBus(), "xyz.openbmc_project.Led.Group",
1437 identify_led_object_name);
1438 }
1439 catch (const std::exception& e)
1440 {
Vernon Mauery38108d92024-03-11 12:53:55 -07001441 lg2::error("Chassis Identify: Error communicating to mapper: {ERROR}",
1442 "ERROR", e);
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001443 elog<InternalFailure>();
Tom Joseph5110c122018-03-23 17:55:40 +05301444 }
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001445}
Tom Joseph5110c122018-03-23 17:55:40 +05301446
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001447/** @brief Turn On/Off enclosure identify LED
1448 *
1449 * @param[in] flag - true to turn on LED, false to turn off
1450 * @return a IPMI return code
1451 */
1452void enclosureIdentifyLed(bool flag)
1453{
1454 using namespace chassis::internal;
George Liu3e3cc352023-07-26 15:59:31 +08001455 try
1456 {
1457 std::string connection = getEnclosureIdentifyConnection();
1458
1459 auto msg = std::string("enclosureIdentifyLed(") +
1460 boost::lexical_cast<std::string>(flag) + ")";
Vernon Mauery38108d92024-03-11 12:53:55 -07001461 lg2::debug(msg.c_str());
George Liu3e3cc352023-07-26 15:59:31 +08001462
1463 ipmi::setDbusProperty(*getSdBus(), connection, identify_led_object_name,
1464 "xyz.openbmc_project.Led.Group", "Asserted",
1465 flag);
1466 }
1467 catch (const std::exception& e)
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001468 {
Vernon Mauery38108d92024-03-11 12:53:55 -07001469 lg2::error("Chassis Identify: Error Setting State {LED_STATE}: {ERROR}",
1470 "LED_STATE", flag, "ERROR", e);
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001471 elog<InternalFailure>();
1472 }
1473}
1474
1475/** @brief Callback method to turn off LED
1476 */
1477void enclosureIdentifyLedOff()
1478{
1479 try
1480 {
Yong Lif4e38512019-05-21 14:46:55 +08001481 chassisIDState = ChassisIDState::off;
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001482 enclosureIdentifyLed(false);
1483 }
1484 catch (const InternalFailure& e)
1485 {
1486 report<InternalFailure>();
1487 }
1488}
1489
1490/** @brief Create timer to turn on and off the enclosure LED
1491 */
1492void createIdentifyTimer()
1493{
1494 if (!identifyTimer)
1495 {
Vernon Mauery1181af72018-10-08 12:05:00 -07001496 identifyTimer =
Patrick Williams95655222023-12-05 12:45:02 -06001497 std::make_unique<sdbusplus::Timer>(enclosureIdentifyLedOff);
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001498 }
1499}
1500
Vernon Mauery400cc782018-10-09 13:49:53 -07001501ipmi::RspType<> ipmiChassisIdentify(std::optional<uint8_t> interval,
1502 std::optional<uint8_t> force)
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001503{
Vernon Mauery400cc782018-10-09 13:49:53 -07001504 uint8_t identifyInterval = interval.value_or(DEFAULT_IDENTIFY_TIME_OUT);
1505 bool forceIdentify = force.value_or(0) & 0x01;
Tom Josephbed26992018-07-31 23:00:24 +05301506
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001507 if (identifyInterval || forceIdentify)
1508 {
Vernon Mauery400cc782018-10-09 13:49:53 -07001509 // stop the timer if already started;
1510 // for force identify we should not turn off LED
Vernon Mauery1181af72018-10-08 12:05:00 -07001511 identifyTimer->stop();
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001512 try
Tom Joseph5110c122018-03-23 17:55:40 +05301513 {
Yong Lif4e38512019-05-21 14:46:55 +08001514 chassisIDState = ChassisIDState::temporaryOn;
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001515 enclosureIdentifyLed(true);
1516 }
1517 catch (const InternalFailure& e)
1518 {
1519 report<InternalFailure>();
Vernon Mauery400cc782018-10-09 13:49:53 -07001520 return ipmi::responseResponseError();
Tom Joseph5110c122018-03-23 17:55:40 +05301521 }
1522
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001523 if (forceIdentify)
Tom Joseph5110c122018-03-23 17:55:40 +05301524 {
Yong Lif4e38512019-05-21 14:46:55 +08001525 chassisIDState = ChassisIDState::indefiniteOn;
Vernon Mauery400cc782018-10-09 13:49:53 -07001526 return ipmi::responseSuccess();
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001527 }
1528 // start the timer
1529 auto time = std::chrono::duration_cast<std::chrono::microseconds>(
Patrick Venture0b02be92018-08-31 11:55:55 -07001530 std::chrono::seconds(identifyInterval));
Vernon Mauery1181af72018-10-08 12:05:00 -07001531 identifyTimer->start(time);
Tom Joseph5110c122018-03-23 17:55:40 +05301532 }
Tom Josephbed26992018-07-31 23:00:24 +05301533 else if (!identifyInterval)
1534 {
Vernon Mauery1181af72018-10-08 12:05:00 -07001535 identifyTimer->stop();
Tom Josephbed26992018-07-31 23:00:24 +05301536 enclosureIdentifyLedOff();
1537 }
Vernon Mauery400cc782018-10-09 13:49:53 -07001538 return ipmi::responseSuccess();
Tom Joseph5110c122018-03-23 17:55:40 +05301539}
1540
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001541namespace boot_options
1542{
1543
Willy Tu523e2d12023-09-05 11:36:48 -07001544using namespace sdbusplus::server::xyz::openbmc_project::control::boot;
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001545using IpmiValue = uint8_t;
1546constexpr auto ipmiDefault = 0;
1547
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001548std::map<IpmiValue, Type::Types> typeIpmiToDbus = {{0x00, Type::Types::Legacy},
1549 {0x01, Type::Types::EFI}};
1550
Patrick Venture0b02be92018-08-31 11:55:55 -07001551std::map<IpmiValue, Source::Sources> sourceIpmiToDbus = {
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001552 {0x01, Source::Sources::Network},
1553 {0x02, Source::Sources::Disk},
1554 {0x05, Source::Sources::ExternalMedia},
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08001555 {0x0f, Source::Sources::RemovableMedia},
Patrick Venture0b02be92018-08-31 11:55:55 -07001556 {ipmiDefault, Source::Sources::Default}};
shgoupfd84fbbf2015-12-17 10:05:51 +08001557
Patrick Venture0b02be92018-08-31 11:55:55 -07001558std::map<IpmiValue, Mode::Modes> modeIpmiToDbus = {
Yong Li5833cb62019-10-30 13:27:12 +08001559#ifdef ENABLE_BOOT_FLAG_SAFE_MODE_SUPPORT
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001560 {0x03, Mode::Modes::Safe},
Yong Li5833cb62019-10-30 13:27:12 +08001561#endif // ENABLE_BOOT_SAFE_MODE_SUPPORT
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001562 {0x06, Mode::Modes::Setup},
Patrick Venture0b02be92018-08-31 11:55:55 -07001563 {ipmiDefault, Mode::Modes::Regular}};
shgoupfd84fbbf2015-12-17 10:05:51 +08001564
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001565std::map<Type::Types, IpmiValue> typeDbusToIpmi = {{Type::Types::Legacy, 0x00},
1566 {Type::Types::EFI, 0x01}};
1567
Patrick Venture0b02be92018-08-31 11:55:55 -07001568std::map<Source::Sources, IpmiValue> sourceDbusToIpmi = {
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001569 {Source::Sources::Network, 0x01},
1570 {Source::Sources::Disk, 0x02},
1571 {Source::Sources::ExternalMedia, 0x05},
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08001572 {Source::Sources::RemovableMedia, 0x0f},
Patrick Venture0b02be92018-08-31 11:55:55 -07001573 {Source::Sources::Default, ipmiDefault}};
shgoupfd84fbbf2015-12-17 10:05:51 +08001574
Patrick Venture0b02be92018-08-31 11:55:55 -07001575std::map<Mode::Modes, IpmiValue> modeDbusToIpmi = {
Yong Li5833cb62019-10-30 13:27:12 +08001576#ifdef ENABLE_BOOT_FLAG_SAFE_MODE_SUPPORT
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001577 {Mode::Modes::Safe, 0x03},
Yong Li5833cb62019-10-30 13:27:12 +08001578#endif // ENABLE_BOOT_SAFE_MODE_SUPPORT
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001579 {Mode::Modes::Setup, 0x06},
Patrick Venture0b02be92018-08-31 11:55:55 -07001580 {Mode::Modes::Regular, ipmiDefault}};
shgoupfd84fbbf2015-12-17 10:05:51 +08001581
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001582} // namespace boot_options
shgoupfd84fbbf2015-12-17 10:05:51 +08001583
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001584/** @brief Get the property value for boot source
1585 * @param[in] ctx - context pointer
1586 * @param[out] source - boot source value
1587 * @return On failure return IPMI error.
1588 */
1589static ipmi::Cc getBootSource(ipmi::Context::ptr& ctx, Source::Sources& source)
1590{
1591 using namespace chassis::internal;
1592 std::string result;
1593 std::string service;
Patrick Williams1318a5e2024-08-16 15:19:54 -04001594 boost::system::error_code ec =
1595 getService(ctx, bootSourceIntf, bootSettingsPath, service);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001596 if (!ec)
1597 {
1598 ec = ipmi::getDbusProperty(ctx, service, bootSettingsPath,
1599 bootSourceIntf, "BootSource", result);
1600 if (!ec)
1601 {
1602 source = Source::convertSourcesFromString(result);
1603 return ipmi::ccSuccess;
1604 }
1605 }
Vernon Mauery38108d92024-03-11 12:53:55 -07001606 lg2::error("Error in BootSource Get: {ERROR}", "ERROR", ec.message());
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001607 return ipmi::ccUnspecifiedError;
1608}
1609
Marri Devender Rao81719702018-05-07 00:53:48 -05001610/** @brief Set the property value for boot source
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001611 * @param[in] ctx - context pointer
Marri Devender Rao81719702018-05-07 00:53:48 -05001612 * @param[in] source - boot source value
1613 * @return On failure return IPMI error.
1614 */
Jayaprakash Mutyala6088e9f2021-07-14 07:40:29 +00001615static ipmi::Cc setBootSource(ipmi::Context::ptr& ctx,
1616 const Source::Sources& source)
Marri Devender Rao81719702018-05-07 00:53:48 -05001617{
1618 using namespace chassis::internal;
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001619 std::string service;
Patrick Williams1318a5e2024-08-16 15:19:54 -04001620 boost::system::error_code ec =
1621 getService(ctx, bootSourceIntf, bootSettingsPath, service);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001622 if (!ec)
Marri Devender Rao81719702018-05-07 00:53:48 -05001623 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001624 ec = ipmi::setDbusProperty(ctx, service, bootSettingsPath,
1625 bootSourceIntf, "BootSource",
1626 convertForMessage(source));
1627 if (!ec)
1628 {
1629 return ipmi::ccSuccess;
1630 }
Marri Devender Rao81719702018-05-07 00:53:48 -05001631 }
Vernon Mauery38108d92024-03-11 12:53:55 -07001632 lg2::error("Error in BootSource Set: {ERROR}", "ERROR", ec.message());
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001633 return ipmi::ccUnspecifiedError;
1634}
1635
1636/** @brief Get the property value for boot mode
1637 * @param[in] ctx - context pointer
1638 * @param[out] mode - boot mode value
1639 * @return On failure return IPMI error.
1640 */
1641static ipmi::Cc getBootMode(ipmi::Context::ptr& ctx, Mode::Modes& mode)
1642{
1643 using namespace chassis::internal;
1644 std::string result;
1645 std::string service;
Patrick Williams1318a5e2024-08-16 15:19:54 -04001646 boost::system::error_code ec =
1647 getService(ctx, bootModeIntf, bootSettingsPath, service);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001648 if (!ec)
1649 {
1650 ec = ipmi::getDbusProperty(ctx, service, bootSettingsPath, bootModeIntf,
1651 "BootMode", result);
1652 if (!ec)
1653 {
1654 mode = Mode::convertModesFromString(result);
1655 return ipmi::ccSuccess;
1656 }
1657 }
Vernon Mauery38108d92024-03-11 12:53:55 -07001658 lg2::error("Error in BootMode Get: {ERROR}", "ERROR", ec.message());
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001659 return ipmi::ccUnspecifiedError;
Marri Devender Rao81719702018-05-07 00:53:48 -05001660}
1661
Patrick Venture0b02be92018-08-31 11:55:55 -07001662/** @brief Set the property value for boot mode
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001663 * @param[in] ctx - context pointer
Marri Devender Rao81719702018-05-07 00:53:48 -05001664 * @param[in] mode - boot mode value
1665 * @return On failure return IPMI error.
1666 */
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001667static ipmi::Cc setBootMode(ipmi::Context::ptr& ctx, const Mode::Modes& mode)
Marri Devender Rao81719702018-05-07 00:53:48 -05001668{
1669 using namespace chassis::internal;
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001670 std::string service;
Patrick Williams1318a5e2024-08-16 15:19:54 -04001671 boost::system::error_code ec =
1672 getService(ctx, bootModeIntf, bootSettingsPath, service);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001673 if (!ec)
Marri Devender Rao81719702018-05-07 00:53:48 -05001674 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001675 ec = ipmi::setDbusProperty(ctx, service, bootSettingsPath, bootModeIntf,
1676 "BootMode", convertForMessage(mode));
1677 if (!ec)
1678 {
1679 return ipmi::ccSuccess;
1680 }
Marri Devender Rao81719702018-05-07 00:53:48 -05001681 }
Vernon Mauery38108d92024-03-11 12:53:55 -07001682 lg2::error("Error in BootMode Set: {ERROR}", "ERROR", ec.message());
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001683 return ipmi::ccUnspecifiedError;
1684}
1685
1686/** @brief Get the property value for boot type
1687 * @param[in] ctx - context pointer
1688 * @param[out] type - boot type value
1689 * @return On failure return IPMI error.
1690 */
1691static ipmi::Cc getBootType(ipmi::Context::ptr& ctx, Type::Types& type)
1692{
1693 using namespace chassis::internal;
1694 std::string result;
1695 std::string service;
Patrick Williams1318a5e2024-08-16 15:19:54 -04001696 boost::system::error_code ec =
1697 getService(ctx, bootTypeIntf, bootSettingsPath, service);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001698
1699 // Don't throw error if BootType interface is not present.
1700 // This interface is not relevant for some Host architectures
1701 // (for example POWER). In this case we don't won't IPMI to
1702 // return an error, but simply return bootType as EFI.
1703 type = Type::Types::EFI;
1704 if (!ec)
1705 {
1706 ec = ipmi::getDbusProperty(ctx, service, bootSettingsPath, bootTypeIntf,
1707 "BootType", result);
1708 if (ec)
1709 {
Vernon Mauery38108d92024-03-11 12:53:55 -07001710 lg2::error("Error in BootType Get: {ERROR}", "ERROR", ec.message());
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001711 return ipmi::ccUnspecifiedError;
1712 }
1713 type = Type::convertTypesFromString(result);
1714 }
1715
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00001716 return ipmi::ccSuccess;
Marri Devender Rao81719702018-05-07 00:53:48 -05001717}
1718
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001719/** @brief Set the property value for boot type
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001720 * @param[in] ctx - context pointer
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001721 * @param[in] type - boot type value
1722 * @return On failure return IPMI error.
1723 */
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001724static ipmi::Cc setBootType(ipmi::Context::ptr& ctx, const Type::Types& type)
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001725{
1726 using namespace chassis::internal;
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001727 std::string service;
Patrick Williams1318a5e2024-08-16 15:19:54 -04001728 boost::system::error_code ec =
1729 getService(ctx, bootTypeIntf, bootSettingsPath, service);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001730 if (!ec)
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001731 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001732 ec = ipmi::setDbusProperty(ctx, service, bootSettingsPath, bootTypeIntf,
1733 "BootType", convertForMessage(type));
1734 if (ec)
1735 {
Vernon Mauery38108d92024-03-11 12:53:55 -07001736 lg2::error("Error in BootType Set: {ERROR}", "ERROR", ec.message());
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001737 return ipmi::ccUnspecifiedError;
1738 }
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001739 }
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001740 // Don't throw error if BootType interface is not present.
1741 // This interface is not relevant for some Host architectures
1742 // (for example POWER). In this case we don't won't IPMI to
1743 // return an error, but want to just skip this function.
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001744 return ipmi::ccSuccess;
1745}
1746
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001747/** @brief Get the property value for boot override enable
1748 * @param[in] ctx - context pointer
1749 * @param[out] enable - boot override enable
1750 * @return On failure return IPMI error.
1751 */
1752static ipmi::Cc getBootEnable(ipmi::Context::ptr& ctx, bool& enable)
1753{
1754 using namespace chassis::internal;
1755 std::string result;
1756 std::string service;
Patrick Williams1318a5e2024-08-16 15:19:54 -04001757 boost::system::error_code ec =
1758 getService(ctx, bootEnableIntf, bootSettingsPath, service);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001759 if (!ec)
1760 {
1761 ec = ipmi::getDbusProperty(ctx, service, bootSettingsPath,
1762 bootEnableIntf, "Enabled", enable);
1763 if (!ec)
1764 {
1765 return ipmi::ccSuccess;
1766 }
1767 }
Vernon Mauery38108d92024-03-11 12:53:55 -07001768 lg2::error("Error in Boot Override Enable Get: {ERROR}", "ERROR",
1769 ec.message());
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001770 return ipmi::ccUnspecifiedError;
1771}
1772
1773/** @brief Set the property value for boot override enable
1774 * @param[in] ctx - context pointer
1775 * @param[in] enable - boot override enable
1776 * @return On failure return IPMI error.
1777 */
1778static ipmi::Cc setBootEnable(ipmi::Context::ptr& ctx, const bool& enable)
1779{
1780 using namespace chassis::internal;
1781 std::string service;
Patrick Williams1318a5e2024-08-16 15:19:54 -04001782 boost::system::error_code ec =
1783 getService(ctx, bootEnableIntf, bootSettingsPath, service);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001784 if (!ec)
1785 {
1786 ec = ipmi::setDbusProperty(ctx, service, bootSettingsPath,
1787 bootEnableIntf, "Enabled", enable);
1788 if (!ec)
1789 {
1790 return ipmi::ccSuccess;
1791 }
1792 }
Vernon Mauery38108d92024-03-11 12:53:55 -07001793 lg2::error("Error in Boot Source Override Enable Set: {ERROR}", "ERROR",
1794 ec.message());
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001795 return ipmi::ccUnspecifiedError;
1796}
1797
1798/** @brief Get the property value for boot override one-time
1799 * @param[in] ctx - context pointer
1800 * @param[out] onetime - boot override one-time
1801 * @return On failure return IPMI error.
1802 */
1803static ipmi::Cc getBootOneTime(ipmi::Context::ptr& ctx, bool& onetime)
1804{
1805 using namespace chassis::internal;
1806 std::string result;
1807 std::string service;
Patrick Williams1318a5e2024-08-16 15:19:54 -04001808 boost::system::error_code ec =
1809 getService(ctx, bootOneTimeIntf, bootSettingsOneTimePath, service);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001810 if (!ec)
1811 {
1812 ec = ipmi::getDbusProperty(ctx, service, bootSettingsOneTimePath,
1813 bootOneTimeIntf, "Enabled", onetime);
1814 if (!ec)
1815 {
1816 return ipmi::ccSuccess;
1817 }
1818 }
Vernon Mauery38108d92024-03-11 12:53:55 -07001819 lg2::error("Error in Boot Override OneTime Get: {ERROR}", "ERROR",
1820 ec.message());
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001821 return ipmi::ccUnspecifiedError;
1822}
1823
1824/** @brief Set the property value for boot override one-time
1825 * @param[in] ctx - context pointer
1826 * @param[in] onetime - boot override one-time
1827 * @return On failure return IPMI error.
1828 */
1829static ipmi::Cc setBootOneTime(ipmi::Context::ptr& ctx, const bool& onetime)
1830{
1831 using namespace chassis::internal;
1832 std::string service;
Patrick Williams1318a5e2024-08-16 15:19:54 -04001833 boost::system::error_code ec =
1834 getService(ctx, bootOneTimeIntf, bootSettingsOneTimePath, service);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001835 if (!ec)
1836 {
1837 ec = ipmi::setDbusProperty(ctx, service, bootSettingsOneTimePath,
1838 bootOneTimeIntf, "Enabled", onetime);
1839 if (!ec)
1840 {
1841 return ipmi::ccSuccess;
1842 }
1843 }
Vernon Mauery38108d92024-03-11 12:53:55 -07001844 lg2::error("Error in Boot Source Override OneTime Set: {ERROR}", "ERROR",
1845 ec.message());
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001846 return ipmi::ccUnspecifiedError;
1847}
1848
huangheab369282020-10-10 14:40:00 +08001849static constexpr uint8_t setComplete = 0x0;
1850static constexpr uint8_t setInProgress = 0x1;
1851static uint8_t transferStatus = setComplete;
Chen Yugang86ac4992021-06-25 08:14:52 +08001852static uint8_t bootFlagValidBitClr = 0;
Hieu Huynh38ffafc2021-05-14 08:40:14 +00001853static uint5_t bootInitiatorAckData = 0x0;
Hieu Huynh1982a3f2021-09-21 03:06:45 +00001854static bool cmosClear = false;
Cosmo Chou53831212025-01-10 13:36:36 +08001855static uint2_t biosVerbosity = 0x0;
huangheab369282020-10-10 14:40:00 +08001856
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001857/** @brief implements the Get Chassis system boot option
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001858 * @param ctx - context pointer
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001859 * @param bootOptionParameter - boot option parameter selector
1860 * @param reserved1 - reserved bit
1861 * @param setSelector - selects a particular block or set of parameters
1862 * under the given parameter selector
1863 * write as 00h if parameter doesn't use a setSelector
1864 * @param blockSelector- selects a particular block within a set of
1865 * parameters write as 00h if parameter doesn't use a
1866 * blockSelector
1867 *
1868 * @return IPMI completion code plus response data
1869 * @return Payload contains below parameters:
1870 * version - parameter version
1871 * bootOptionParameter - boot option parameter selector
Patrick Venture8b1c3032020-09-15 09:43:03 -07001872 * parmIndicator - parameter valid/invalid indicator
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001873 * data - configuration parameter data
1874 */
Patrick Williams1318a5e2024-08-16 15:19:54 -04001875ipmi::RspType<ipmi::message::Payload> ipmiChassisGetSysBootOptions(
1876 ipmi::Context::ptr ctx, uint7_t bootOptionParameter, bool reserved1,
1877 [[maybe_unused]] uint8_t setSelector,
1878 [[maybe_unused]] uint8_t blockSelector)
Adriana Kobylak40814c62015-10-27 15:58:44 -05001879{
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001880 ipmi::Cc rc;
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001881 if (reserved1)
1882 {
1883 return ipmi::responseInvalidFieldRequest();
1884 }
1885
1886 constexpr uint4_t version = 0x01;
1887 ipmi::message::Payload response;
1888 response.pack(version, uint4_t{});
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001889 using namespace boot_options;
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001890
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001891 IpmiValue bootOption = ipmiDefault;
Adriana Kobylak40814c62015-10-27 15:58:44 -05001892
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001893 if (types::enum_cast<BootOptionParameter>(bootOptionParameter) ==
1894 BootOptionParameter::setInProgress)
huangheab369282020-10-10 14:40:00 +08001895 {
1896 response.pack(bootOptionParameter, reserved1, transferStatus);
1897 return ipmi::responseSuccess(std::move(response));
1898 }
1899
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001900 if (types::enum_cast<BootOptionParameter>(bootOptionParameter) ==
1901 BootOptionParameter::bootInfo)
John Wang0213f902020-12-28 14:49:57 +08001902 {
1903 constexpr uint8_t writeMask = 0;
Hieu Huynh38ffafc2021-05-14 08:40:14 +00001904 response.pack(bootOptionParameter, reserved1, writeMask,
1905 bootInitiatorAckData);
John Wang0213f902020-12-28 14:49:57 +08001906 return ipmi::responseSuccess(std::move(response));
1907 }
1908
Chen Yugang86ac4992021-06-25 08:14:52 +08001909 if (types::enum_cast<BootOptionParameter>(bootOptionParameter) ==
1910 BootOptionParameter::bootFlagValidClr)
1911 {
1912 response.pack(bootOptionParameter, reserved1,
1913 uint5_t{bootFlagValidBitClr}, uint3_t{});
1914 return ipmi::responseSuccess(std::move(response));
1915 }
1916
shgoupfd84fbbf2015-12-17 10:05:51 +08001917 /*
1918 * Parameter #5 means boot flags. Please refer to 28.13 of ipmi doc.
1919 * This is the only parameter used by petitboot.
1920 */
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001921 if (types::enum_cast<BootOptionParameter>(bootOptionParameter) ==
1922 BootOptionParameter::bootFlags)
Patrick Venture0b02be92018-08-31 11:55:55 -07001923 {
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001924 using namespace chassis::internal;
1925 using namespace chassis::internal::cache;
shgoupfd84fbbf2015-12-17 10:05:51 +08001926
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001927 try
ratagupta6f6bff2016-04-04 06:20:11 -05001928 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001929 Source::Sources bootSource;
1930 rc = getBootSource(ctx, bootSource);
1931 if (rc != ipmi::ccSuccess)
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001932 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001933 return ipmi::response(rc);
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001934 }
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001935
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001936 Type::Types bootType;
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001937 rc = getBootType(ctx, bootType);
1938 if (rc != ipmi::ccSuccess)
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001939 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001940 return ipmi::response(rc);
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001941 }
1942
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001943 Mode::Modes bootMode;
1944 rc = getBootMode(ctx, bootMode);
1945 if (rc != ipmi::ccSuccess)
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001946 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001947 return ipmi::response(rc);
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001948 }
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001949
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001950 bootOption = sourceDbusToIpmi.at(bootSource);
1951 if ((Mode::Modes::Regular == bootMode) &&
1952 (Source::Sources::Default == bootSource))
1953 {
1954 bootOption = ipmiDefault;
1955 }
1956 else if (Source::Sources::Default == bootSource)
1957 {
1958 bootOption = modeDbusToIpmi.at(bootMode);
1959 }
ratagupta6f6bff2016-04-04 06:20:11 -05001960
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001961 IpmiValue biosBootType = typeDbusToIpmi.at(bootType);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001962
1963 bool oneTimeEnabled;
1964 rc = getBootOneTime(ctx, oneTimeEnabled);
1965 if (rc != ipmi::ccSuccess)
1966 {
1967 return ipmi::response(rc);
1968 }
1969
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001970 uint1_t permanent = oneTimeEnabled ? 0 : 1;
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001971
1972 bool valid;
1973 rc = getBootEnable(ctx, valid);
1974 if (rc != ipmi::ccSuccess)
1975 {
1976 return ipmi::response(rc);
1977 }
1978
1979 uint1_t validFlag = valid ? 1 : 0;
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001980
Cosmo Chou53831212025-01-10 13:36:36 +08001981 response.pack(
1982 bootOptionParameter, reserved1, uint5_t{},
1983 uint1_t{biosBootType}, uint1_t{permanent}, uint1_t{validFlag},
1984 uint2_t{}, uint4_t{bootOption}, uint1_t{}, cmosClear, uint5_t{},
1985 uint2_t{biosVerbosity}, uint1_t{}, uint8_t{}, uint8_t{});
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001986 return ipmi::responseSuccess(std::move(response));
ratagupta6f6bff2016-04-04 06:20:11 -05001987 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -05001988 catch (const InternalFailure& e)
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001989 {
James Feist225dec82019-11-26 16:25:06 -08001990 cache::objectsPtr.reset();
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001991 report<InternalFailure>();
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001992 return ipmi::responseUnspecifiedError();
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001993 }
Patrick Venture0b02be92018-08-31 11:55:55 -07001994 }
Patrick Venture0b02be92018-08-31 11:55:55 -07001995 else
1996 {
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001997 if ((bootOptionParameter >= oemParmStart) &&
1998 (bootOptionParameter <= oemParmEnd))
1999 {
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07002000 if (types::enum_cast<BootOptionParameter>(bootOptionParameter) ==
2001 BootOptionParameter::opalNetworkSettings)
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002002 {
2003 response.pack(bootOptionParameter, reserved1);
2004 int ret = getHostNetworkData(response);
2005 if (ret < 0)
2006 {
2007 response.trailingOk = true;
Vernon Mauery38108d92024-03-11 12:53:55 -07002008 lg2::error(
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002009 "getHostNetworkData failed for GetSysBootOptions.");
2010 return ipmi::responseUnspecifiedError();
2011 }
2012 else
2013 {
2014 return ipmi::responseSuccess(std::move(response));
2015 }
2016 }
Jayaprakash Mutyala43a88102021-08-04 16:41:58 +00002017 else
2018 {
Vernon Mauery38108d92024-03-11 12:53:55 -07002019 lg2::error(
2020 "ipmiChassisGetSysBootOptions: Unsupported parameter {PARAM}",
2021 "PARAM", lg2::hex,
2022 static_cast<uint8_t>(bootOptionParameter));
Jayaprakash Mutyala43a88102021-08-04 16:41:58 +00002023 return ipmi::responseParmNotSupported();
2024 }
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002025 }
2026 else
2027 {
Vernon Mauery38108d92024-03-11 12:53:55 -07002028 lg2::error(
2029 "ipmiChassisGetSysBootOptions: Unsupported parameter {PARAM}",
2030 "PARAM", lg2::hex, static_cast<uint8_t>(bootOptionParameter));
Jayaprakash Mutyala6088e9f2021-07-14 07:40:29 +00002031 return ipmi::responseParmNotSupported();
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002032 }
shgoupfd84fbbf2015-12-17 10:05:51 +08002033 }
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002034 return ipmi::responseUnspecifiedError();
shgoupfd84fbbf2015-12-17 10:05:51 +08002035}
2036
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002037ipmi::RspType<> ipmiChassisSetSysBootOptions(ipmi::Context::ptr ctx,
Willy Tu11d68892022-01-20 10:37:34 -08002038 uint7_t parameterSelector, bool,
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002039 ipmi::message::Payload& data)
shgoupfd84fbbf2015-12-17 10:05:51 +08002040{
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002041 using namespace boot_options;
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002042 ipmi::Cc rc;
shgoupfd84fbbf2015-12-17 10:05:51 +08002043
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07002044 if (types::enum_cast<BootOptionParameter>(parameterSelector) ==
2045 BootOptionParameter::setInProgress)
huangheab369282020-10-10 14:40:00 +08002046 {
2047 uint2_t setInProgressFlag;
2048 uint6_t rsvd;
2049 if (data.unpack(setInProgressFlag, rsvd) != 0 || !data.fullyUnpacked())
2050 {
2051 return ipmi::responseReqDataLenInvalid();
2052 }
2053 if (rsvd)
2054 {
2055 return ipmi::responseInvalidFieldRequest();
2056 }
2057 if ((transferStatus == setInProgress) &&
2058 (static_cast<uint8_t>(setInProgressFlag) != setComplete))
2059 {
George Liuf5dd1022025-07-07 09:13:07 +08002060 return ipmi::responsefailSetInProgress();
huangheab369282020-10-10 14:40:00 +08002061 }
2062 transferStatus = static_cast<uint8_t>(setInProgressFlag);
2063 return ipmi::responseSuccess();
2064 }
2065
shgoupfd84fbbf2015-12-17 10:05:51 +08002066 /* 000101
2067 * Parameter #5 means boot flags. Please refer to 28.13 of ipmi doc.
2068 * This is the only parameter used by petitboot.
2069 */
Ratan Guptafd28dd72016-08-01 04:58:01 -05002070
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07002071 if (types::enum_cast<BootOptionParameter>(parameterSelector) ==
2072 BootOptionParameter::bootFlags)
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002073 {
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002074 uint5_t rsvd;
2075 bool validFlag;
2076 bool permanent;
2077 bool biosBootType;
2078 bool lockOutResetButton;
2079 bool screenBlank;
2080 uint4_t bootDeviceSelector;
2081 bool lockKeyboard;
Cosmo Chou53831212025-01-10 13:36:36 +08002082 uint5_t biosCtrls;
2083 bool lockOutPower;
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002084 uint4_t biosInfo;
2085 uint4_t rsvd1;
2086 uint5_t deviceInstance;
2087 uint3_t rsvd2;
2088
2089 if (data.unpack(rsvd, biosBootType, permanent, validFlag,
2090 lockOutResetButton, screenBlank, bootDeviceSelector,
Cosmo Chou53831212025-01-10 13:36:36 +08002091 lockKeyboard, cmosClear, biosCtrls, biosVerbosity,
2092 lockOutPower, biosInfo, rsvd1, deviceInstance, rsvd2) !=
2093 0 ||
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002094 !data.fullyUnpacked())
2095 {
2096 return ipmi::responseReqDataLenInvalid();
2097 }
2098 if (rsvd || rsvd1 || rsvd2)
2099 {
2100 return ipmi::responseInvalidFieldRequest();
2101 }
2102
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002103 using namespace chassis::internal;
2104 using namespace chassis::internal::cache;
shgoupfd84fbbf2015-12-17 10:05:51 +08002105
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002106 try
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002107 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002108 rc = setBootOneTime(ctx, !permanent);
2109 if (rc != ipmi::ccSuccess)
Konstantin Aladyshev69e8e842021-06-18 17:01:18 +03002110 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002111 return ipmi::response(rc);
2112 }
Vernon Maueryafd45db2021-07-29 16:27:25 +00002113
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002114 rc = setBootEnable(ctx, validFlag);
2115 if (rc != ipmi::ccSuccess)
2116 {
2117 return ipmi::response(rc);
Tom Joseph57e8eb72017-09-25 18:05:02 +05302118 }
2119
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002120 auto modeItr =
2121 modeIpmiToDbus.find(static_cast<uint8_t>(bootDeviceSelector));
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002122 auto typeItr =
2123 typeIpmiToDbus.find(static_cast<uint8_t>(biosBootType));
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002124 auto sourceItr =
2125 sourceIpmiToDbus.find(static_cast<uint8_t>(bootDeviceSelector));
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002126 if (sourceIpmiToDbus.end() != sourceItr)
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002127 {
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03002128 rc = setBootSource(ctx, sourceItr->second);
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002129 if (rc != ipmi::ccSuccess)
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002130 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002131 return ipmi::response(rc);
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002132 }
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002133 // If a set boot device is mapping to a boot source, then reset
2134 // the boot mode D-Bus property to default.
2135 // This way the ipmid code can determine which property is not
2136 // at the default value
Patrick Venture0b02be92018-08-31 11:55:55 -07002137 if (sourceItr->second != Source::Sources::Default)
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002138 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002139 rc = setBootMode(ctx, Mode::Modes::Regular);
2140 if (rc != ipmi::ccSuccess)
2141 {
2142 return ipmi::response(rc);
2143 }
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002144 }
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002145 }
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002146
2147 if (typeIpmiToDbus.end() != typeItr)
2148 {
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03002149 rc = setBootType(ctx, typeItr->second);
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002150 if (rc != ipmi::ccSuccess)
2151 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002152 return ipmi::response(rc);
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002153 }
2154 }
2155
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002156 if (modeIpmiToDbus.end() != modeItr)
2157 {
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03002158 rc = setBootMode(ctx, modeItr->second);
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002159 if (rc != ipmi::ccSuccess)
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002160 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002161 return ipmi::response(rc);
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002162 }
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002163 // If a set boot device is mapping to a boot mode, then reset
2164 // the boot source D-Bus property to default.
2165 // This way the ipmid code can determine which property is not
2166 // at the default value
Patrick Venture0b02be92018-08-31 11:55:55 -07002167 if (modeItr->second != Mode::Modes::Regular)
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002168 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002169 rc = setBootSource(ctx, Source::Sources::Default);
2170 if (rc != ipmi::ccSuccess)
2171 {
2172 return ipmi::response(rc);
2173 }
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002174 }
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002175 }
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08002176 if ((modeIpmiToDbus.end() == modeItr) &&
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002177 (typeIpmiToDbus.end() == typeItr) &&
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08002178 (sourceIpmiToDbus.end() == sourceItr))
2179 {
2180 // return error if boot option is not supported
Vernon Mauery38108d92024-03-11 12:53:55 -07002181 lg2::error(
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002182 "ipmiChassisSetSysBootOptions: Boot option not supported");
2183 return ipmi::responseInvalidFieldRequest();
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08002184 }
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002185 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -05002186 catch (const sdbusplus::exception_t& e)
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002187 {
James Feist225dec82019-11-26 16:25:06 -08002188 objectsPtr.reset();
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002189 report<InternalFailure>();
Vernon Mauery38108d92024-03-11 12:53:55 -07002190 lg2::error("ipmiChassisSetSysBootOptions: Error in setting Boot "
2191 "flag parameters");
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002192 return ipmi::responseUnspecifiedError();
Ratan Guptafd28dd72016-08-01 04:58:01 -05002193 }
Patrick Venture0b02be92018-08-31 11:55:55 -07002194 }
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07002195 else if (types::enum_cast<BootOptionParameter>(parameterSelector) ==
2196 BootOptionParameter::bootInfo)
Patrick Venture0b02be92018-08-31 11:55:55 -07002197 {
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002198 uint8_t writeMak;
Hieu Huynh38ffafc2021-05-14 08:40:14 +00002199 uint5_t bootInfoAck;
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002200 uint3_t rsvd;
2201
Hieu Huynh38ffafc2021-05-14 08:40:14 +00002202 if (data.unpack(writeMak, bootInfoAck, rsvd) != 0 ||
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002203 !data.fullyUnpacked())
2204 {
2205 return ipmi::responseReqDataLenInvalid();
2206 }
2207 if (rsvd)
2208 {
2209 return ipmi::responseInvalidFieldRequest();
2210 }
Hieu Huynh38ffafc2021-05-14 08:40:14 +00002211 bootInitiatorAckData &= ~writeMak;
2212 bootInitiatorAckData |= (writeMak & bootInfoAck);
Vernon Mauery38108d92024-03-11 12:53:55 -07002213 lg2::info("ipmiChassisSetSysBootOptions: bootInfo parameter set "
2214 "successfully");
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002215 data.trailingOk = true;
2216 return ipmi::responseSuccess();
Patrick Venture0b02be92018-08-31 11:55:55 -07002217 }
Chen Yugang86ac4992021-06-25 08:14:52 +08002218 else if (types::enum_cast<BootOptionParameter>(parameterSelector) ==
2219 BootOptionParameter::bootFlagValidClr)
2220 {
2221 uint5_t bootFlagValidClr;
2222 uint3_t rsvd;
2223
2224 if (data.unpack(bootFlagValidClr, rsvd) != 0 || !data.fullyUnpacked())
2225 {
2226 return ipmi::responseReqDataLenInvalid();
2227 }
2228 if (rsvd)
2229 {
2230 return ipmi::responseInvalidFieldRequest();
2231 }
2232 // store boot flag valid bits clear value
2233 bootFlagValidBitClr = static_cast<uint8_t>(bootFlagValidClr);
Vernon Mauery38108d92024-03-11 12:53:55 -07002234 lg2::info(
Chen Yugang86ac4992021-06-25 08:14:52 +08002235 "ipmiChassisSetSysBootOptions: bootFlagValidBits parameter set "
Vernon Mauery38108d92024-03-11 12:53:55 -07002236 "successfully to {VALUE}",
2237 "VALUE", lg2::hex, bootFlagValidBitClr);
Chen Yugang86ac4992021-06-25 08:14:52 +08002238 return ipmi::responseSuccess();
2239 }
Patrick Venture0b02be92018-08-31 11:55:55 -07002240 else
2241 {
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002242 if ((parameterSelector >= static_cast<uint7_t>(oemParmStart)) &&
2243 (parameterSelector <= static_cast<uint7_t>(oemParmEnd)))
2244 {
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07002245 if (types::enum_cast<BootOptionParameter>(parameterSelector) ==
2246 BootOptionParameter::opalNetworkSettings)
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002247 {
2248 ipmi::Cc ret = setHostNetworkData(data);
2249 if (ret != ipmi::ccSuccess)
2250 {
Vernon Mauery38108d92024-03-11 12:53:55 -07002251 lg2::error("ipmiChassisSetSysBootOptions: Error in "
2252 "setHostNetworkData");
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002253 data.trailingOk = true;
2254 return ipmi::response(ret);
2255 }
2256 data.trailingOk = true;
2257 return ipmi::responseSuccess();
2258 }
2259 else
2260 {
Vernon Mauery38108d92024-03-11 12:53:55 -07002261 lg2::error(
2262 "ipmiChassisSetSysBootOptions: Unsupported param: {PARAM}",
2263 "PARAM", lg2::hex, static_cast<uint8_t>(parameterSelector));
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002264 data.trailingOk = true;
2265 return ipmi::responseParmNotSupported();
2266 }
2267 }
2268 data.trailingOk = true;
2269 return ipmi::responseParmNotSupported();
Adriana Kobylak40814c62015-10-27 15:58:44 -05002270 }
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002271 return ipmi::responseSuccess();
Adriana Kobylak40814c62015-10-27 15:58:44 -05002272}
2273
anil kumar appanaa5a76eb2019-04-30 14:57:24 +00002274/** @brief implements Get POH counter command
2275 * @parameter
2276 * - none
2277 * @returns IPMI completion code plus response data
2278 * - minPerCount - Minutes per count
2279 * - counterReading - counter reading
2280 */
2281ipmi::RspType<uint8_t, // Minutes per count
2282 uint32_t // Counter reading
2283 >
2284 ipmiGetPOHCounter()
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002285{
2286 // sd_bus error
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002287 try
2288 {
anil kumar appanaa5a76eb2019-04-30 14:57:24 +00002289 return ipmi::responseSuccess(static_cast<uint8_t>(poh::minutesPerCount),
2290 getPOHCounter());
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002291 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -05002292 catch (const std::exception& e)
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002293 {
Vernon Mauery38108d92024-03-11 12:53:55 -07002294 lg2::error("getPOHCounter error: {ERROR}", "ERROR", e);
anil kumar appanaa5a76eb2019-04-30 14:57:24 +00002295 return ipmi::responseUnspecifiedError();
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002296 }
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002297}
2298
Jason M. Billsbc996a32019-06-17 15:46:37 -07002299ipmi::RspType<uint3_t, // policy support
2300 uint5_t // reserved
2301 >
George Liude1420d2025-03-03 15:14:25 +08002302 ipmiChassisSetPowerRestorePolicy(ipmi::Context::ptr ctx, uint3_t policy,
2303 uint5_t reserved)
Yong Lic6713cf2018-09-12 12:35:13 +08002304{
Yong Lic6713cf2018-09-12 12:35:13 +08002305 power_policy::DbusValue value =
2306 power_policy::RestorePolicy::Policy::AlwaysOff;
2307
Jason M. Billsbc996a32019-06-17 15:46:37 -07002308 if (reserved || (policy > power_policy::noChange))
Yong Lic6713cf2018-09-12 12:35:13 +08002309 {
Vernon Mauery38108d92024-03-11 12:53:55 -07002310 lg2::error("Reserved request parameter: {REQ}", "REQ", lg2::hex,
2311 static_cast<int>(policy));
Jason M. Billsbc996a32019-06-17 15:46:37 -07002312 return ipmi::responseInvalidFieldRequest();
Yong Lic6713cf2018-09-12 12:35:13 +08002313 }
2314
Vernon Mauerye278ead2018-10-09 09:23:43 -07002315 if (policy == power_policy::noChange)
Yong Lic6713cf2018-09-12 12:35:13 +08002316 {
2317 // just return the supported policy
Jason M. Billsbc996a32019-06-17 15:46:37 -07002318 return ipmi::responseSuccess(power_policy::allSupport, reserved);
Yong Lic6713cf2018-09-12 12:35:13 +08002319 }
2320
Patrick Williamsfbc6c9d2023-05-10 07:50:16 -05002321 for (const auto& it : power_policy::dbusToIpmi)
Yong Lic6713cf2018-09-12 12:35:13 +08002322 {
Vernon Mauerye278ead2018-10-09 09:23:43 -07002323 if (it.second == policy)
Yong Lic6713cf2018-09-12 12:35:13 +08002324 {
2325 value = it.first;
2326 break;
2327 }
2328 }
2329
2330 try
2331 {
James Feist225dec82019-11-26 16:25:06 -08002332 settings::Objects& objects = chassis::internal::cache::getObjects();
Yong Lic6713cf2018-09-12 12:35:13 +08002333 const settings::Path& powerRestoreSetting =
James Feist225dec82019-11-26 16:25:06 -08002334 objects.map.at(chassis::internal::powerRestoreIntf).front();
Yong Lic6713cf2018-09-12 12:35:13 +08002335
George Liude1420d2025-03-03 15:14:25 +08002336 boost::system::error_code ec = ipmi::setDbusProperty(
2337 ctx,
2338 objects.service(powerRestoreSetting,
2339 chassis::internal::powerRestoreIntf),
2340 powerRestoreSetting, chassis::internal::powerRestoreIntf,
2341 "PowerRestorePolicy", convertForMessage(value));
Vernon Mauerye278ead2018-10-09 09:23:43 -07002342 if (ec)
Yong Lic6713cf2018-09-12 12:35:13 +08002343 {
Vernon Mauery38108d92024-03-11 12:53:55 -07002344 lg2::error("Unspecified Error");
Vernon Mauerye278ead2018-10-09 09:23:43 -07002345 return ipmi::responseUnspecifiedError();
Yong Lic6713cf2018-09-12 12:35:13 +08002346 }
2347 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -05002348 catch (const InternalFailure& e)
Yong Lic6713cf2018-09-12 12:35:13 +08002349 {
James Feist225dec82019-11-26 16:25:06 -08002350 chassis::internal::cache::objectsPtr.reset();
Yong Lic6713cf2018-09-12 12:35:13 +08002351 report<InternalFailure>();
Vernon Mauerye278ead2018-10-09 09:23:43 -07002352 return ipmi::responseUnspecifiedError();
Yong Lic6713cf2018-09-12 12:35:13 +08002353 }
2354
Jason M. Billsbc996a32019-06-17 15:46:37 -07002355 return ipmi::responseSuccess(power_policy::allSupport, reserved);
Yong Lic6713cf2018-09-12 12:35:13 +08002356}
2357
Patrick Williams1318a5e2024-08-16 15:19:54 -04002358ipmi::RspType<> ipmiSetFrontPanelButtonEnables(
2359 ipmi::Context::ptr ctx, bool disablePowerButton, bool disableResetButton,
2360 bool, bool, uint4_t)
Kuiying Wang21addc52019-01-04 10:50:21 +08002361{
2362 using namespace chassis::internal;
2363
2364 // set power button Enabled property
Konstantin Aladyshev305d8642025-02-15 00:36:54 +03002365 bool success = setButtonDisabled(ctx, powerButtonPath, powerButtonIntf,
2366 disablePowerButton);
Kuiying Wang21addc52019-01-04 10:50:21 +08002367
2368 // set reset button Enabled property
Konstantin Aladyshev305d8642025-02-15 00:36:54 +03002369 success &= setButtonDisabled(ctx, resetButtonPath, resetButtonIntf,
2370 disableResetButton);
Kuiying Wang21addc52019-01-04 10:50:21 +08002371
2372 if (!success)
2373 {
2374 // not all buttons were successfully set
2375 return ipmi::responseUnspecifiedError();
2376 }
2377 return ipmi::responseSuccess();
2378}
2379
George Liu5087b072025-03-11 19:28:17 +08002380void registerNetFnChassisFunctions()
Adriana Kobylak40814c62015-10-27 15:58:44 -05002381{
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05002382 createIdentifyTimer();
2383
Tom05732372016-09-06 17:21:23 +05302384 // Get Chassis Capabilities
anil kumar appana43263c62019-05-27 12:45:04 +00002385 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2386 ipmi::chassis::cmdGetChassisCapabilities,
2387 ipmi::Privilege::User, ipmiGetChassisCap);
Nan Li8d15fb42016-08-16 22:29:40 +08002388
Kuiying Wang21addc52019-01-04 10:50:21 +08002389 // Set Front Panel Button Enables
2390 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2391 ipmi::chassis::cmdSetFrontPanelButtonEnables,
2392 ipmi::Privilege::Admin,
2393 ipmiSetFrontPanelButtonEnables);
2394
Yong Liae4b0402018-11-02 11:12:14 +08002395 // Set Chassis Capabilities
anil kumar appana894d0222019-05-27 16:32:14 +00002396 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2397 ipmi::chassis::cmdSetChassisCapabilities,
2398 ipmi::Privilege::User, ipmiSetChassisCap);
Yong Liae4b0402018-11-02 11:12:14 +08002399
Tom05732372016-09-06 17:21:23 +05302400 // <Get System Boot Options>
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002401 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2402 ipmi::chassis::cmdGetSystemBootOptions,
2403 ipmi::Privilege::Operator,
2404 ipmiChassisGetSysBootOptions);
Adriana Kobylak40814c62015-10-27 15:58:44 -05002405
Tom05732372016-09-06 17:21:23 +05302406 // <Get Chassis Status>
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07002407 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2408 ipmi::chassis::cmdGetChassisStatus,
2409 ipmi::Privilege::User, ipmiGetChassisStatus);
Nan Lifdd8ec52016-08-28 03:57:40 +08002410
Vijay Khemka074f64d2020-03-03 15:08:43 -08002411 // <Chassis Get System Restart Cause>
2412 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2413 ipmi::chassis::cmdGetSystemRestartCause,
2414 ipmi::Privilege::User, ipmiGetSystemRestartCause);
2415
Tom05732372016-09-06 17:21:23 +05302416 // <Chassis Control>
anil kumar appanadafff5f2019-04-27 18:06:00 +00002417 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2418 ipmi::chassis::cmdChassisControl,
2419 ipmi::Privilege::Operator, ipmiChassisControl);
shgoupfd84fbbf2015-12-17 10:05:51 +08002420
Tom Joseph5110c122018-03-23 17:55:40 +05302421 // <Chassis Identify>
Vernon Mauery400cc782018-10-09 13:49:53 -07002422 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2423 ipmi::chassis::cmdChassisIdentify,
2424 ipmi::Privilege::Operator, ipmiChassisIdentify);
Tom Joseph5110c122018-03-23 17:55:40 +05302425
Tom05732372016-09-06 17:21:23 +05302426 // <Set System Boot Options>
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002427 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2428 ipmi::chassis::cmdSetSystemBootOptions,
2429 ipmi::Privilege::Operator,
2430 ipmiChassisSetSysBootOptions);
2431
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002432 // <Get POH Counter>
anil kumar appanaa5a76eb2019-04-30 14:57:24 +00002433 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2434 ipmi::chassis::cmdGetPohCounter,
2435 ipmi::Privilege::User, ipmiGetPOHCounter);
Yong Lic6713cf2018-09-12 12:35:13 +08002436
2437 // <Set Power Restore Policy>
Vernon Mauerye278ead2018-10-09 09:23:43 -07002438 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2439 ipmi::chassis::cmdSetPowerRestorePolicy,
2440 ipmi::Privilege::Operator,
2441 ipmiChassisSetPowerRestorePolicy);
vishwa36993272015-11-20 12:43:49 -06002442}