blob: 3a650b6a2433a0d94fe552dc1264f3f126582126 [file] [log] [blame]
Patrick Venture46470a32018-09-07 19:26:25 -07001#include "config.h"
2
3#include "chassishandler.hpp"
Patrick Venture0b02be92018-08-31 11:55:55 -07004
Patrick Venture0b02be92018-08-31 11:55:55 -07005#include <arpa/inet.h>
6#include <endian.h>
7#include <limits.h>
8#include <mapper.h>
9#include <netinet/in.h>
Patrick Venture0b02be92018-08-31 11:55:55 -070010
Ratan Guptafd28dd72016-08-01 04:58:01 -050011#include <array>
Patrick Venture0b02be92018-08-31 11:55:55 -070012#include <chrono>
Patrick Ventureb51bf9c2018-09-10 15:53:14 -070013#include <cstring>
Vernon Mauerybdda8002019-02-26 10:18:51 -080014#include <filesystem>
Andrew Geisslera6e3a302017-05-31 19:34:00 -050015#include <fstream>
Tom Joseph5110c122018-03-23 17:55:40 +053016#include <future>
Vernon Mauerye08fbff2019-04-03 09:19:34 -070017#include <ipmid/api.hpp>
Vernon Mauery33250242019-03-12 16:49:26 -070018#include <ipmid/types.hpp>
Vernon Mauery6a98fe72019-03-11 15:57:48 -070019#include <ipmid/utils.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070020#include <map>
21#include <phosphor-logging/elog-errors.hpp>
22#include <phosphor-logging/log.hpp>
23#include <sdbusplus/bus.hpp>
William A. Kennington III4c008022018-10-12 17:18:14 -070024#include <sdbusplus/message/types.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070025#include <sdbusplus/server/object.hpp>
Vernon Mauery1181af72018-10-08 12:05:00 -070026#include <sdbusplus/timer.hpp>
Vernon Mauerye278ead2018-10-09 09:23:43 -070027#include <settings.hpp>
Patrick Venture0b02be92018-08-31 11:55:55 -070028#include <sstream>
Patrick Venture3a5071a2018-09-12 13:27:42 -070029#include <string>
30#include <xyz/openbmc_project/Common/error.hpp>
31#include <xyz/openbmc_project/Control/Boot/Mode/server.hpp>
32#include <xyz/openbmc_project/Control/Boot/Source/server.hpp>
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +030033#include <xyz/openbmc_project/Control/Boot/Type/server.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070034#include <xyz/openbmc_project/Control/Power/RestorePolicy/server.hpp>
Jason M. Billsad588bf2020-01-30 16:18:33 -080035#include <xyz/openbmc_project/State/Chassis/server.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070036#include <xyz/openbmc_project/State/Host/server.hpp>
37#include <xyz/openbmc_project/State/PowerOnHours/server.hpp>
38
Lei YU4b0ddb62019-01-25 16:43:50 +080039std::unique_ptr<phosphor::Timer> identifyTimer
40 __attribute__((init_priority(101)));
Marri Devender Rao6706c1c2018-05-14 00:29:38 -050041
Yong Lif4e38512019-05-21 14:46:55 +080042static ChassisIDState chassisIDState = ChassisIDState::reserved;
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +000043static constexpr uint8_t setParmVersion = 0x01;
Yong Lif4e38512019-05-21 14:46:55 +080044
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
Marri Devender Rao6706c1c2018-05-14 00:29:38 -050061static constexpr size_t encIdentifyObjectsSize = 1;
62static constexpr size_t chassisIdentifyReqLength = 2;
63static constexpr size_t identifyIntervalPos = 0;
64static constexpr size_t forceIdentifyPos = 1;
shgoupfd84fbbf2015-12-17 10:05:51 +080065
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +000066namespace ipmi
67{
68constexpr Cc ccParmNotSupported = 0x80;
69
70static inline auto responseParmNotSupported()
71{
72 return response(ccParmNotSupported);
73}
74} // namespace ipmi
75
Adriana Kobylak40814c62015-10-27 15:58:44 -050076void register_netfn_chassis_functions() __attribute__((constructor));
77
shgoupfd84fbbf2015-12-17 10:05:51 +080078// Host settings in dbus
79// Service name should be referenced by connection name got via object mapper
Patrick Venture0b02be92018-08-31 11:55:55 -070080const char* settings_object_name = "/org/openbmc/settings/host0";
81const char* settings_intf_name = "org.freedesktop.DBus.Properties";
Patrick Venture0b02be92018-08-31 11:55:55 -070082const char* identify_led_object_name =
Tom Joseph5110c122018-03-23 17:55:40 +053083 "/xyz/openbmc_project/led/groups/enclosure_identify";
shgoupfd84fbbf2015-12-17 10:05:51 +080084
Ratan Guptadcb10672017-07-10 10:33:50 +053085constexpr auto SETTINGS_ROOT = "/";
86constexpr auto SETTINGS_MATCH = "host0";
Ratan Guptadcb10672017-07-10 10:33:50 +053087
88constexpr auto IP_INTERFACE = "xyz.openbmc_project.Network.IP";
89constexpr auto MAC_INTERFACE = "xyz.openbmc_project.Network.MACAddress";
90
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -050091static constexpr auto chassisStateRoot = "/xyz/openbmc_project/state";
92static constexpr auto chassisPOHStateIntf =
Patrick Venture0b02be92018-08-31 11:55:55 -070093 "xyz.openbmc_project.State.PowerOnHours";
Patrick Williams7345ac42021-04-30 20:57:39 -050094static constexpr auto pohCounterProperty = "POHCounter";
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -050095static constexpr auto match = "chassis0";
Yong Liae4b0402018-11-02 11:12:14 +080096const static constexpr char chassisCapIntf[] =
97 "xyz.openbmc_project.Control.ChassisCapabilities";
Karthick Sundarrajan86d8bd72019-11-26 12:48:50 -080098const static constexpr char chassisIntrusionProp[] = "ChassisIntrusionEnabled";
99const static constexpr char chassisFrontPanelLockoutProp[] =
100 "ChassisFrontPanelLockoutEnabled";
101const static constexpr char chassisNMIProp[] = "ChassisNMIEnabled";
102const static constexpr char chassisPowerInterlockProp[] =
103 "ChassisPowerInterlockEnabled";
Yong Liae4b0402018-11-02 11:12:14 +0800104const static constexpr char chassisFRUDevAddrProp[] = "FRUDeviceAddress";
105const static constexpr char chassisSDRDevAddrProp[] = "SDRDeviceAddress";
106const static constexpr char chassisSELDevAddrProp[] = "SELDeviceAddress";
107const static constexpr char chassisSMDevAddrProp[] = "SMDeviceAddress";
108const static constexpr char chassisBridgeDevAddrProp[] = "BridgeDeviceAddress";
109static constexpr uint8_t chassisCapFlagMask = 0x0f;
110static 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
121namespace State = sdbusplus::xyz::openbmc_project::State::server;
122
Vernon Mauery185b9f82018-07-20 10:52:36 -0700123namespace fs = std::filesystem;
Andrew Geisslera6e3a302017-05-31 19:34:00 -0500124
Ratan Guptadcb10672017-07-10 10:33:50 +0530125using namespace phosphor::logging;
126using namespace sdbusplus::xyz::openbmc_project::Common::Error;
Marri Devender Rao81719702018-05-07 00:53:48 -0500127using namespace sdbusplus::xyz::openbmc_project::Control::Boot::server;
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";
Deepak Kodihalli8cc19362017-07-21 11:18:38 -0500145sdbusplus::bus::bus dbus(ipmid_get_sd_bus_connection());
146
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
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530190 sdbusplus::bus::bus 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);
200 auto variant = ipmi::getDbusProperty(bus, macObjectInfo.second,
201 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 {
297 log<level::ERR>("Invalid net config ");
298 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 {
307 log<level::ERR>("Invalid length of address size");
308 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 Venture0b02be92018-08-31 11:55:55 -0700343 struct sockaddr_in addr4
344 {
345 };
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700346 std::memcpy(&addr4.sin_addr.s_addr, &data[offset], addrSize);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530347
Patrick Venture0b02be92018-08-31 11:55:55 -0700348 inet_ntop(AF_INET, &addr4.sin_addr, ipAddr, INET_ADDRSTRLEN);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530349
350 break;
351 }
352 case AF_INET6:
353 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700354 struct sockaddr_in6 addr6
355 {
356 };
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700357 std::memcpy(&addr6.sin6_addr.s6_addr, &data[offset], addrSize);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530358
Patrick Venture0b02be92018-08-31 11:55:55 -0700359 inet_ntop(AF_INET6, &addr6.sin6_addr, ipAddr, INET6_ADDRSTRLEN);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530360
361 break;
362 }
363 default:
364 {
365 return {};
366 }
367 }
368
369 return ipAddr;
370}
371
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000372ipmi::Cc setHostNetworkData(ipmi::message::Payload& data)
Ratan Guptafd28dd72016-08-01 04:58:01 -0500373{
Ratan Guptadcb10672017-07-10 10:33:50 +0530374 using namespace std::string_literals;
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000375 std::string hostNetworkConfig;
376 std::string mac("00:00:00:00:00:00");
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530377 std::string ipAddress, gateway;
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000378 std::string addrOrigin{0};
Patrick Venture0b02be92018-08-31 11:55:55 -0700379 uint8_t addrSize{0};
Ratan Guptadcb10672017-07-10 10:33:50 +0530380 std::string addressOrigin =
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530381 "xyz.openbmc_project.Network.IP.AddressOrigin.DHCP";
Patrick Venture0b02be92018-08-31 11:55:55 -0700382 std::string addressType = "xyz.openbmc_project.Network.IP.Protocol.IPv4";
383 uint8_t prefix{0};
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530384 uint8_t family = AF_INET;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500385
Patrick Venture0b02be92018-08-31 11:55:55 -0700386 // cookie starts from second byte
Ratan Guptafd28dd72016-08-01 04:58:01 -0500387 // version starts from sixth byte
388
Ratan Guptadcb10672017-07-10 10:33:50 +0530389 try
Ratan Guptafd28dd72016-08-01 04:58:01 -0500390 {
Ratan Guptadcb10672017-07-10 10:33:50 +0530391 do
392 {
393 // cookie == 0x21 0x70 0x62 0x21
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000394 data.trailingOk = true;
395 auto msgLen = data.size();
396 std::vector<uint8_t> msgPayloadBytes(msgLen);
397 if (data.unpack(msgPayloadBytes) != 0 || !data.fullyUnpacked())
Ratan Guptadcb10672017-07-10 10:33:50 +0530398 {
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000399 log<level::ERR>(
400 "Error in unpacking message of setHostNetworkData");
401 return ipmi::ccReqDataLenInvalid;
402 }
403
404 uint8_t* msgPayloadStartingPos = msgPayloadBytes.data();
405 constexpr size_t cookieSize = 4;
406 if (msgLen < cookieOffset + cookieSize)
407 {
408 log<level::ERR>(
409 "Error in cookie getting of setHostNetworkData");
410 return ipmi::ccReqDataLenInvalid;
411 }
412 if (std::equal(msgPayloadStartingPos + cookieOffset,
413 msgPayloadStartingPos + cookieOffset + cookieSize,
414 (netConfInitialBytes + cookieOffset)) != 0)
415 {
416 // all cookie == 0
417 if (std::all_of(msgPayloadStartingPos + cookieOffset,
418 msgPayloadStartingPos + cookieOffset +
419 cookieSize,
420 [](int i) { return i == 0; }) == true)
Ratan Guptadcb10672017-07-10 10:33:50 +0530421 {
422 // need to zero out the network settings.
423 break;
424 }
425
426 log<level::ERR>("Invalid Cookie");
427 elog<InternalFailure>();
428 }
429
430 // vesion == 0x00 0x01
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000431 if (msgLen < versionOffset + sizeVersion)
Ratan Guptadcb10672017-07-10 10:33:50 +0530432 {
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000433 log<level::ERR>(
434 "Error in version getting of setHostNetworkData");
435 return ipmi::ccReqDataLenInvalid;
436 }
437 if (std::equal(msgPayloadStartingPos + versionOffset,
438 msgPayloadStartingPos + versionOffset + sizeVersion,
439 (netConfInitialBytes + versionOffset)) != 0)
440 {
Ratan Guptadcb10672017-07-10 10:33:50 +0530441 log<level::ERR>("Invalid Version");
442 elog<InternalFailure>();
443 }
444
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000445 if (msgLen < macOffset + 6)
446 {
447 log<level::ERR>(
448 "Error in mac address getting of setHostNetworkData");
449 return ipmi::ccReqDataLenInvalid;
450 }
451 std::stringstream result;
452 std::copy((msgPayloadStartingPos + macOffset),
453 (msgPayloadStartingPos + macOffset + 5),
454 std::ostream_iterator<int>(result, ":"));
455 mac = result.str();
Ratan Guptadcb10672017-07-10 10:33:50 +0530456
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000457 if (msgLen < addrTypeOffset + sizeof(decltype(addrOrigin)))
458 {
459 log<level::ERR>(
460 "Error in original address getting of setHostNetworkData");
461 return ipmi::ccReqDataLenInvalid;
462 }
463 std::copy(msgPayloadStartingPos + addrTypeOffset,
464 msgPayloadStartingPos + addrTypeOffset +
465 sizeof(decltype(addrOrigin)),
466 std::ostream_iterator<int>(result, ""));
467 addrOrigin = result.str();
Ratan Guptadcb10672017-07-10 10:33:50 +0530468
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000469 if (!addrOrigin.empty())
Ratan Guptadcb10672017-07-10 10:33:50 +0530470 {
471 addressOrigin =
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530472 "xyz.openbmc_project.Network.IP.AddressOrigin.Static";
Ratan Guptadcb10672017-07-10 10:33:50 +0530473 }
474
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000475 if (msgLen < addrSizeOffset + sizeof(decltype(addrSize)))
476 {
477 log<level::ERR>(
478 "Error in address size getting of setHostNetworkData");
479 return ipmi::ccReqDataLenInvalid;
480 }
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530481 // Get the address size
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000482 std::copy(msgPayloadStartingPos + addrSizeOffset,
483 (msgPayloadStartingPos + addrSizeOffset +
484 sizeof(decltype(addrSize))),
485 &addrSize);
Ratan Guptadcb10672017-07-10 10:33:50 +0530486
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000487 uint8_t prefixOffset = ipAddrOffset + addrSize;
488 if (msgLen < prefixOffset + sizeof(decltype(prefix)))
489 {
490 log<level::ERR>(
491 "Error in prefix getting of setHostNetworkData");
492 return ipmi::ccReqDataLenInvalid;
493 }
494 std::copy(msgPayloadStartingPos + prefixOffset,
495 (msgPayloadStartingPos + prefixOffset +
496 sizeof(decltype(prefix))),
497 &prefix);
Ratan Guptadcb10672017-07-10 10:33:50 +0530498
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530499 uint8_t gatewayOffset = prefixOffset + sizeof(decltype(prefix));
Ratan Gupta8c31d232017-08-13 05:49:43 +0530500 if (addrSize != ipmi::network::IPV4_ADDRESS_SIZE_BYTE)
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530501 {
502 addressType = "xyz.openbmc_project.Network.IP.Protocol.IPv6";
503 family = AF_INET6;
504 }
505
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000506 if (msgLen < ipAddrOffset + addrSize)
507 {
508 log<level::ERR>(
509 "Error in IP address getting of setHostNetworkData");
510 return ipmi::ccReqDataLenInvalid;
511 }
512 ipAddress = getAddrStr(family, msgPayloadStartingPos, ipAddrOffset,
513 addrSize);
Ratan Guptad70f4532017-08-04 02:07:31 +0530514
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000515 if (msgLen < gatewayOffset + addrSize)
516 {
517 log<level::ERR>(
518 "Error in gateway address getting of setHostNetworkData");
519 return ipmi::ccReqDataLenInvalid;
520 }
521 gateway = getAddrStr(family, msgPayloadStartingPos, gatewayOffset,
522 addrSize);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530523
Patrick Venture0b02be92018-08-31 11:55:55 -0700524 } while (0);
Ratan Guptadcb10672017-07-10 10:33:50 +0530525
Patrick Venture0b02be92018-08-31 11:55:55 -0700526 // Cookie == 0 or it is a valid cookie
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000527 hostNetworkConfig += "ipaddress="s + ipAddress + ",prefix="s +
528 std::to_string(prefix) + ",gateway="s + gateway +
529 ",mac="s + mac + ",addressOrigin="s +
530 addressOrigin;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500531
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530532 sdbusplus::bus::bus bus(ipmid_get_sd_bus_connection());
533
534 auto ipObjectInfo = ipmi::getDbusObject(bus, IP_INTERFACE,
535 SETTINGS_ROOT, SETTINGS_MATCH);
536 auto macObjectInfo = ipmi::getDbusObject(bus, MAC_INTERFACE,
537 SETTINGS_ROOT, SETTINGS_MATCH);
Ratan Guptadcb10672017-07-10 10:33:50 +0530538 // set the dbus property
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530539 ipmi::setDbusProperty(bus, ipObjectInfo.second, ipObjectInfo.first,
Patrick Venture0b02be92018-08-31 11:55:55 -0700540 IP_INTERFACE, "Address", std::string(ipAddress));
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530541 ipmi::setDbusProperty(bus, ipObjectInfo.second, ipObjectInfo.first,
Patrick Venture0b02be92018-08-31 11:55:55 -0700542 IP_INTERFACE, "PrefixLength", prefix);
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530543 ipmi::setDbusProperty(bus, ipObjectInfo.second, ipObjectInfo.first,
Patrick Venture0b02be92018-08-31 11:55:55 -0700544 IP_INTERFACE, "Origin", addressOrigin);
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530545 ipmi::setDbusProperty(bus, ipObjectInfo.second, ipObjectInfo.first,
Patrick Venture0b02be92018-08-31 11:55:55 -0700546 IP_INTERFACE, "Gateway", std::string(gateway));
547 ipmi::setDbusProperty(
548 bus, ipObjectInfo.second, ipObjectInfo.first, IP_INTERFACE, "Type",
549 std::string("xyz.openbmc_project.Network.IP.Protocol.IPv4"));
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530550 ipmi::setDbusProperty(bus, macObjectInfo.second, macObjectInfo.first,
Patrick Venture0b02be92018-08-31 11:55:55 -0700551 MAC_INTERFACE, "MACAddress", std::string(mac));
Ratan Guptafd28dd72016-08-01 04:58:01 -0500552
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000553 log<level::DEBUG>("Network configuration changed",
554 entry("NETWORKCONFIG=%s", hostNetworkConfig.c_str()));
Ratan Guptafd28dd72016-08-01 04:58:01 -0500555 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -0500556 catch (const sdbusplus::exception_t& e)
Ratan Guptadcb10672017-07-10 10:33:50 +0530557 {
558 commit<InternalFailure>();
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000559 log<level::ERR>("Error in ipmiChassisSetSysBootOptions call");
560 return ipmi::ccUnspecifiedError;
Ratan Guptadcb10672017-07-10 10:33:50 +0530561 }
562
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +0000563 return ipmi::ccSuccess;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500564}
565
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500566uint32_t getPOHCounter()
567{
568 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
569
Patrick Venture0b02be92018-08-31 11:55:55 -0700570 auto chassisStateObj =
571 ipmi::getDbusObject(bus, chassisPOHStateIntf, chassisStateRoot, match);
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500572
Patrick Venture0b02be92018-08-31 11:55:55 -0700573 auto service =
574 ipmi::getService(bus, chassisPOHStateIntf, chassisStateObj.first);
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500575
Patrick Venture0b02be92018-08-31 11:55:55 -0700576 auto propValue =
577 ipmi::getDbusProperty(bus, service, chassisStateObj.first,
Patrick Williams7345ac42021-04-30 20:57:39 -0500578 chassisPOHStateIntf, pohCounterProperty);
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500579
Vernon Maueryf442e112019-04-09 11:44:36 -0700580 return std::get<uint32_t>(propValue);
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500581}
582
anil kumar appana43263c62019-05-27 12:45:04 +0000583/** @brief Implements the get chassis capabilities command
584 *
585 * @returns IPMI completion code plus response data
586 * chassisCapFlags - chassis capability flag
587 * chassisFRUInfoDevAddr - chassis FRU info Device Address
588 * chassisSDRDevAddr - chassis SDR device address
589 * chassisSELDevAddr - chassis SEL device address
590 * chassisSMDevAddr - chassis system management device address
591 * chassisBridgeDevAddr - chassis bridge device address
592 */
Karthick Sundarrajan86d8bd72019-11-26 12:48:50 -0800593ipmi::RspType<bool, // chassis intrusion sensor
594 bool, // chassis Front panel lockout
595 bool, // chassis NMI
596 bool, // chassis power interlock
597 uint4_t, // reserved
anil kumar appana43263c62019-05-27 12:45:04 +0000598 uint8_t, // chassis FRU info Device Address
599 uint8_t, // chassis SDR device address
600 uint8_t, // chassis SEL device address
601 uint8_t, // chassis system management device address
602 uint8_t // chassis bridge device address
603 >
604 ipmiGetChassisCap()
Nan Li8d15fb42016-08-16 22:29:40 +0800605{
anil kumar appana43263c62019-05-27 12:45:04 +0000606 ipmi::PropertyMap properties;
Yong Liae4b0402018-11-02 11:12:14 +0800607 try
608 {
609 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
Nan Li8d15fb42016-08-16 22:29:40 +0800610
Yong Liae4b0402018-11-02 11:12:14 +0800611 ipmi::DbusObjectInfo chassisCapObject =
612 ipmi::getDbusObject(bus, chassisCapIntf);
Nan Li8d15fb42016-08-16 22:29:40 +0800613
Yong Liae4b0402018-11-02 11:12:14 +0800614 // capabilities flags
615 // [7..4] - reserved
616 // [3] – 1b = provides power interlock (IPM 1.5)
617 // [2] – 1b = provides Diagnostic Interrupt (FP NMI)
618 // [1] – 1b = provides “Front Panel Lockout” (indicates that the chassis
619 // has capabilities
620 // to lock out external power control and reset button or
621 // front panel interfaces and/or detect tampering with those
622 // interfaces).
623 // [0] -1b = Chassis provides intrusion (physical security) sensor.
624 // set to default value 0x0.
Nan Li8d15fb42016-08-16 22:29:40 +0800625
anil kumar appana43263c62019-05-27 12:45:04 +0000626 properties =
627 ipmi::getAllDbusProperties(bus, chassisCapObject.second,
628 chassisCapObject.first, chassisCapIntf);
Yong Liae4b0402018-11-02 11:12:14 +0800629 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -0500630 catch (const std::exception& e)
Yong Liae4b0402018-11-02 11:12:14 +0800631 {
anil kumar appana43263c62019-05-27 12:45:04 +0000632 log<level::ERR>("Failed to fetch Chassis Capability properties",
633 entry("ERROR=%s", e.what()));
634 return ipmi::responseUnspecifiedError();
Yong Liae4b0402018-11-02 11:12:14 +0800635 }
636
Karthick Sundarrajan86d8bd72019-11-26 12:48:50 -0800637 bool* chassisIntrusionFlag =
638 std::get_if<bool>(&properties[chassisIntrusionProp]);
639 if (chassisIntrusionFlag == nullptr)
anil kumar appana43263c62019-05-27 12:45:04 +0000640 {
Karthick Sundarrajan86d8bd72019-11-26 12:48:50 -0800641 log<level::ERR>("Error to get chassis Intrusion flags");
642 return ipmi::responseUnspecifiedError();
643 }
644 bool* chassisFrontPanelFlag =
645 std::get_if<bool>(&properties[chassisFrontPanelLockoutProp]);
646 if (chassisFrontPanelFlag == nullptr)
647 {
648 log<level::ERR>("Error to get chassis intrusion flags");
649 return ipmi::responseUnspecifiedError();
650 }
651 bool* chassisNMIFlag = std::get_if<bool>(&properties[chassisNMIProp]);
652 if (chassisNMIFlag == nullptr)
653 {
654 log<level::ERR>("Error to get chassis NMI flags");
655 return ipmi::responseUnspecifiedError();
656 }
657 bool* chassisPowerInterlockFlag =
658 std::get_if<bool>(&properties[chassisPowerInterlockProp]);
659 if (chassisPowerInterlockFlag == nullptr)
660 {
661 log<level::ERR>("Error to get chassis power interlock flags");
anil kumar appana43263c62019-05-27 12:45:04 +0000662 return ipmi::responseUnspecifiedError();
663 }
664 uint8_t* chassisFRUInfoDevAddr =
665 std::get_if<uint8_t>(&properties[chassisFRUDevAddrProp]);
666 if (chassisFRUInfoDevAddr == nullptr)
667 {
668 log<level::ERR>("Error to get chassis FRU info device address");
669 return ipmi::responseUnspecifiedError();
670 }
671 uint8_t* chassisSDRDevAddr =
672 std::get_if<uint8_t>(&properties[chassisSDRDevAddrProp]);
673 if (chassisSDRDevAddr == nullptr)
674 {
675 log<level::ERR>("Error to get chassis SDR device address");
676 return ipmi::responseUnspecifiedError();
677 }
678 uint8_t* chassisSELDevAddr =
679 std::get_if<uint8_t>(&properties[chassisSELDevAddrProp]);
680 if (chassisSELDevAddr == nullptr)
681 {
682 log<level::ERR>("Error to get chassis SEL device address");
683 return ipmi::responseUnspecifiedError();
684 }
685 uint8_t* chassisSMDevAddr =
686 std::get_if<uint8_t>(&properties[chassisSMDevAddrProp]);
687 if (chassisSMDevAddr == nullptr)
688 {
689 log<level::ERR>("Error to get chassis SM device address");
690 return ipmi::responseUnspecifiedError();
691 }
692 uint8_t* chassisBridgeDevAddr =
693 std::get_if<uint8_t>(&properties[chassisBridgeDevAddrProp]);
694 if (chassisBridgeDevAddr == nullptr)
695 {
696 log<level::ERR>("Error to get chassis bridge device address");
697 return ipmi::responseUnspecifiedError();
698 }
699
Karthick Sundarrajan86d8bd72019-11-26 12:48:50 -0800700 return ipmi::responseSuccess(*chassisIntrusionFlag, *chassisFrontPanelFlag,
701 *chassisNMIFlag, *chassisPowerInterlockFlag, 0,
702 *chassisFRUInfoDevAddr, *chassisSDRDevAddr,
703 *chassisSELDevAddr, *chassisSMDevAddr,
704 *chassisBridgeDevAddr);
Yong Liae4b0402018-11-02 11:12:14 +0800705}
706
anil kumar appana894d0222019-05-27 16:32:14 +0000707/** @brief implements set chassis capalibities command
708 * @param intrusion - chassis intrusion
709 * @param fpLockout - frontpannel lockout
710 * @param reserved1 - skip one bit
711 * @param fruDeviceAddr - chassis FRU info Device Address
712 * @param sdrDeviceAddr - chassis SDR device address
713 * @param selDeviceAddr - chassis SEL device address
714 * @param smDeviceAddr - chassis system management device address
715 * @param bridgeDeviceAddr - chassis bridge device address
716 *
717 * @returns IPMI completion code
718 */
719ipmi::RspType<> ipmiSetChassisCap(bool intrusion, bool fpLockout,
720 uint6_t reserved1,
721
722 uint8_t fruDeviceAddr,
723
724 uint8_t sdrDeviceAddr,
725
726 uint8_t selDeviceAddr,
727
728 uint8_t smDeviceAddr,
729
730 uint8_t bridgeDeviceAddr)
Yong Liae4b0402018-11-02 11:12:14 +0800731{
Yong Liae4b0402018-11-02 11:12:14 +0800732
733 // check input data
anil kumar appana894d0222019-05-27 16:32:14 +0000734 if (reserved1 != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800735 {
anil kumar appana894d0222019-05-27 16:32:14 +0000736 log<level::ERR>("Unsupported request parameter");
737 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800738 }
739
anil kumar appana894d0222019-05-27 16:32:14 +0000740 if ((fruDeviceAddr & ~chassisCapAddrMask) != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800741 {
742 log<level::ERR>("Unsupported request parameter(FRU Addr)",
anil kumar appana894d0222019-05-27 16:32:14 +0000743 entry("REQ=0x%x", fruDeviceAddr));
744 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800745 }
anil kumar appana894d0222019-05-27 16:32:14 +0000746 if ((sdrDeviceAddr & ~chassisCapAddrMask) != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800747 {
748 log<level::ERR>("Unsupported request parameter(SDR Addr)",
anil kumar appana894d0222019-05-27 16:32:14 +0000749 entry("REQ=0x%x", sdrDeviceAddr));
750 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800751 }
752
anil kumar appana894d0222019-05-27 16:32:14 +0000753 if ((selDeviceAddr & ~chassisCapAddrMask) != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800754 {
755 log<level::ERR>("Unsupported request parameter(SEL Addr)",
anil kumar appana894d0222019-05-27 16:32:14 +0000756 entry("REQ=0x%x", selDeviceAddr));
757 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800758 }
759
anil kumar appana894d0222019-05-27 16:32:14 +0000760 if ((smDeviceAddr & ~chassisCapAddrMask) != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800761 {
anil kumar appana894d0222019-05-27 16:32:14 +0000762 log<level::ERR>("Unsupported request parameter(SM Addr)",
763 entry("REQ=0x%x", smDeviceAddr));
764 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800765 }
766
anil kumar appana894d0222019-05-27 16:32:14 +0000767 if ((bridgeDeviceAddr & ~chassisCapAddrMask) != 0)
Yong Liae4b0402018-11-02 11:12:14 +0800768 {
769 log<level::ERR>("Unsupported request parameter(Bridge Addr)",
anil kumar appana894d0222019-05-27 16:32:14 +0000770 entry("REQ=0x%x", bridgeDeviceAddr));
771 return ipmi::responseInvalidFieldRequest();
Yong Liae4b0402018-11-02 11:12:14 +0800772 }
773
774 try
775 {
776 sdbusplus::bus::bus bus(ipmid_get_sd_bus_connection());
777 ipmi::DbusObjectInfo chassisCapObject =
778 ipmi::getDbusObject(bus, chassisCapIntf);
779
780 ipmi::setDbusProperty(bus, chassisCapObject.second,
781 chassisCapObject.first, chassisCapIntf,
Karthick Sundarrajan86d8bd72019-11-26 12:48:50 -0800782 chassisIntrusionProp, intrusion);
783
784 ipmi::setDbusProperty(bus, chassisCapObject.second,
785 chassisCapObject.first, chassisCapIntf,
786 chassisFrontPanelLockoutProp, fpLockout);
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 chassisFRUDevAddrProp, fruDeviceAddr);
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 chassisSDRDevAddrProp, sdrDeviceAddr);
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 chassisSELDevAddrProp, selDeviceAddr);
Yong Liae4b0402018-11-02 11:12:14 +0800799
800 ipmi::setDbusProperty(bus, chassisCapObject.second,
801 chassisCapObject.first, chassisCapIntf,
anil kumar appana894d0222019-05-27 16:32:14 +0000802 chassisSMDevAddrProp, smDeviceAddr);
Yong Liae4b0402018-11-02 11:12:14 +0800803
804 ipmi::setDbusProperty(bus, chassisCapObject.second,
805 chassisCapObject.first, chassisCapIntf,
anil kumar appana894d0222019-05-27 16:32:14 +0000806 chassisBridgeDevAddrProp, bridgeDeviceAddr);
Yong Liae4b0402018-11-02 11:12:14 +0800807 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -0500808 catch (const std::exception& e)
Yong Liae4b0402018-11-02 11:12:14 +0800809 {
810 log<level::ERR>(e.what());
anil kumar appana894d0222019-05-27 16:32:14 +0000811 return ipmi::responseUnspecifiedError();
Yong Liae4b0402018-11-02 11:12:14 +0800812 }
anil kumar appana894d0222019-05-27 16:32:14 +0000813 return ipmi::responseSuccess();
Nan Li8d15fb42016-08-16 22:29:40 +0800814}
815
Vishwanatha Subbannab12b0c02017-03-07 18:17:19 +0530816//------------------------------------------
817// Calls into Host State Manager Dbus object
818//------------------------------------------
Jason M. Bills664e1c32020-01-30 16:02:39 -0800819int initiateHostStateTransition(ipmi::Context::ptr& ctx,
820 State::Host::Transition transition)
vishwa36993272015-11-20 12:43:49 -0600821{
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500822 // OpenBMC Host State Manager dbus framework
Jason M. Bills664e1c32020-01-30 16:02:39 -0800823 constexpr auto hostStatePath = "/xyz/openbmc_project/state/host0";
824 constexpr auto hostStateIntf = "xyz.openbmc_project.State.Host";
Vishwanatha Subbannab12b0c02017-03-07 18:17:19 +0530825
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500826 // Convert to string equivalent of the passed in transition enum.
827 auto request = State::convertForMessage(transition);
Vishwanatha Subbannab12b0c02017-03-07 18:17:19 +0530828
Jason M. Bills664e1c32020-01-30 16:02:39 -0800829 std::string service;
830 boost::system::error_code ec =
831 ipmi::getService(ctx, hostStateIntf, hostStatePath, service);
832
833 if (!ec)
834 {
835 ec = ipmi::setDbusProperty(ctx, service, hostStatePath, hostStateIntf,
836 "RequestedHostTransition", request);
837 }
838 if (ec)
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500839 {
840 log<level::ERR>("Failed to initiate transition",
Jason M. Bills664e1c32020-01-30 16:02:39 -0800841 entry("EXCEPTION=%s, REQUEST=%s", ec.message().c_str(),
842 request.c_str()));
843 return -1;
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500844 }
Jason M. Bills664e1c32020-01-30 16:02:39 -0800845 log<level::INFO>(
846 "Transition request initiated successfully",
847 entry("USERID=%d, REQUEST=%s", ctx->userId, request.c_str()));
848 return 0;
vishwa36993272015-11-20 12:43:49 -0600849}
850
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +0800851//------------------------------------------
Jason M. Billsad588bf2020-01-30 16:18:33 -0800852// Calls into Chassis State Manager Dbus object
853//------------------------------------------
854int initiateChassisStateTransition(ipmi::Context::ptr& ctx,
855 State::Chassis::Transition transition)
856{
857 // OpenBMC Chassis State Manager dbus framework
858 constexpr auto chassisStatePath = "/xyz/openbmc_project/state/chassis0";
859 constexpr auto chassisStateIntf = "xyz.openbmc_project.State.Chassis";
860
861 std::string service;
862 boost::system::error_code ec =
863 ipmi::getService(ctx, chassisStateIntf, chassisStatePath, service);
864
865 // Convert to string equivalent of the passed in transition enum.
866 auto request = State::convertForMessage(transition);
867
868 if (!ec)
869 {
870 ec = ipmi::setDbusProperty(ctx, service, chassisStatePath,
871 chassisStateIntf, "RequestedPowerTransition",
872 request);
873 }
874 if (ec)
875 {
876 log<level::ERR>("Failed to initiate transition",
877 entry("EXCEPTION=%s, REQUEST=%s", ec.message().c_str(),
878 request.c_str()));
879 return -1;
880 }
881
882 return 0;
883}
884
885//------------------------------------------
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +0800886// Set Enabled property to inform NMI source
887// handling to trigger a NMI_OUT BSOD.
888//------------------------------------------
889int setNmiProperty(const bool value)
890{
891 constexpr const char* nmiSourceObjPath =
892 "/xyz/openbmc_project/Chassis/Control/NMISource";
893 constexpr const char* nmiSourceIntf =
894 "xyz.openbmc_project.Chassis.Control.NMISource";
895 std::string bmcSourceSignal = "xyz.openbmc_project.Chassis.Control."
896 "NMISource.BMCSourceSignal.ChassisCmd";
897 std::shared_ptr<sdbusplus::asio::connection> busp = getSdBus();
898
899 try
900 {
901 auto service = ipmi::getService(*busp, nmiSourceIntf, nmiSourceObjPath);
902 ipmi::setDbusProperty(*busp, service, nmiSourceObjPath, nmiSourceIntf,
903 "BMCSource", bmcSourceSignal);
904 ipmi::setDbusProperty(*busp, service, nmiSourceObjPath, nmiSourceIntf,
905 "Enabled", value);
906 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -0500907 catch (const std::exception& e)
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +0800908 {
909 log<level::ERR>("Failed to trigger NMI_OUT",
910 entry("EXCEPTION=%s", e.what()));
911 return -1;
912 }
913
914 return 0;
915}
916
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500917namespace power_policy
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500918{
Nan Lifdd8ec52016-08-28 03:57:40 +0800919
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500920using namespace sdbusplus::xyz::openbmc_project::Control::Power::server;
921using IpmiValue = uint8_t;
922using DbusValue = RestorePolicy::Policy;
Nan Lifdd8ec52016-08-28 03:57:40 +0800923
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700924const std::map<DbusValue, IpmiValue> dbusToIpmi = {
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500925 {RestorePolicy::Policy::AlwaysOff, 0x00},
926 {RestorePolicy::Policy::Restore, 0x01},
Patrick Venture0b02be92018-08-31 11:55:55 -0700927 {RestorePolicy::Policy::AlwaysOn, 0x02}};
Nan Lifdd8ec52016-08-28 03:57:40 +0800928
Yong Lic6713cf2018-09-12 12:35:13 +0800929static constexpr uint8_t noChange = 0x03;
930static constexpr uint8_t allSupport = 0x01 | 0x02 | 0x04;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700931
932/* helper function for Get Chassis Status Command
933 */
934std::optional<uint2_t> getPowerRestorePolicy()
935{
936 uint2_t restorePolicy = 0;
937 using namespace chassis::internal;
938
James Feist225dec82019-11-26 16:25:06 -0800939 settings::Objects& objects = cache::getObjects();
940
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700941 try
942 {
943 const auto& powerRestoreSetting =
James Feist225dec82019-11-26 16:25:06 -0800944 objects.map.at(powerRestoreIntf).front();
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700945 ipmi::Value result = ipmi::getDbusProperty(
946 *getSdBus(),
James Feist225dec82019-11-26 16:25:06 -0800947 objects.service(powerRestoreSetting, powerRestoreIntf).c_str(),
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700948 powerRestoreSetting.c_str(), powerRestoreIntf,
949 "PowerRestorePolicy");
950 auto powerRestore = RestorePolicy::convertPolicyFromString(
951 std::get<std::string>(result));
952 restorePolicy = dbusToIpmi.at(powerRestore);
953 }
954 catch (const std::exception& e)
955 {
956 log<level::ERR>(
957 "Failed to fetch pgood property", entry("ERROR=%s", e.what()),
James Feist225dec82019-11-26 16:25:06 -0800958 entry("PATH=%s", objects.map.at(powerRestoreIntf).front().c_str()),
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700959 entry("INTERFACE=%s", powerRestoreIntf));
James Feist225dec82019-11-26 16:25:06 -0800960 cache::objectsPtr.reset();
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700961 return std::nullopt;
962 }
963 return std::make_optional(restorePolicy);
964}
965
966/*
967 * getPowerStatus
968 * helper function for Get Chassis Status Command
969 * return - optional value for pgood (no value on error)
970 */
971std::optional<bool> getPowerStatus()
972{
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700973 bool powerGood = false;
974 std::shared_ptr<sdbusplus::asio::connection> busp = getSdBus();
975 try
976 {
Jason M. Bills3de424c2019-05-21 09:57:16 -0700977 constexpr const char* chassisStatePath =
978 "/xyz/openbmc_project/state/chassis0";
979 constexpr const char* chassisStateIntf =
980 "xyz.openbmc_project.State.Chassis";
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700981 auto service =
Jason M. Bills3de424c2019-05-21 09:57:16 -0700982 ipmi::getService(*busp, chassisStateIntf, chassisStatePath);
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700983
Jason M. Bills3de424c2019-05-21 09:57:16 -0700984 ipmi::Value powerState =
985 ipmi::getDbusProperty(*busp, service, chassisStatePath,
986 chassisStateIntf, "CurrentPowerState");
987 powerGood = std::get<std::string>(powerState) ==
988 "xyz.openbmc_project.State.Chassis.PowerState.On";
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700989 }
990 catch (const std::exception& e)
991 {
992 try
993 {
994 // FIXME: some legacy modules use the older path; try that next
995 constexpr const char* legacyPwrCtrlObj =
996 "/org/openbmc/control/power0";
997 constexpr const char* legacyPwrCtrlIntf =
998 "org.openbmc.control.Power";
999 auto service =
1000 ipmi::getService(*busp, legacyPwrCtrlIntf, legacyPwrCtrlObj);
1001
1002 ipmi::Value variant = ipmi::getDbusProperty(
1003 *busp, service, legacyPwrCtrlObj, legacyPwrCtrlIntf, "pgood");
1004 powerGood = static_cast<bool>(std::get<int>(variant));
1005 }
1006 catch (const std::exception& e)
1007 {
1008 log<level::ERR>("Failed to fetch pgood property",
Jason M. Bills3de424c2019-05-21 09:57:16 -07001009 entry("ERROR=%s", e.what()));
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001010 return std::nullopt;
1011 }
1012 }
1013 return std::make_optional(powerGood);
1014}
1015
Yong Li70ce7352019-05-16 21:15:27 +08001016/*
1017 * getACFailStatus
1018 * helper function for Get Chassis Status Command
1019 * return - bool value for ACFail (false on error)
1020 */
1021bool getACFailStatus()
1022{
1023 constexpr const char* powerControlObj =
1024 "/xyz/openbmc_project/Chassis/Control/Power0";
1025 constexpr const char* powerControlIntf =
1026 "xyz.openbmc_project.Chassis.Control.Power";
1027 bool acFail = false;
1028 std::shared_ptr<sdbusplus::asio::connection> bus = getSdBus();
1029 try
1030 {
1031 auto service =
1032 ipmi::getService(*bus, powerControlIntf, powerControlObj);
1033
1034 ipmi::Value variant = ipmi::getDbusProperty(
1035 *bus, service, powerControlObj, powerControlIntf, "PFail");
1036 acFail = std::get<bool>(variant);
1037 }
1038 catch (const std::exception& e)
1039 {
1040 log<level::ERR>("Failed to fetch PFail property",
1041 entry("ERROR=%s", e.what()),
1042 entry("PATH=%s", powerControlObj),
1043 entry("INTERFACE=%s", powerControlIntf));
1044 }
1045 return acFail;
1046}
Deepak Kodihalli18b70d12017-07-21 13:36:33 -05001047} // namespace power_policy
Nan Lifdd8ec52016-08-28 03:57:40 +08001048
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001049static std::optional<bool> getButtonEnabled(const std::string& buttonPath,
1050 const std::string& buttonIntf)
1051{
1052 std::shared_ptr<sdbusplus::asio::connection> busp = getSdBus();
1053 bool buttonDisabled = false;
1054 try
1055 {
1056 auto service = ipmi::getService(*busp, buttonIntf, buttonPath);
1057 ipmi::Value enabled = ipmi::getDbusProperty(*busp, service, buttonPath,
1058 buttonIntf, "Enabled");
1059 buttonDisabled = !std::get<bool>(enabled);
1060 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -05001061 catch (const sdbusplus::exception::exception& e)
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001062 {
1063 log<level::ERR>("Fail to get button Enabled property",
1064 entry("PATH=%s", buttonPath.c_str()),
1065 entry("ERROR=%s", e.what()));
1066 return std::nullopt;
1067 }
1068 return std::make_optional(buttonDisabled);
1069}
1070
Kuiying Wang21addc52019-01-04 10:50:21 +08001071static bool setButtonEnabled(ipmi::Context::ptr& ctx,
1072 const std::string& buttonPath,
1073 const std::string& buttonIntf, bool enable)
1074{
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,
1081 "Enabled", enable);
1082 }
1083 if (ec)
1084 {
1085 log<level::ERR>("Fail to set button Enabled property",
1086 entry("SERVICE=%s", service.c_str()),
1087 entry("PATH=%s", buttonPath.c_str()),
1088 entry("ERROR=%s", ec.message().c_str()));
1089 return false;
1090 }
1091 return true;
1092}
1093
Nan Lifdd8ec52016-08-28 03:57:40 +08001094//----------------------------------------------------------------------
1095// Get Chassis Status commands
1096//----------------------------------------------------------------------
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001097ipmi::RspType<bool, // Power is on
1098 bool, // Power overload
1099 bool, // Interlock
1100 bool, // power fault
1101 bool, // power control fault
1102 uint2_t, // power restore policy
1103 bool, // reserved
1104
1105 bool, // AC failed
1106 bool, // last power down caused by a Power overload
1107 bool, // last power down caused by a power interlock
1108 bool, // last power down caused by power fault
1109 bool, // last ‘Power is on’ state was entered via IPMI command
1110 uint3_t, // reserved
1111
1112 bool, // Chassis intrusion active
1113 bool, // Front Panel Lockout active
1114 bool, // Drive Fault
1115 bool, // Cooling/fan fault detected
1116 uint2_t, // Chassis Identify State
1117 bool, // Chassis Identify command and state info supported
1118 bool, // reserved
1119
1120 bool, // Power off button disabled
1121 bool, // Reset button disabled
1122 bool, // Diagnostic Interrupt button disabled
1123 bool, // Standby (sleep) button disabled
1124 bool, // Power off button disable allowed
1125 bool, // Reset button disable allowed
1126 bool, // Diagnostic Interrupt button disable allowed
1127 bool // Standby (sleep) button disable allowed
1128 >
1129 ipmiGetChassisStatus()
Nan Lifdd8ec52016-08-28 03:57:40 +08001130{
Deepak Kodihalli18b70d12017-07-21 13:36:33 -05001131 using namespace chassis::internal;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001132 std::optional<uint2_t> restorePolicy =
1133 power_policy::getPowerRestorePolicy();
1134 std::optional<bool> powerGood = power_policy::getPowerStatus();
1135 if (!restorePolicy || !powerGood)
Deepak Kodihalli18b70d12017-07-21 13:36:33 -05001136 {
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001137 return ipmi::responseUnspecifiedError();
Deepak Kodihalli18b70d12017-07-21 13:36:33 -05001138 }
Nan Lifdd8ec52016-08-28 03:57:40 +08001139
1140 // Front Panel Button Capabilities and disable/enable status(Optional)
Vernon Mauery6d5b2f72019-05-16 14:48:47 -07001141 std::optional<bool> powerButtonReading =
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001142 getButtonEnabled(powerButtonPath, powerButtonIntf);
Vernon Mauery6d5b2f72019-05-16 14:48:47 -07001143 // allow disable if the interface is present
1144 bool powerButtonDisableAllow = static_cast<bool>(powerButtonReading);
1145 // default return the button is enabled (not disabled)
1146 bool powerButtonDisabled = false;
1147 if (powerButtonDisableAllow)
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001148 {
Vernon Mauery6d5b2f72019-05-16 14:48:47 -07001149 // return the real value of the button status, if present
1150 powerButtonDisabled = *powerButtonReading;
1151 }
1152
1153 std::optional<bool> resetButtonReading =
1154 getButtonEnabled(resetButtonPath, resetButtonIntf);
1155 // allow disable if the interface is present
1156 bool resetButtonDisableAllow = static_cast<bool>(resetButtonReading);
1157 // default return the button is enabled (not disabled)
1158 bool resetButtonDisabled = false;
1159 if (resetButtonDisableAllow)
1160 {
1161 // return the real value of the button status, if present
1162 resetButtonDisabled = *resetButtonReading;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001163 }
Nan Lifdd8ec52016-08-28 03:57:40 +08001164
Yong Li70ce7352019-05-16 21:15:27 +08001165 bool powerDownAcFailed = power_policy::getACFailStatus();
1166
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001167 // This response has a lot of hard-coded, unsupported fields
1168 // They are set to false or 0
1169 constexpr bool powerOverload = false;
1170 constexpr bool chassisInterlock = false;
1171 constexpr bool powerFault = false;
1172 constexpr bool powerControlFault = false;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001173 constexpr bool powerDownOverload = false;
1174 constexpr bool powerDownInterlock = false;
1175 constexpr bool powerDownPowerFault = false;
1176 constexpr bool powerStatusIPMI = false;
1177 constexpr bool chassisIntrusionActive = false;
1178 constexpr bool frontPanelLockoutActive = false;
1179 constexpr bool driveFault = false;
1180 constexpr bool coolingFanFault = false;
1181 // chassisIdentifySupport set because this command is implemented
1182 constexpr bool chassisIdentifySupport = true;
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001183 uint2_t chassisIdentifyState = types::enum_cast<uint2_t>(chassisIDState);
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001184 constexpr bool diagButtonDisabled = false;
1185 constexpr bool sleepButtonDisabled = false;
1186 constexpr bool diagButtonDisableAllow = false;
1187 constexpr bool sleepButtonDisableAllow = false;
1188
1189 return ipmi::responseSuccess(
1190 *powerGood, powerOverload, chassisInterlock, powerFault,
1191 powerControlFault, *restorePolicy,
1192 false, // reserved
1193
1194 powerDownAcFailed, powerDownOverload, powerDownInterlock,
1195 powerDownPowerFault, powerStatusIPMI,
1196 uint3_t(0), // reserved
1197
1198 chassisIntrusionActive, frontPanelLockoutActive, driveFault,
1199 coolingFanFault, chassisIdentifyState, chassisIdentifySupport,
1200 false, // reserved
1201
Vernon Mauery6d5b2f72019-05-16 14:48:47 -07001202 powerButtonDisabled, resetButtonDisabled, diagButtonDisabled,
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001203 sleepButtonDisabled, powerButtonDisableAllow, resetButtonDisableAllow,
1204 diagButtonDisableAllow, sleepButtonDisableAllow);
Nan Lifdd8ec52016-08-28 03:57:40 +08001205}
Chris Austen7888c4d2015-12-03 15:26:20 -06001206
Vijay Khemka074f64d2020-03-03 15:08:43 -08001207enum class IpmiRestartCause
1208{
1209 Unknown = 0x0,
1210 RemoteCommand = 0x1,
1211 ResetButton = 0x2,
1212 PowerButton = 0x3,
1213 WatchdogTimer = 0x4,
1214 PowerPolicyAlwaysOn = 0x6,
1215 PowerPolicyPreviousState = 0x7,
1216 SoftReset = 0xa,
1217};
1218
1219static IpmiRestartCause
1220 restartCauseToIpmiRestartCause(State::Host::RestartCause cause)
1221{
1222 switch (cause)
1223 {
1224 case State::Host::RestartCause::Unknown:
1225 {
1226 return IpmiRestartCause::Unknown;
1227 }
1228 case State::Host::RestartCause::RemoteCommand:
1229 {
1230 return IpmiRestartCause::RemoteCommand;
1231 }
1232 case State::Host::RestartCause::ResetButton:
1233 {
1234 return IpmiRestartCause::ResetButton;
1235 }
1236 case State::Host::RestartCause::PowerButton:
1237 {
1238 return IpmiRestartCause::PowerButton;
1239 }
1240 case State::Host::RestartCause::WatchdogTimer:
1241 {
1242 return IpmiRestartCause::WatchdogTimer;
1243 }
1244 case State::Host::RestartCause::PowerPolicyAlwaysOn:
1245 {
1246 return IpmiRestartCause::PowerPolicyAlwaysOn;
1247 }
1248 case State::Host::RestartCause::PowerPolicyPreviousState:
1249 {
1250 return IpmiRestartCause::PowerPolicyPreviousState;
1251 }
1252 case State::Host::RestartCause::SoftReset:
1253 {
1254 return IpmiRestartCause::SoftReset;
1255 }
1256 default:
1257 {
1258 return IpmiRestartCause::Unknown;
1259 }
1260 }
1261}
1262
1263/*
1264 * getRestartCause
1265 * helper function for Get Host restart cause Command
1266 * return - optional value for RestartCause (no value on error)
1267 */
1268static std::optional<uint4_t> getRestartCause(ipmi::Context::ptr ctx)
1269{
1270 constexpr const char* restartCausePath =
1271 "/xyz/openbmc_project/control/host0/restart_cause";
1272 constexpr const char* restartCauseIntf =
1273 "xyz.openbmc_project.Control.Host.RestartCause";
1274
1275 std::string service;
1276 boost::system::error_code ec =
1277 ipmi::getService(ctx, restartCauseIntf, restartCausePath, service);
1278 if (!ec)
1279 {
1280 std::string restartCauseStr;
1281 ec = ipmi::getDbusProperty<std::string>(
1282 ctx, service, restartCausePath, restartCauseIntf, "RestartCause",
1283 restartCauseStr);
1284 if (!ec)
1285 {
1286 auto cause =
1287 State::Host::convertRestartCauseFromString(restartCauseStr);
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001288 return types::enum_cast<uint4_t>(
1289 restartCauseToIpmiRestartCause(cause));
Vijay Khemka074f64d2020-03-03 15:08:43 -08001290 }
1291 }
1292
1293 log<level::ERR>("Failed to fetch RestartCause property",
1294 entry("ERROR=%s", ec.message().c_str()),
1295 entry("PATH=%s", restartCausePath),
1296 entry("INTERFACE=%s", restartCauseIntf));
1297 return std::nullopt;
1298}
1299
1300ipmi::RspType<uint4_t, // Restart Cause
1301 uint4_t, // reserved
1302 uint8_t // channel number (not supported)
1303 >
1304 ipmiGetSystemRestartCause(ipmi::Context::ptr ctx)
1305{
1306 std::optional<uint4_t> cause = getRestartCause(ctx);
1307 if (!cause)
1308 {
1309 return ipmi::responseUnspecifiedError();
1310 }
1311
Vernon Mauery916d4232021-03-29 13:42:16 -07001312 constexpr uint4_t reserved = 0;
1313 auto channel = static_cast<uint8_t>(ctx->channel);
1314 return ipmi::responseSuccess(cause.value(), reserved, channel);
Vijay Khemka074f64d2020-03-03 15:08:43 -08001315}
1316
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301317//-------------------------------------------------------------
1318// Send a command to SoftPowerOff application to stop any timer
1319//-------------------------------------------------------------
1320int stop_soft_off_timer()
1321{
Patrick Venture0b02be92018-08-31 11:55:55 -07001322 constexpr auto iface = "org.freedesktop.DBus.Properties";
1323 constexpr auto soft_off_iface = "xyz.openbmc_project.Ipmi.Internal."
1324 "SoftPowerOff";
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301325
Patrick Venture0b02be92018-08-31 11:55:55 -07001326 constexpr auto property = "ResponseReceived";
1327 constexpr auto value = "xyz.openbmc_project.Ipmi.Internal."
1328 "SoftPowerOff.HostResponse.HostShutdown";
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301329
1330 // Get the system bus where most system services are provided.
1331 auto bus = ipmid_get_sd_bus_connection();
1332
1333 // Get the service name
Andrew Geissler2b4e4592017-06-08 11:18:35 -05001334 // TODO openbmc/openbmc#1661 - Mapper refactor
1335 //
1336 // See openbmc/openbmc#1743 for some details but high level summary is that
1337 // for now the code will directly call the soft off interface due to a
1338 // race condition with mapper usage
1339 //
Patrick Venture0b02be92018-08-31 11:55:55 -07001340 // char *busname = nullptr;
1341 // auto r = mapper_get_service(bus, SOFTOFF_OBJPATH, &busname);
1342 // if (r < 0)
Andrew Geissler2b4e4592017-06-08 11:18:35 -05001343 //{
1344 // fprintf(stderr, "Failed to get %s bus name: %s\n",
Aditya Saripalli5fb14602017-11-09 14:46:27 +05301345 // SOFTOFF_OBJPATH, -r);
Andrew Geissler2b4e4592017-06-08 11:18:35 -05001346 // return r;
1347 //}
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301348
1349 // No error object or reply expected.
Andrew Geissler2b4e4592017-06-08 11:18:35 -05001350 int rc = sd_bus_call_method(bus, SOFTOFF_BUSNAME, SOFTOFF_OBJPATH, iface,
Patrick Venture0b02be92018-08-31 11:55:55 -07001351 "Set", nullptr, nullptr, "ssv", soft_off_iface,
1352 property, "s", value);
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301353 if (rc < 0)
1354 {
Aditya Saripalli5fb14602017-11-09 14:46:27 +05301355 log<level::ERR>("Failed to set property in SoftPowerOff object",
1356 entry("ERRNO=0x%X", -rc));
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301357 }
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001358
Patrick Venture0b02be92018-08-31 11:55:55 -07001359 // TODO openbmc/openbmc#1661 - Mapper refactor
1360 // free(busname);
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301361 return rc;
1362}
1363
vishwa36993272015-11-20 12:43:49 -06001364//----------------------------------------------------------------------
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001365// Create file to indicate there is no need for softoff notification to host
1366//----------------------------------------------------------------------
1367void indicate_no_softoff_needed()
1368{
1369 fs::path path{HOST_INBAND_REQUEST_DIR};
1370 if (!fs::is_directory(path))
1371 {
1372 fs::create_directory(path);
1373 }
1374
1375 // Add the host instance (default 0 for now) to the file name
1376 std::string file{HOST_INBAND_REQUEST_FILE};
Patrick Venture0b02be92018-08-31 11:55:55 -07001377 auto size = std::snprintf(nullptr, 0, file.c_str(), 0);
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001378 size++; // null
1379 std::unique_ptr<char[]> buf(new char[size]);
Patrick Venture0b02be92018-08-31 11:55:55 -07001380 std::snprintf(buf.get(), size, file.c_str(), 0);
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001381
1382 // Append file name to directory and create it
1383 path /= buf.get();
1384 std::ofstream(path.c_str());
1385}
1386
anil kumar appanadafff5f2019-04-27 18:06:00 +00001387/** @brief Implementation of chassis control command
1388 *
1389 * @param - chassisControl command byte
1390 *
1391 * @return Success or InvalidFieldRequest.
1392 */
Jason M. Bills664e1c32020-01-30 16:02:39 -08001393ipmi::RspType<> ipmiChassisControl(ipmi::Context::ptr& ctx,
1394 uint8_t chassisControl)
vishwa36993272015-11-20 12:43:49 -06001395{
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001396 int rc = 0;
anil kumar appanadafff5f2019-04-27 18:06:00 +00001397 switch (chassisControl)
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001398 {
1399 case CMD_POWER_ON:
Jason M. Bills664e1c32020-01-30 16:02:39 -08001400 rc = initiateHostStateTransition(ctx, State::Host::Transition::On);
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001401 break;
1402 case CMD_POWER_OFF:
Vishwanatha Subbanna8b26d352017-08-04 18:35:18 +05301403 // This path would be hit in 2 conditions.
1404 // 1: When user asks for power off using ipmi chassis command 0x04
1405 // 2: Host asking for power off post shutting down.
1406
1407 // If it's a host requested power off, then need to nudge Softoff
1408 // application that it needs to stop the watchdog timer if running.
1409 // If it is a user requested power off, then this is not really
1410 // needed. But then we need to differentiate between user and host
1411 // calling this same command
1412
1413 // For now, we are going ahead with trying to nudge the soft off and
1414 // interpret the failure to do so as a non softoff case
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001415 rc = stop_soft_off_timer();
Vishwanatha Subbanna8b26d352017-08-04 18:35:18 +05301416
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001417 // Only request the Off transition if the soft power off
1418 // application is not running
1419 if (rc < 0)
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001420 {
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001421 // First create a file to indicate to the soft off application
Vishwanatha Subbanna8b26d352017-08-04 18:35:18 +05301422 // that it should not run. Not doing this will result in State
1423 // manager doing a default soft power off when asked for power
1424 // off.
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001425 indicate_no_softoff_needed();
1426
1427 // Now request the shutdown
Jason M. Bills664e1c32020-01-30 16:02:39 -08001428 rc = initiateHostStateTransition(ctx,
1429 State::Host::Transition::Off);
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001430 }
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001431 else
1432 {
Vishwanatha Subbanna8b26d352017-08-04 18:35:18 +05301433 log<level::INFO>("Soft off is running, so let shutdown target "
1434 "stop the host");
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001435 }
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001436 break;
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301437
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001438 case CMD_HARD_RESET:
Jason M. Bills664e1c32020-01-30 16:02:39 -08001439 rc = initiateHostStateTransition(
1440 ctx, State::Host::Transition::ForceWarmReboot);
Chanh Nguyend0a7fcd2021-07-16 22:59:28 +07001441 break;
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001442 case CMD_POWER_CYCLE:
1443 // SPEC has a section that says certain implementations can trigger
1444 // PowerOn if power is Off when a command to power cycle is
1445 // requested
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001446
1447 // First create a file to indicate to the soft off application
1448 // that it should not run since this is a direct user initiated
1449 // power reboot request (i.e. a reboot request that is not
1450 // originating via a soft power off SMS request)
1451 indicate_no_softoff_needed();
1452
Jason M. Bills664e1c32020-01-30 16:02:39 -08001453 rc = initiateHostStateTransition(ctx,
1454 State::Host::Transition::Reboot);
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001455 break;
Vishwanatha Subbanna8b26d352017-08-04 18:35:18 +05301456
1457 case CMD_SOFT_OFF_VIA_OVER_TEMP:
1458 // Request Host State Manager to do a soft power off
Jason M. Bills664e1c32020-01-30 16:02:39 -08001459 rc = initiateHostStateTransition(ctx, State::Host::Transition::Off);
Vishwanatha Subbanna8b26d352017-08-04 18:35:18 +05301460 break;
1461
Kuiying Wang6b0ceaa2019-11-05 15:13:40 +08001462 case CMD_PULSE_DIAGNOSTIC_INTR:
1463 rc = setNmiProperty(true);
1464 break;
1465
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001466 default:
1467 {
Aditya Saripalli5fb14602017-11-09 14:46:27 +05301468 log<level::ERR>("Invalid Chassis Control command",
anil kumar appanadafff5f2019-04-27 18:06:00 +00001469 entry("CMD=0x%X", chassisControl));
1470 return ipmi::responseInvalidFieldRequest();
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001471 }
1472 }
vishwa36993272015-11-20 12:43:49 -06001473
anil kumar appanadafff5f2019-04-27 18:06:00 +00001474 return ((rc < 0) ? ipmi::responseUnspecifiedError()
1475 : ipmi::responseSuccess());
vishwa36993272015-11-20 12:43:49 -06001476}
1477
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001478/** @brief Return D-Bus connection string to enclosure identify LED object
1479 *
1480 * @param[in, out] connection - connection to D-Bus object
1481 * @return a IPMI return code
1482 */
1483std::string getEnclosureIdentifyConnection()
Tom Joseph5110c122018-03-23 17:55:40 +05301484{
Tom Joseph5110c122018-03-23 17:55:40 +05301485 // lookup enclosure_identify group owner(s) in mapper
1486 auto mapperCall = chassis::internal::dbus.new_method_call(
Patrick Venture0b02be92018-08-31 11:55:55 -07001487 ipmi::MAPPER_BUS_NAME, ipmi::MAPPER_OBJ, ipmi::MAPPER_INTF,
1488 "GetObject");
Tom Joseph5110c122018-03-23 17:55:40 +05301489
1490 mapperCall.append(identify_led_object_name);
Patrick Venture0b02be92018-08-31 11:55:55 -07001491 static const std::vector<std::string> interfaces = {
1492 "xyz.openbmc_project.Led.Group"};
Tom Joseph5110c122018-03-23 17:55:40 +05301493 mapperCall.append(interfaces);
1494 auto mapperReply = chassis::internal::dbus.call(mapperCall);
1495 if (mapperReply.is_method_error())
1496 {
1497 log<level::ERR>("Chassis Identify: Error communicating to mapper.");
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001498 elog<InternalFailure>();
Tom Joseph5110c122018-03-23 17:55:40 +05301499 }
1500 std::vector<std::pair<std::string, std::vector<std::string>>> mapperResp;
1501 mapperReply.read(mapperResp);
1502
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001503 if (mapperResp.size() != encIdentifyObjectsSize)
Tom Joseph5110c122018-03-23 17:55:40 +05301504 {
Patrick Venture0b02be92018-08-31 11:55:55 -07001505 log<level::ERR>(
1506 "Invalid number of enclosure identify objects.",
1507 entry("ENC_IDENTITY_OBJECTS_SIZE=%d", mapperResp.size()));
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001508 elog<InternalFailure>();
1509 }
1510 auto pair = mapperResp[encIdentifyObjectsSize - 1];
1511 return pair.first;
1512}
Tom Joseph5110c122018-03-23 17:55:40 +05301513
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001514/** @brief Turn On/Off enclosure identify LED
1515 *
1516 * @param[in] flag - true to turn on LED, false to turn off
1517 * @return a IPMI return code
1518 */
1519void enclosureIdentifyLed(bool flag)
1520{
1521 using namespace chassis::internal;
1522 std::string connection = std::move(getEnclosureIdentifyConnection());
Vernon Mauery400cc782018-10-09 13:49:53 -07001523 auto msg = std::string("enclosureIdentifyLed(") +
1524 boost::lexical_cast<std::string>(flag) + ")";
1525 log<level::DEBUG>(msg.c_str());
Patrick Venture0b02be92018-08-31 11:55:55 -07001526 auto led =
1527 dbus.new_method_call(connection.c_str(), identify_led_object_name,
1528 "org.freedesktop.DBus.Properties", "Set");
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001529 led.append("xyz.openbmc_project.Led.Group", "Asserted",
Vernon Mauery16b86932019-05-01 08:36:11 -07001530 std::variant<bool>(flag));
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001531 auto ledReply = dbus.call(led);
1532 if (ledReply.is_method_error())
1533 {
1534 log<level::ERR>("Chassis Identify: Error Setting State On/Off\n",
Patrick Venture0b02be92018-08-31 11:55:55 -07001535 entry("LED_STATE=%d", flag));
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001536 elog<InternalFailure>();
1537 }
1538}
1539
1540/** @brief Callback method to turn off LED
1541 */
1542void enclosureIdentifyLedOff()
1543{
1544 try
1545 {
Yong Lif4e38512019-05-21 14:46:55 +08001546 chassisIDState = ChassisIDState::off;
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001547 enclosureIdentifyLed(false);
1548 }
1549 catch (const InternalFailure& e)
1550 {
1551 report<InternalFailure>();
1552 }
1553}
1554
1555/** @brief Create timer to turn on and off the enclosure LED
1556 */
1557void createIdentifyTimer()
1558{
1559 if (!identifyTimer)
1560 {
Vernon Mauery1181af72018-10-08 12:05:00 -07001561 identifyTimer =
1562 std::make_unique<phosphor::Timer>(enclosureIdentifyLedOff);
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001563 }
1564}
1565
Vernon Mauery400cc782018-10-09 13:49:53 -07001566ipmi::RspType<> ipmiChassisIdentify(std::optional<uint8_t> interval,
1567 std::optional<uint8_t> force)
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001568{
Vernon Mauery400cc782018-10-09 13:49:53 -07001569 uint8_t identifyInterval = interval.value_or(DEFAULT_IDENTIFY_TIME_OUT);
1570 bool forceIdentify = force.value_or(0) & 0x01;
Tom Josephbed26992018-07-31 23:00:24 +05301571
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001572 if (identifyInterval || forceIdentify)
1573 {
Vernon Mauery400cc782018-10-09 13:49:53 -07001574 // stop the timer if already started;
1575 // for force identify we should not turn off LED
Vernon Mauery1181af72018-10-08 12:05:00 -07001576 identifyTimer->stop();
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001577 try
Tom Joseph5110c122018-03-23 17:55:40 +05301578 {
Yong Lif4e38512019-05-21 14:46:55 +08001579 chassisIDState = ChassisIDState::temporaryOn;
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001580 enclosureIdentifyLed(true);
1581 }
1582 catch (const InternalFailure& e)
1583 {
1584 report<InternalFailure>();
Vernon Mauery400cc782018-10-09 13:49:53 -07001585 return ipmi::responseResponseError();
Tom Joseph5110c122018-03-23 17:55:40 +05301586 }
1587
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001588 if (forceIdentify)
Tom Joseph5110c122018-03-23 17:55:40 +05301589 {
Yong Lif4e38512019-05-21 14:46:55 +08001590 chassisIDState = ChassisIDState::indefiniteOn;
Vernon Mauery400cc782018-10-09 13:49:53 -07001591 return ipmi::responseSuccess();
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001592 }
1593 // start the timer
1594 auto time = std::chrono::duration_cast<std::chrono::microseconds>(
Patrick Venture0b02be92018-08-31 11:55:55 -07001595 std::chrono::seconds(identifyInterval));
Vernon Mauery1181af72018-10-08 12:05:00 -07001596 identifyTimer->start(time);
Tom Joseph5110c122018-03-23 17:55:40 +05301597 }
Tom Josephbed26992018-07-31 23:00:24 +05301598 else if (!identifyInterval)
1599 {
Vernon Mauery1181af72018-10-08 12:05:00 -07001600 identifyTimer->stop();
Tom Josephbed26992018-07-31 23:00:24 +05301601 enclosureIdentifyLedOff();
1602 }
Vernon Mauery400cc782018-10-09 13:49:53 -07001603 return ipmi::responseSuccess();
Tom Joseph5110c122018-03-23 17:55:40 +05301604}
1605
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001606namespace boot_options
1607{
1608
1609using namespace sdbusplus::xyz::openbmc_project::Control::Boot::server;
1610using IpmiValue = uint8_t;
1611constexpr auto ipmiDefault = 0;
1612
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001613std::map<IpmiValue, Type::Types> typeIpmiToDbus = {{0x00, Type::Types::Legacy},
1614 {0x01, Type::Types::EFI}};
1615
Patrick Venture0b02be92018-08-31 11:55:55 -07001616std::map<IpmiValue, Source::Sources> sourceIpmiToDbus = {
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001617 {0x01, Source::Sources::Network},
1618 {0x02, Source::Sources::Disk},
1619 {0x05, Source::Sources::ExternalMedia},
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08001620 {0x0f, Source::Sources::RemovableMedia},
Patrick Venture0b02be92018-08-31 11:55:55 -07001621 {ipmiDefault, Source::Sources::Default}};
shgoupfd84fbbf2015-12-17 10:05:51 +08001622
Patrick Venture0b02be92018-08-31 11:55:55 -07001623std::map<IpmiValue, Mode::Modes> modeIpmiToDbus = {
Yong Li5833cb62019-10-30 13:27:12 +08001624#ifdef ENABLE_BOOT_FLAG_SAFE_MODE_SUPPORT
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001625 {0x03, Mode::Modes::Safe},
Yong Li5833cb62019-10-30 13:27:12 +08001626#endif // ENABLE_BOOT_SAFE_MODE_SUPPORT
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001627 {0x06, Mode::Modes::Setup},
Patrick Venture0b02be92018-08-31 11:55:55 -07001628 {ipmiDefault, Mode::Modes::Regular}};
shgoupfd84fbbf2015-12-17 10:05:51 +08001629
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001630std::map<Type::Types, IpmiValue> typeDbusToIpmi = {{Type::Types::Legacy, 0x00},
1631 {Type::Types::EFI, 0x01}};
1632
Patrick Venture0b02be92018-08-31 11:55:55 -07001633std::map<Source::Sources, IpmiValue> sourceDbusToIpmi = {
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001634 {Source::Sources::Network, 0x01},
1635 {Source::Sources::Disk, 0x02},
1636 {Source::Sources::ExternalMedia, 0x05},
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08001637 {Source::Sources::RemovableMedia, 0x0f},
Patrick Venture0b02be92018-08-31 11:55:55 -07001638 {Source::Sources::Default, ipmiDefault}};
shgoupfd84fbbf2015-12-17 10:05:51 +08001639
Patrick Venture0b02be92018-08-31 11:55:55 -07001640std::map<Mode::Modes, IpmiValue> modeDbusToIpmi = {
Yong Li5833cb62019-10-30 13:27:12 +08001641#ifdef ENABLE_BOOT_FLAG_SAFE_MODE_SUPPORT
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001642 {Mode::Modes::Safe, 0x03},
Yong Li5833cb62019-10-30 13:27:12 +08001643#endif // ENABLE_BOOT_SAFE_MODE_SUPPORT
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001644 {Mode::Modes::Setup, 0x06},
Patrick Venture0b02be92018-08-31 11:55:55 -07001645 {Mode::Modes::Regular, ipmiDefault}};
shgoupfd84fbbf2015-12-17 10:05:51 +08001646
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001647} // namespace boot_options
shgoupfd84fbbf2015-12-17 10:05:51 +08001648
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001649/** @brief Get the property value for boot source
1650 * @param[in] ctx - context pointer
1651 * @param[out] source - boot source value
1652 * @return On failure return IPMI error.
1653 */
1654static ipmi::Cc getBootSource(ipmi::Context::ptr& ctx, Source::Sources& source)
1655{
1656 using namespace chassis::internal;
1657 std::string result;
1658 std::string service;
1659 boost::system::error_code ec =
1660 getService(ctx, bootSourceIntf, bootSettingsPath, service);
1661 if (!ec)
1662 {
1663 ec = ipmi::getDbusProperty(ctx, service, bootSettingsPath,
1664 bootSourceIntf, "BootSource", result);
1665 if (!ec)
1666 {
1667 source = Source::convertSourcesFromString(result);
1668 return ipmi::ccSuccess;
1669 }
1670 }
1671 log<level::ERR>("Error in BootSource Get",
1672 entry("ERROR=%s", ec.message().c_str()));
1673 return ipmi::ccUnspecifiedError;
1674}
1675
Marri Devender Rao81719702018-05-07 00:53:48 -05001676/** @brief Set the property value for boot source
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001677 * @param[in] ctx - context pointer
Marri Devender Rao81719702018-05-07 00:53:48 -05001678 * @param[in] source - boot source value
1679 * @return On failure return IPMI error.
1680 */
Jayaprakash Mutyala6088e9f2021-07-14 07:40:29 +00001681static ipmi::Cc setBootSource(ipmi::Context::ptr& ctx,
1682 const Source::Sources& source)
Marri Devender Rao81719702018-05-07 00:53:48 -05001683{
1684 using namespace chassis::internal;
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001685 std::string service;
1686 boost::system::error_code ec =
1687 getService(ctx, bootSourceIntf, bootSettingsPath, service);
1688 if (!ec)
Marri Devender Rao81719702018-05-07 00:53:48 -05001689 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001690 ec = ipmi::setDbusProperty(ctx, service, bootSettingsPath,
1691 bootSourceIntf, "BootSource",
1692 convertForMessage(source));
1693 if (!ec)
1694 {
1695 return ipmi::ccSuccess;
1696 }
Marri Devender Rao81719702018-05-07 00:53:48 -05001697 }
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001698 log<level::ERR>("Error in BootSource Set",
1699 entry("ERROR=%s", ec.message().c_str()));
1700 return ipmi::ccUnspecifiedError;
1701}
1702
1703/** @brief Get the property value for boot mode
1704 * @param[in] ctx - context pointer
1705 * @param[out] mode - boot mode value
1706 * @return On failure return IPMI error.
1707 */
1708static ipmi::Cc getBootMode(ipmi::Context::ptr& ctx, Mode::Modes& mode)
1709{
1710 using namespace chassis::internal;
1711 std::string result;
1712 std::string service;
1713 boost::system::error_code ec =
1714 getService(ctx, bootModeIntf, bootSettingsPath, service);
1715 if (!ec)
1716 {
1717 ec = ipmi::getDbusProperty(ctx, service, bootSettingsPath, bootModeIntf,
1718 "BootMode", result);
1719 if (!ec)
1720 {
1721 mode = Mode::convertModesFromString(result);
1722 return ipmi::ccSuccess;
1723 }
1724 }
1725 log<level::ERR>("Error in BootMode Get",
1726 entry("ERROR=%s", ec.message().c_str()));
1727 return ipmi::ccUnspecifiedError;
Marri Devender Rao81719702018-05-07 00:53:48 -05001728}
1729
Patrick Venture0b02be92018-08-31 11:55:55 -07001730/** @brief Set the property value for boot mode
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001731 * @param[in] ctx - context pointer
Marri Devender Rao81719702018-05-07 00:53:48 -05001732 * @param[in] mode - boot mode value
1733 * @return On failure return IPMI error.
1734 */
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001735static ipmi::Cc setBootMode(ipmi::Context::ptr& ctx, const Mode::Modes& mode)
Marri Devender Rao81719702018-05-07 00:53:48 -05001736{
1737 using namespace chassis::internal;
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001738 std::string service;
1739 boost::system::error_code ec =
1740 getService(ctx, bootModeIntf, bootSettingsPath, service);
1741 if (!ec)
Marri Devender Rao81719702018-05-07 00:53:48 -05001742 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001743 ec = ipmi::setDbusProperty(ctx, service, bootSettingsPath, bootModeIntf,
1744 "BootMode", convertForMessage(mode));
1745 if (!ec)
1746 {
1747 return ipmi::ccSuccess;
1748 }
Marri Devender Rao81719702018-05-07 00:53:48 -05001749 }
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001750 log<level::ERR>("Error in BootMode Set",
1751 entry("ERROR=%s", ec.message().c_str()));
1752 return ipmi::ccUnspecifiedError;
1753}
1754
1755/** @brief Get the property value for boot type
1756 * @param[in] ctx - context pointer
1757 * @param[out] type - boot type value
1758 * @return On failure return IPMI error.
1759 */
1760static ipmi::Cc getBootType(ipmi::Context::ptr& ctx, Type::Types& type)
1761{
1762 using namespace chassis::internal;
1763 std::string result;
1764 std::string service;
1765 boost::system::error_code ec =
1766 getService(ctx, bootTypeIntf, bootSettingsPath, service);
1767
1768 // Don't throw error if BootType interface is not present.
1769 // This interface is not relevant for some Host architectures
1770 // (for example POWER). In this case we don't won't IPMI to
1771 // return an error, but simply return bootType as EFI.
1772 type = Type::Types::EFI;
1773 if (!ec)
1774 {
1775 ec = ipmi::getDbusProperty(ctx, service, bootSettingsPath, bootTypeIntf,
1776 "BootType", result);
1777 if (ec)
1778 {
1779 log<level::ERR>("Error in BootType Get",
1780 entry("ERROR=%s", ec.message().c_str()));
1781 return ipmi::ccUnspecifiedError;
1782 }
1783 type = Type::convertTypesFromString(result);
1784 }
1785
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00001786 return ipmi::ccSuccess;
Marri Devender Rao81719702018-05-07 00:53:48 -05001787}
1788
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001789/** @brief Set the property value for boot type
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001790 * @param[in] ctx - context pointer
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001791 * @param[in] type - boot type value
1792 * @return On failure return IPMI error.
1793 */
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001794static ipmi::Cc setBootType(ipmi::Context::ptr& ctx, const Type::Types& type)
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001795{
1796 using namespace chassis::internal;
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001797 std::string service;
1798 boost::system::error_code ec =
1799 getService(ctx, bootTypeIntf, bootSettingsPath, service);
1800 if (!ec)
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001801 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001802 ec = ipmi::setDbusProperty(ctx, service, bootSettingsPath, bootTypeIntf,
1803 "BootType", convertForMessage(type));
1804 if (ec)
1805 {
1806 log<level::ERR>("Error in BootType Set",
1807 entry("ERROR=%s", ec.message().c_str()));
1808 return ipmi::ccUnspecifiedError;
1809 }
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001810 }
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001811 // Don't throw error if BootType interface is not present.
1812 // This interface is not relevant for some Host architectures
1813 // (for example POWER). In this case we don't won't IPMI to
1814 // return an error, but want to just skip this function.
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03001815 return ipmi::ccSuccess;
1816}
1817
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001818/** @brief Get the property value for boot override enable
1819 * @param[in] ctx - context pointer
1820 * @param[out] enable - boot override enable
1821 * @return On failure return IPMI error.
1822 */
1823static ipmi::Cc getBootEnable(ipmi::Context::ptr& ctx, bool& enable)
1824{
1825 using namespace chassis::internal;
1826 std::string result;
1827 std::string service;
1828 boost::system::error_code ec =
1829 getService(ctx, bootEnableIntf, bootSettingsPath, service);
1830 if (!ec)
1831 {
1832 ec = ipmi::getDbusProperty(ctx, service, bootSettingsPath,
1833 bootEnableIntf, "Enabled", enable);
1834 if (!ec)
1835 {
1836 return ipmi::ccSuccess;
1837 }
1838 }
1839 log<level::ERR>("Error in Boot Override Enable Get",
1840 entry("ERROR=%s", ec.message().c_str()));
1841 return ipmi::ccUnspecifiedError;
1842}
1843
1844/** @brief Set the property value for boot override enable
1845 * @param[in] ctx - context pointer
1846 * @param[in] enable - boot override enable
1847 * @return On failure return IPMI error.
1848 */
1849static ipmi::Cc setBootEnable(ipmi::Context::ptr& ctx, const bool& enable)
1850{
1851 using namespace chassis::internal;
1852 std::string service;
1853 boost::system::error_code ec =
1854 getService(ctx, bootEnableIntf, bootSettingsPath, service);
1855 if (!ec)
1856 {
1857 ec = ipmi::setDbusProperty(ctx, service, bootSettingsPath,
1858 bootEnableIntf, "Enabled", enable);
1859 if (!ec)
1860 {
1861 return ipmi::ccSuccess;
1862 }
1863 }
1864 log<level::ERR>("Error in Boot Source Override Enable Set",
1865 entry("ERROR=%s", ec.message().c_str()));
1866 return ipmi::ccUnspecifiedError;
1867}
1868
1869/** @brief Get the property value for boot override one-time
1870 * @param[in] ctx - context pointer
1871 * @param[out] onetime - boot override one-time
1872 * @return On failure return IPMI error.
1873 */
1874static ipmi::Cc getBootOneTime(ipmi::Context::ptr& ctx, bool& onetime)
1875{
1876 using namespace chassis::internal;
1877 std::string result;
1878 std::string service;
1879 boost::system::error_code ec =
1880 getService(ctx, bootOneTimeIntf, bootSettingsOneTimePath, service);
1881 if (!ec)
1882 {
1883 ec = ipmi::getDbusProperty(ctx, service, bootSettingsOneTimePath,
1884 bootOneTimeIntf, "Enabled", onetime);
1885 if (!ec)
1886 {
1887 return ipmi::ccSuccess;
1888 }
1889 }
1890 log<level::ERR>("Error in Boot Override OneTime Get",
1891 entry("ERROR=%s", ec.message().c_str()));
1892 return ipmi::ccUnspecifiedError;
1893}
1894
1895/** @brief Set the property value for boot override one-time
1896 * @param[in] ctx - context pointer
1897 * @param[in] onetime - boot override one-time
1898 * @return On failure return IPMI error.
1899 */
1900static ipmi::Cc setBootOneTime(ipmi::Context::ptr& ctx, const bool& onetime)
1901{
1902 using namespace chassis::internal;
1903 std::string service;
1904 boost::system::error_code ec =
1905 getService(ctx, bootOneTimeIntf, bootSettingsOneTimePath, service);
1906 if (!ec)
1907 {
1908 ec = ipmi::setDbusProperty(ctx, service, bootSettingsOneTimePath,
1909 bootOneTimeIntf, "Enabled", onetime);
1910 if (!ec)
1911 {
1912 return ipmi::ccSuccess;
1913 }
1914 }
1915 log<level::ERR>("Error in Boot Source Override OneTime Set",
1916 entry("ERROR=%s", ec.message().c_str()));
1917 return ipmi::ccUnspecifiedError;
1918}
1919
huangheab369282020-10-10 14:40:00 +08001920static constexpr uint8_t setComplete = 0x0;
1921static constexpr uint8_t setInProgress = 0x1;
1922static uint8_t transferStatus = setComplete;
Chen Yugang86ac4992021-06-25 08:14:52 +08001923static uint8_t bootFlagValidBitClr = 0;
Hieu Huynh38ffafc2021-05-14 08:40:14 +00001924static uint5_t bootInitiatorAckData = 0x0;
Hieu Huynh1982a3f2021-09-21 03:06:45 +00001925static bool cmosClear = false;
huangheab369282020-10-10 14:40:00 +08001926
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001927/** @brief implements the Get Chassis system boot option
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001928 * @param ctx - context pointer
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001929 * @param bootOptionParameter - boot option parameter selector
1930 * @param reserved1 - reserved bit
1931 * @param setSelector - selects a particular block or set of parameters
1932 * under the given parameter selector
1933 * write as 00h if parameter doesn't use a setSelector
1934 * @param blockSelector- selects a particular block within a set of
1935 * parameters write as 00h if parameter doesn't use a
1936 * blockSelector
1937 *
1938 * @return IPMI completion code plus response data
1939 * @return Payload contains below parameters:
1940 * version - parameter version
1941 * bootOptionParameter - boot option parameter selector
Patrick Venture8b1c3032020-09-15 09:43:03 -07001942 * parmIndicator - parameter valid/invalid indicator
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001943 * data - configuration parameter data
1944 */
1945ipmi::RspType<ipmi::message::Payload>
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03001946 ipmiChassisGetSysBootOptions(ipmi::Context::ptr ctx,
1947 uint7_t bootOptionParameter, bool reserved1,
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001948
1949 uint8_t setSelector, uint8_t blockSelector)
Adriana Kobylak40814c62015-10-27 15:58:44 -05001950{
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03001951 ipmi::Cc rc;
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001952 if (reserved1)
1953 {
1954 return ipmi::responseInvalidFieldRequest();
1955 }
1956
1957 constexpr uint4_t version = 0x01;
1958 ipmi::message::Payload response;
1959 response.pack(version, uint4_t{});
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001960 using namespace boot_options;
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00001961
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001962 IpmiValue bootOption = ipmiDefault;
Adriana Kobylak40814c62015-10-27 15:58:44 -05001963
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001964 if (types::enum_cast<BootOptionParameter>(bootOptionParameter) ==
1965 BootOptionParameter::setInProgress)
huangheab369282020-10-10 14:40:00 +08001966 {
1967 response.pack(bootOptionParameter, reserved1, transferStatus);
1968 return ipmi::responseSuccess(std::move(response));
1969 }
1970
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001971 if (types::enum_cast<BootOptionParameter>(bootOptionParameter) ==
1972 BootOptionParameter::bootInfo)
John Wang0213f902020-12-28 14:49:57 +08001973 {
1974 constexpr uint8_t writeMask = 0;
Hieu Huynh38ffafc2021-05-14 08:40:14 +00001975 response.pack(bootOptionParameter, reserved1, writeMask,
1976 bootInitiatorAckData);
John Wang0213f902020-12-28 14:49:57 +08001977 return ipmi::responseSuccess(std::move(response));
1978 }
1979
Chen Yugang86ac4992021-06-25 08:14:52 +08001980 if (types::enum_cast<BootOptionParameter>(bootOptionParameter) ==
1981 BootOptionParameter::bootFlagValidClr)
1982 {
1983 response.pack(bootOptionParameter, reserved1,
1984 uint5_t{bootFlagValidBitClr}, uint3_t{});
1985 return ipmi::responseSuccess(std::move(response));
1986 }
1987
shgoupfd84fbbf2015-12-17 10:05:51 +08001988 /*
1989 * Parameter #5 means boot flags. Please refer to 28.13 of ipmi doc.
1990 * This is the only parameter used by petitboot.
1991 */
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001992 if (types::enum_cast<BootOptionParameter>(bootOptionParameter) ==
1993 BootOptionParameter::bootFlags)
Patrick Venture0b02be92018-08-31 11:55:55 -07001994 {
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001995 using namespace chassis::internal;
1996 using namespace chassis::internal::cache;
shgoupfd84fbbf2015-12-17 10:05:51 +08001997
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001998 try
ratagupta6f6bff2016-04-04 06:20:11 -05001999 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002000 Source::Sources bootSource;
2001 rc = getBootSource(ctx, bootSource);
2002 if (rc != ipmi::ccSuccess)
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002003 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002004 return ipmi::response(rc);
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002005 }
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002006
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002007 Type::Types bootType;
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002008 rc = getBootType(ctx, bootType);
2009 if (rc != ipmi::ccSuccess)
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002010 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002011 return ipmi::response(rc);
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002012 }
2013
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002014 Mode::Modes bootMode;
2015 rc = getBootMode(ctx, bootMode);
2016 if (rc != ipmi::ccSuccess)
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002017 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002018 return ipmi::response(rc);
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002019 }
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002020
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002021 bootOption = sourceDbusToIpmi.at(bootSource);
2022 if ((Mode::Modes::Regular == bootMode) &&
2023 (Source::Sources::Default == bootSource))
2024 {
2025 bootOption = ipmiDefault;
2026 }
2027 else if (Source::Sources::Default == bootSource)
2028 {
2029 bootOption = modeDbusToIpmi.at(bootMode);
2030 }
ratagupta6f6bff2016-04-04 06:20:11 -05002031
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002032 IpmiValue biosBootType = typeDbusToIpmi.at(bootType);
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002033
2034 bool oneTimeEnabled;
2035 rc = getBootOneTime(ctx, oneTimeEnabled);
2036 if (rc != ipmi::ccSuccess)
2037 {
2038 return ipmi::response(rc);
2039 }
2040
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002041 uint1_t permanent = oneTimeEnabled ? 0 : 1;
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002042
2043 bool valid;
2044 rc = getBootEnable(ctx, valid);
2045 if (rc != ipmi::ccSuccess)
2046 {
2047 return ipmi::response(rc);
2048 }
2049
2050 uint1_t validFlag = valid ? 1 : 0;
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002051
2052 response.pack(bootOptionParameter, reserved1, uint5_t{},
2053 uint1_t{biosBootType}, uint1_t{permanent},
2054 uint1_t{validFlag}, uint2_t{}, uint4_t{bootOption},
Hieu Huynh1982a3f2021-09-21 03:06:45 +00002055 uint1_t{}, cmosClear, uint8_t{}, uint8_t{},
2056 uint8_t{});
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002057 return ipmi::responseSuccess(std::move(response));
ratagupta6f6bff2016-04-04 06:20:11 -05002058 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -05002059 catch (const InternalFailure& e)
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002060 {
James Feist225dec82019-11-26 16:25:06 -08002061 cache::objectsPtr.reset();
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002062 report<InternalFailure>();
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002063 return ipmi::responseUnspecifiedError();
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002064 }
Patrick Venture0b02be92018-08-31 11:55:55 -07002065 }
Patrick Venture0b02be92018-08-31 11:55:55 -07002066 else
2067 {
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002068 if ((bootOptionParameter >= oemParmStart) &&
2069 (bootOptionParameter <= oemParmEnd))
2070 {
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07002071 if (types::enum_cast<BootOptionParameter>(bootOptionParameter) ==
2072 BootOptionParameter::opalNetworkSettings)
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002073 {
2074 response.pack(bootOptionParameter, reserved1);
2075 int ret = getHostNetworkData(response);
2076 if (ret < 0)
2077 {
2078 response.trailingOk = true;
2079 log<level::ERR>(
2080 "getHostNetworkData failed for GetSysBootOptions.");
2081 return ipmi::responseUnspecifiedError();
2082 }
2083 else
2084 {
2085 return ipmi::responseSuccess(std::move(response));
2086 }
2087 }
Jayaprakash Mutyala43a88102021-08-04 16:41:58 +00002088 else
2089 {
2090 log<level::ERR>(
2091 "ipmiChassisGetSysBootOptions: Unsupported parameter",
2092 entry("PARAM=0x%x",
2093 static_cast<uint8_t>(bootOptionParameter)));
2094 return ipmi::responseParmNotSupported();
2095 }
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002096 }
2097 else
2098 {
2099 log<level::ERR>(
2100 "ipmiChassisGetSysBootOptions: Unsupported parameter",
2101 entry("PARAM=0x%x", static_cast<uint8_t>(bootOptionParameter)));
Jayaprakash Mutyala6088e9f2021-07-14 07:40:29 +00002102 return ipmi::responseParmNotSupported();
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002103 }
shgoupfd84fbbf2015-12-17 10:05:51 +08002104 }
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002105 return ipmi::responseUnspecifiedError();
shgoupfd84fbbf2015-12-17 10:05:51 +08002106}
2107
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002108ipmi::RspType<> ipmiChassisSetSysBootOptions(ipmi::Context::ptr ctx,
2109 uint7_t parameterSelector,
2110 bool parameterIsValid,
2111 ipmi::message::Payload& data)
shgoupfd84fbbf2015-12-17 10:05:51 +08002112{
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002113 using namespace boot_options;
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002114 ipmi::Cc rc;
shgoupfd84fbbf2015-12-17 10:05:51 +08002115
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07002116 if (types::enum_cast<BootOptionParameter>(parameterSelector) ==
2117 BootOptionParameter::setInProgress)
huangheab369282020-10-10 14:40:00 +08002118 {
2119 uint2_t setInProgressFlag;
2120 uint6_t rsvd;
2121 if (data.unpack(setInProgressFlag, rsvd) != 0 || !data.fullyUnpacked())
2122 {
2123 return ipmi::responseReqDataLenInvalid();
2124 }
2125 if (rsvd)
2126 {
2127 return ipmi::responseInvalidFieldRequest();
2128 }
2129 if ((transferStatus == setInProgress) &&
2130 (static_cast<uint8_t>(setInProgressFlag) != setComplete))
2131 {
2132 return ipmi::response(IPMI_CC_FAIL_SET_IN_PROGRESS);
2133 }
2134 transferStatus = static_cast<uint8_t>(setInProgressFlag);
2135 return ipmi::responseSuccess();
2136 }
2137
shgoupfd84fbbf2015-12-17 10:05:51 +08002138 /* 000101
2139 * Parameter #5 means boot flags. Please refer to 28.13 of ipmi doc.
2140 * This is the only parameter used by petitboot.
2141 */
Ratan Guptafd28dd72016-08-01 04:58:01 -05002142
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07002143 if (types::enum_cast<BootOptionParameter>(parameterSelector) ==
2144 BootOptionParameter::bootFlags)
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002145 {
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002146 uint5_t rsvd;
2147 bool validFlag;
2148 bool permanent;
2149 bool biosBootType;
2150 bool lockOutResetButton;
2151 bool screenBlank;
2152 uint4_t bootDeviceSelector;
2153 bool lockKeyboard;
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002154 uint8_t data3;
2155 uint4_t biosInfo;
2156 uint4_t rsvd1;
2157 uint5_t deviceInstance;
2158 uint3_t rsvd2;
2159
2160 if (data.unpack(rsvd, biosBootType, permanent, validFlag,
2161 lockOutResetButton, screenBlank, bootDeviceSelector,
2162 lockKeyboard, cmosClear, data3, biosInfo, rsvd1,
2163 deviceInstance, rsvd2) != 0 ||
2164 !data.fullyUnpacked())
2165 {
2166 return ipmi::responseReqDataLenInvalid();
2167 }
2168 if (rsvd || rsvd1 || rsvd2)
2169 {
2170 return ipmi::responseInvalidFieldRequest();
2171 }
2172
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002173 using namespace chassis::internal;
2174 using namespace chassis::internal::cache;
shgoupfd84fbbf2015-12-17 10:05:51 +08002175
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002176 try
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002177 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002178 rc = setBootOneTime(ctx, !permanent);
2179 if (rc != ipmi::ccSuccess)
Konstantin Aladyshev69e8e842021-06-18 17:01:18 +03002180 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002181 return ipmi::response(rc);
2182 }
Vernon Maueryafd45db2021-07-29 16:27:25 +00002183
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002184 rc = setBootEnable(ctx, validFlag);
2185 if (rc != ipmi::ccSuccess)
2186 {
2187 return ipmi::response(rc);
Tom Joseph57e8eb72017-09-25 18:05:02 +05302188 }
2189
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002190 auto modeItr =
2191 modeIpmiToDbus.find(static_cast<uint8_t>(bootDeviceSelector));
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002192 auto typeItr =
2193 typeIpmiToDbus.find(static_cast<uint8_t>(biosBootType));
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002194 auto sourceItr =
2195 sourceIpmiToDbus.find(static_cast<uint8_t>(bootDeviceSelector));
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002196 if (sourceIpmiToDbus.end() != sourceItr)
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002197 {
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03002198 rc = setBootSource(ctx, sourceItr->second);
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002199 if (rc != ipmi::ccSuccess)
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002200 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002201 return ipmi::response(rc);
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002202 }
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002203 // If a set boot device is mapping to a boot source, then reset
2204 // the boot mode D-Bus property to default.
2205 // This way the ipmid code can determine which property is not
2206 // at the default value
Patrick Venture0b02be92018-08-31 11:55:55 -07002207 if (sourceItr->second != Source::Sources::Default)
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002208 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002209 rc = setBootMode(ctx, Mode::Modes::Regular);
2210 if (rc != ipmi::ccSuccess)
2211 {
2212 return ipmi::response(rc);
2213 }
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002214 }
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002215 }
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002216
2217 if (typeIpmiToDbus.end() != typeItr)
2218 {
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03002219 rc = setBootType(ctx, typeItr->second);
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002220 if (rc != ipmi::ccSuccess)
2221 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002222 return ipmi::response(rc);
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002223 }
2224 }
2225
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002226 if (modeIpmiToDbus.end() != modeItr)
2227 {
Konstantin Aladysheve76a61a2021-03-18 22:19:13 +03002228 rc = setBootMode(ctx, modeItr->second);
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002229 if (rc != ipmi::ccSuccess)
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002230 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002231 return ipmi::response(rc);
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002232 }
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002233 // If a set boot device is mapping to a boot mode, then reset
2234 // the boot source D-Bus property to default.
2235 // This way the ipmid code can determine which property is not
2236 // at the default value
Patrick Venture0b02be92018-08-31 11:55:55 -07002237 if (modeItr->second != Mode::Modes::Regular)
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002238 {
Konstantin Aladyshev08a080a2021-06-18 17:01:18 +03002239 rc = setBootSource(ctx, Source::Sources::Default);
2240 if (rc != ipmi::ccSuccess)
2241 {
2242 return ipmi::response(rc);
2243 }
Marri Devender Rao54fa1302018-05-07 01:06:23 -05002244 }
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002245 }
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08002246 if ((modeIpmiToDbus.end() == modeItr) &&
Konstantin Aladyshev96ef0282021-02-09 13:57:10 +03002247 (typeIpmiToDbus.end() == typeItr) &&
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08002248 (sourceIpmiToDbus.end() == sourceItr))
2249 {
2250 // return error if boot option is not supported
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002251 log<level::ERR>(
2252 "ipmiChassisSetSysBootOptions: Boot option not supported");
2253 return ipmi::responseInvalidFieldRequest();
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08002254 }
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002255 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -05002256 catch (const sdbusplus::exception_t& e)
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05002257 {
James Feist225dec82019-11-26 16:25:06 -08002258 objectsPtr.reset();
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05002259 report<InternalFailure>();
Aditya Saripalli5fb14602017-11-09 14:46:27 +05302260 log<level::ERR>(
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002261 "ipmiChassisSetSysBootOptions: Error in setting Boot "
2262 "flag parameters");
2263 return ipmi::responseUnspecifiedError();
Ratan Guptafd28dd72016-08-01 04:58:01 -05002264 }
Patrick Venture0b02be92018-08-31 11:55:55 -07002265 }
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07002266 else if (types::enum_cast<BootOptionParameter>(parameterSelector) ==
2267 BootOptionParameter::bootInfo)
Patrick Venture0b02be92018-08-31 11:55:55 -07002268 {
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002269 uint8_t writeMak;
Hieu Huynh38ffafc2021-05-14 08:40:14 +00002270 uint5_t bootInfoAck;
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002271 uint3_t rsvd;
2272
Hieu Huynh38ffafc2021-05-14 08:40:14 +00002273 if (data.unpack(writeMak, bootInfoAck, rsvd) != 0 ||
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002274 !data.fullyUnpacked())
2275 {
2276 return ipmi::responseReqDataLenInvalid();
2277 }
2278 if (rsvd)
2279 {
2280 return ipmi::responseInvalidFieldRequest();
2281 }
Hieu Huynh38ffafc2021-05-14 08:40:14 +00002282 bootInitiatorAckData &= ~writeMak;
2283 bootInitiatorAckData |= (writeMak & bootInfoAck);
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002284 log<level::INFO>("ipmiChassisSetSysBootOptions: bootInfo parameter set "
2285 "successfully");
2286 data.trailingOk = true;
2287 return ipmi::responseSuccess();
Patrick Venture0b02be92018-08-31 11:55:55 -07002288 }
Chen Yugang86ac4992021-06-25 08:14:52 +08002289 else if (types::enum_cast<BootOptionParameter>(parameterSelector) ==
2290 BootOptionParameter::bootFlagValidClr)
2291 {
2292 uint5_t bootFlagValidClr;
2293 uint3_t rsvd;
2294
2295 if (data.unpack(bootFlagValidClr, rsvd) != 0 || !data.fullyUnpacked())
2296 {
2297 return ipmi::responseReqDataLenInvalid();
2298 }
2299 if (rsvd)
2300 {
2301 return ipmi::responseInvalidFieldRequest();
2302 }
2303 // store boot flag valid bits clear value
2304 bootFlagValidBitClr = static_cast<uint8_t>(bootFlagValidClr);
2305 log<level::INFO>(
2306 "ipmiChassisSetSysBootOptions: bootFlagValidBits parameter set "
2307 "successfully",
2308 entry("value=0x%x", bootFlagValidBitClr));
2309 return ipmi::responseSuccess();
2310 }
Patrick Venture0b02be92018-08-31 11:55:55 -07002311 else
2312 {
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002313 if ((parameterSelector >= static_cast<uint7_t>(oemParmStart)) &&
2314 (parameterSelector <= static_cast<uint7_t>(oemParmEnd)))
2315 {
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07002316 if (types::enum_cast<BootOptionParameter>(parameterSelector) ==
2317 BootOptionParameter::opalNetworkSettings)
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002318 {
2319 ipmi::Cc ret = setHostNetworkData(data);
2320 if (ret != ipmi::ccSuccess)
2321 {
2322 log<level::ERR>("ipmiChassisSetSysBootOptions: Error in "
2323 "setHostNetworkData");
2324 data.trailingOk = true;
2325 return ipmi::response(ret);
2326 }
2327 data.trailingOk = true;
2328 return ipmi::responseSuccess();
2329 }
2330 else
2331 {
2332 log<level::ERR>(
2333 "ipmiChassisSetSysBootOptions: Unsupported parameters",
2334 entry("PARAM=0x%x",
2335 static_cast<uint8_t>(parameterSelector)));
2336 data.trailingOk = true;
2337 return ipmi::responseParmNotSupported();
2338 }
2339 }
2340 data.trailingOk = true;
2341 return ipmi::responseParmNotSupported();
Adriana Kobylak40814c62015-10-27 15:58:44 -05002342 }
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002343 return ipmi::responseSuccess();
Adriana Kobylak40814c62015-10-27 15:58:44 -05002344}
2345
anil kumar appanaa5a76eb2019-04-30 14:57:24 +00002346/** @brief implements Get POH counter command
2347 * @parameter
2348 * - none
2349 * @returns IPMI completion code plus response data
2350 * - minPerCount - Minutes per count
2351 * - counterReading - counter reading
2352 */
2353ipmi::RspType<uint8_t, // Minutes per count
2354 uint32_t // Counter reading
2355 >
2356 ipmiGetPOHCounter()
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002357{
2358 // sd_bus error
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002359 try
2360 {
anil kumar appanaa5a76eb2019-04-30 14:57:24 +00002361 return ipmi::responseSuccess(static_cast<uint8_t>(poh::minutesPerCount),
2362 getPOHCounter());
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002363 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -05002364 catch (const std::exception& e)
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002365 {
2366 log<level::ERR>(e.what());
anil kumar appanaa5a76eb2019-04-30 14:57:24 +00002367 return ipmi::responseUnspecifiedError();
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002368 }
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002369}
2370
Jason M. Billsbc996a32019-06-17 15:46:37 -07002371ipmi::RspType<uint3_t, // policy support
2372 uint5_t // reserved
2373 >
Vernon Mauerye278ead2018-10-09 09:23:43 -07002374 ipmiChassisSetPowerRestorePolicy(boost::asio::yield_context yield,
Jason M. Billsbc996a32019-06-17 15:46:37 -07002375 uint3_t policy, uint5_t reserved)
Yong Lic6713cf2018-09-12 12:35:13 +08002376{
Yong Lic6713cf2018-09-12 12:35:13 +08002377 power_policy::DbusValue value =
2378 power_policy::RestorePolicy::Policy::AlwaysOff;
2379
Jason M. Billsbc996a32019-06-17 15:46:37 -07002380 if (reserved || (policy > power_policy::noChange))
Yong Lic6713cf2018-09-12 12:35:13 +08002381 {
Vernon Mauerye278ead2018-10-09 09:23:43 -07002382 phosphor::logging::log<level::ERR>(
2383 "Reserved request parameter",
2384 entry("REQ=0x%x", static_cast<int>(policy)));
Jason M. Billsbc996a32019-06-17 15:46:37 -07002385 return ipmi::responseInvalidFieldRequest();
Yong Lic6713cf2018-09-12 12:35:13 +08002386 }
2387
Vernon Mauerye278ead2018-10-09 09:23:43 -07002388 if (policy == power_policy::noChange)
Yong Lic6713cf2018-09-12 12:35:13 +08002389 {
2390 // just return the supported policy
Jason M. Billsbc996a32019-06-17 15:46:37 -07002391 return ipmi::responseSuccess(power_policy::allSupport, reserved);
Yong Lic6713cf2018-09-12 12:35:13 +08002392 }
2393
2394 for (auto const& it : power_policy::dbusToIpmi)
2395 {
Vernon Mauerye278ead2018-10-09 09:23:43 -07002396 if (it.second == policy)
Yong Lic6713cf2018-09-12 12:35:13 +08002397 {
2398 value = it.first;
2399 break;
2400 }
2401 }
2402
2403 try
2404 {
James Feist225dec82019-11-26 16:25:06 -08002405 settings::Objects& objects = chassis::internal::cache::getObjects();
Yong Lic6713cf2018-09-12 12:35:13 +08002406 const settings::Path& powerRestoreSetting =
James Feist225dec82019-11-26 16:25:06 -08002407 objects.map.at(chassis::internal::powerRestoreIntf).front();
Vernon Mauery16b86932019-05-01 08:36:11 -07002408 std::variant<std::string> property = convertForMessage(value);
Yong Lic6713cf2018-09-12 12:35:13 +08002409
Vernon Mauerye278ead2018-10-09 09:23:43 -07002410 auto sdbusp = getSdBus();
2411 boost::system::error_code ec;
2412 sdbusp->yield_method_call<void>(
2413 yield, ec,
James Feist225dec82019-11-26 16:25:06 -08002414 objects
Yong Lic6713cf2018-09-12 12:35:13 +08002415 .service(powerRestoreSetting,
2416 chassis::internal::powerRestoreIntf)
2417 .c_str(),
Vernon Mauerye278ead2018-10-09 09:23:43 -07002418 powerRestoreSetting, ipmi::PROP_INTF, "Set",
2419 chassis::internal::powerRestoreIntf, "PowerRestorePolicy",
2420 property);
2421 if (ec)
Yong Lic6713cf2018-09-12 12:35:13 +08002422 {
2423 phosphor::logging::log<level::ERR>("Unspecified Error");
Vernon Mauerye278ead2018-10-09 09:23:43 -07002424 return ipmi::responseUnspecifiedError();
Yong Lic6713cf2018-09-12 12:35:13 +08002425 }
2426 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -05002427 catch (const InternalFailure& e)
Yong Lic6713cf2018-09-12 12:35:13 +08002428 {
James Feist225dec82019-11-26 16:25:06 -08002429 chassis::internal::cache::objectsPtr.reset();
Yong Lic6713cf2018-09-12 12:35:13 +08002430 report<InternalFailure>();
Vernon Mauerye278ead2018-10-09 09:23:43 -07002431 return ipmi::responseUnspecifiedError();
Yong Lic6713cf2018-09-12 12:35:13 +08002432 }
2433
Jason M. Billsbc996a32019-06-17 15:46:37 -07002434 return ipmi::responseSuccess(power_policy::allSupport, reserved);
Yong Lic6713cf2018-09-12 12:35:13 +08002435}
2436
Kuiying Wang21addc52019-01-04 10:50:21 +08002437ipmi::RspType<> ipmiSetFrontPanelButtonEnables(
2438 ipmi::Context::ptr ctx, bool disablePowerButton, bool disableResetButton,
2439 bool disableDiagButton, bool disableSleepButton, uint4_t reserved)
2440{
2441 using namespace chassis::internal;
2442
2443 // set power button Enabled property
2444 bool success = setButtonEnabled(ctx, powerButtonPath, powerButtonIntf,
2445 !disablePowerButton);
2446
2447 // set reset button Enabled property
2448 success &= setButtonEnabled(ctx, resetButtonPath, resetButtonIntf,
2449 !disableResetButton);
2450
2451 if (!success)
2452 {
2453 // not all buttons were successfully set
2454 return ipmi::responseUnspecifiedError();
2455 }
2456 return ipmi::responseSuccess();
2457}
2458
Adriana Kobylak40814c62015-10-27 15:58:44 -05002459void register_netfn_chassis_functions()
2460{
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05002461 createIdentifyTimer();
2462
Tom05732372016-09-06 17:21:23 +05302463 // Get Chassis Capabilities
anil kumar appana43263c62019-05-27 12:45:04 +00002464 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2465 ipmi::chassis::cmdGetChassisCapabilities,
2466 ipmi::Privilege::User, ipmiGetChassisCap);
Nan Li8d15fb42016-08-16 22:29:40 +08002467
Kuiying Wang21addc52019-01-04 10:50:21 +08002468 // Set Front Panel Button Enables
2469 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2470 ipmi::chassis::cmdSetFrontPanelButtonEnables,
2471 ipmi::Privilege::Admin,
2472 ipmiSetFrontPanelButtonEnables);
2473
Yong Liae4b0402018-11-02 11:12:14 +08002474 // Set Chassis Capabilities
anil kumar appana894d0222019-05-27 16:32:14 +00002475 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2476 ipmi::chassis::cmdSetChassisCapabilities,
2477 ipmi::Privilege::User, ipmiSetChassisCap);
Yong Liae4b0402018-11-02 11:12:14 +08002478
Tom05732372016-09-06 17:21:23 +05302479 // <Get System Boot Options>
Jayaprakash Mutyalad1ef8772020-08-25 10:32:58 +00002480 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2481 ipmi::chassis::cmdGetSystemBootOptions,
2482 ipmi::Privilege::Operator,
2483 ipmiChassisGetSysBootOptions);
Adriana Kobylak40814c62015-10-27 15:58:44 -05002484
Tom05732372016-09-06 17:21:23 +05302485 // <Get Chassis Status>
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07002486 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2487 ipmi::chassis::cmdGetChassisStatus,
2488 ipmi::Privilege::User, ipmiGetChassisStatus);
Nan Lifdd8ec52016-08-28 03:57:40 +08002489
Vijay Khemka074f64d2020-03-03 15:08:43 -08002490 // <Chassis Get System Restart Cause>
2491 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2492 ipmi::chassis::cmdGetSystemRestartCause,
2493 ipmi::Privilege::User, ipmiGetSystemRestartCause);
2494
Tom05732372016-09-06 17:21:23 +05302495 // <Chassis Control>
anil kumar appanadafff5f2019-04-27 18:06:00 +00002496 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2497 ipmi::chassis::cmdChassisControl,
2498 ipmi::Privilege::Operator, ipmiChassisControl);
shgoupfd84fbbf2015-12-17 10:05:51 +08002499
Tom Joseph5110c122018-03-23 17:55:40 +05302500 // <Chassis Identify>
Vernon Mauery400cc782018-10-09 13:49:53 -07002501 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2502 ipmi::chassis::cmdChassisIdentify,
2503 ipmi::Privilege::Operator, ipmiChassisIdentify);
Tom Joseph5110c122018-03-23 17:55:40 +05302504
Tom05732372016-09-06 17:21:23 +05302505 // <Set System Boot Options>
jayaprakash Mutyalabfd8fc42020-05-05 22:38:03 +00002506 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2507 ipmi::chassis::cmdSetSystemBootOptions,
2508 ipmi::Privilege::Operator,
2509 ipmiChassisSetSysBootOptions);
2510
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05002511 // <Get POH Counter>
anil kumar appanaa5a76eb2019-04-30 14:57:24 +00002512 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2513 ipmi::chassis::cmdGetPohCounter,
2514 ipmi::Privilege::User, ipmiGetPOHCounter);
Yong Lic6713cf2018-09-12 12:35:13 +08002515
2516 // <Set Power Restore Policy>
Vernon Mauerye278ead2018-10-09 09:23:43 -07002517 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
2518 ipmi::chassis::cmdSetPowerRestorePolicy,
2519 ipmi::Privilege::Operator,
2520 ipmiChassisSetPowerRestorePolicy);
vishwa36993272015-11-20 12:43:49 -06002521}