blob: 0f2d10cf3e1ae32cb0dd02d13648f8213ede0046 [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>
33#include <xyz/openbmc_project/Control/Power/RestorePolicy/server.hpp>
34#include <xyz/openbmc_project/State/Host/server.hpp>
35#include <xyz/openbmc_project/State/PowerOnHours/server.hpp>
36
Patrick Venture0b02be92018-08-31 11:55:55 -070037// Defines
38#define SET_PARM_VERSION 0x01
Vernon Mauery1181af72018-10-08 12:05:00 -070039#define SET_PARM_BOOT_FLAGS_PERMANENT 0x40
40#define SET_PARM_BOOT_FLAGS_VALID_ONE_TIME 0x80
41#define SET_PARM_BOOT_FLAGS_VALID_PERMANENT 0xC0
ratagupta6f6bff2016-04-04 06:20:11 -050042
Lei YU4b0ddb62019-01-25 16:43:50 +080043std::unique_ptr<phosphor::Timer> identifyTimer
44 __attribute__((init_priority(101)));
Marri Devender Rao6706c1c2018-05-14 00:29:38 -050045
Yong Lif4e38512019-05-21 14:46:55 +080046static ChassisIDState chassisIDState = ChassisIDState::reserved;
47
Patrick Venture0b02be92018-08-31 11:55:55 -070048constexpr size_t SIZE_MAC = 18;
49constexpr size_t SIZE_BOOT_OPTION = (uint8_t)
50 BootOptionResponseSize::OPAL_NETWORK_SETTINGS; // Maximum size of the boot
51 // option parametrs
Ratan Guptafd28dd72016-08-01 04:58:01 -050052constexpr size_t SIZE_PREFIX = 7;
53constexpr size_t MAX_PREFIX_VALUE = 32;
54constexpr size_t SIZE_COOKIE = 4;
55constexpr size_t SIZE_VERSION = 2;
Tom Joseph5110c122018-03-23 17:55:40 +053056constexpr size_t DEFAULT_IDENTIFY_TIME_OUT = 15;
Ratan Gupta6ec7daa2017-07-15 14:13:01 +053057
Patrick Venture0b02be92018-08-31 11:55:55 -070058// PetiBoot-Specific
Ratan Gupta6ec7daa2017-07-15 14:13:01 +053059static constexpr uint8_t net_conf_initial_bytes[] = {0x80, 0x21, 0x70, 0x62,
Patrick Venture0b02be92018-08-31 11:55:55 -070060 0x21, 0x00, 0x01, 0x06};
Ratan Guptafd28dd72016-08-01 04:58:01 -050061
62static constexpr size_t COOKIE_OFFSET = 1;
63static constexpr size_t VERSION_OFFSET = 5;
Ratan Gupta6ec7daa2017-07-15 14:13:01 +053064static constexpr size_t ADDR_SIZE_OFFSET = 8;
Ratan Guptafd28dd72016-08-01 04:58:01 -050065static constexpr size_t MAC_OFFSET = 9;
66static constexpr size_t ADDRTYPE_OFFSET = 16;
67static constexpr size_t IPADDR_OFFSET = 17;
ratagupta6f6bff2016-04-04 06:20:11 -050068
Marri Devender Rao6706c1c2018-05-14 00:29:38 -050069static constexpr size_t encIdentifyObjectsSize = 1;
70static constexpr size_t chassisIdentifyReqLength = 2;
71static constexpr size_t identifyIntervalPos = 0;
72static constexpr size_t forceIdentifyPos = 1;
shgoupfd84fbbf2015-12-17 10:05:51 +080073
Adriana Kobylak40814c62015-10-27 15:58:44 -050074void register_netfn_chassis_functions() __attribute__((constructor));
75
shgoupfd84fbbf2015-12-17 10:05:51 +080076// Host settings in dbus
77// Service name should be referenced by connection name got via object mapper
Patrick Venture0b02be92018-08-31 11:55:55 -070078const char* settings_object_name = "/org/openbmc/settings/host0";
79const char* settings_intf_name = "org.freedesktop.DBus.Properties";
Patrick Venture0b02be92018-08-31 11:55:55 -070080const char* identify_led_object_name =
Tom Joseph5110c122018-03-23 17:55:40 +053081 "/xyz/openbmc_project/led/groups/enclosure_identify";
shgoupfd84fbbf2015-12-17 10:05:51 +080082
Ratan Guptadcb10672017-07-10 10:33:50 +053083constexpr auto SETTINGS_ROOT = "/";
84constexpr auto SETTINGS_MATCH = "host0";
Ratan Guptadcb10672017-07-10 10:33:50 +053085
86constexpr auto IP_INTERFACE = "xyz.openbmc_project.Network.IP";
87constexpr auto MAC_INTERFACE = "xyz.openbmc_project.Network.MACAddress";
88
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -050089static constexpr auto chassisStateRoot = "/xyz/openbmc_project/state";
90static constexpr auto chassisPOHStateIntf =
Patrick Venture0b02be92018-08-31 11:55:55 -070091 "xyz.openbmc_project.State.PowerOnHours";
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -050092static constexpr auto pOHCounterProperty = "POHCounter";
93static constexpr auto match = "chassis0";
Yong Liae4b0402018-11-02 11:12:14 +080094const static constexpr char chassisCapIntf[] =
95 "xyz.openbmc_project.Control.ChassisCapabilities";
96const static constexpr char chassisCapFlagsProp[] = "CapabilitiesFlags";
97const static constexpr char chassisFRUDevAddrProp[] = "FRUDeviceAddress";
98const static constexpr char chassisSDRDevAddrProp[] = "SDRDeviceAddress";
99const static constexpr char chassisSELDevAddrProp[] = "SELDeviceAddress";
100const static constexpr char chassisSMDevAddrProp[] = "SMDeviceAddress";
101const static constexpr char chassisBridgeDevAddrProp[] = "BridgeDeviceAddress";
102static constexpr uint8_t chassisCapFlagMask = 0x0f;
103static constexpr uint8_t chassisCapAddrMask = 0xfe;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700104static constexpr const char* powerButtonIntf =
105 "xyz.openbmc_project.Chassis.Buttons.Power";
106static constexpr const char* powerButtonPath =
107 "/xyz/openbmc_project/Chassis/Buttons/Power0";
108static constexpr const char* resetButtonIntf =
109 "xyz.openbmc_project.Chassis.Buttons.Reset";
110static constexpr const char* resetButtonPath =
111 "/xyz/openbmc_project/Chassis/Buttons/Reset0";
Ratan Guptadcb10672017-07-10 10:33:50 +0530112
Nan Li8d15fb42016-08-16 22:29:40 +0800113typedef struct
114{
115 uint8_t cap_flags;
116 uint8_t fru_info_dev_addr;
117 uint8_t sdr_dev_addr;
118 uint8_t sel_dev_addr;
119 uint8_t system_management_dev_addr;
120 uint8_t bridge_dev_addr;
Patrick Venture0b02be92018-08-31 11:55:55 -0700121} __attribute__((packed)) ipmi_chassis_cap_t;
Nan Li8d15fb42016-08-16 22:29:40 +0800122
Nan Lifdd8ec52016-08-28 03:57:40 +0800123typedef struct
124{
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500125 uint8_t cur_power_state;
126 uint8_t last_power_event;
127 uint8_t misc_power_state;
128 uint8_t front_panel_button_cap_status;
Patrick Venture0b02be92018-08-31 11:55:55 -0700129} __attribute__((packed)) ipmi_get_chassis_status_t;
Nan Lifdd8ec52016-08-28 03:57:40 +0800130
Vishwanatha Subbannab12b0c02017-03-07 18:17:19 +0530131// Phosphor Host State manager
132namespace State = sdbusplus::xyz::openbmc_project::State::server;
133
Vernon Mauery185b9f82018-07-20 10:52:36 -0700134namespace fs = std::filesystem;
Andrew Geisslera6e3a302017-05-31 19:34:00 -0500135
Ratan Guptadcb10672017-07-10 10:33:50 +0530136using namespace phosphor::logging;
137using namespace sdbusplus::xyz::openbmc_project::Common::Error;
Marri Devender Rao81719702018-05-07 00:53:48 -0500138using namespace sdbusplus::xyz::openbmc_project::Control::Boot::server;
William A. Kennington III4c008022018-10-12 17:18:14 -0700139
Deepak Kodihalli8cc19362017-07-21 11:18:38 -0500140namespace chassis
141{
142namespace internal
143{
144
145constexpr auto bootModeIntf = "xyz.openbmc_project.Control.Boot.Mode";
146constexpr auto bootSourceIntf = "xyz.openbmc_project.Control.Boot.Source";
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500147constexpr auto powerRestoreIntf =
148 "xyz.openbmc_project.Control.Power.RestorePolicy";
Deepak Kodihalli8cc19362017-07-21 11:18:38 -0500149sdbusplus::bus::bus dbus(ipmid_get_sd_bus_connection());
150
151namespace cache
152{
153
154settings::Objects objects(dbus,
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500155 {bootModeIntf, bootSourceIntf, powerRestoreIntf});
Deepak Kodihalli8cc19362017-07-21 11:18:38 -0500156
157} // namespace cache
158} // namespace internal
159} // namespace chassis
160
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500161namespace poh
162{
163
164constexpr auto minutesPerCount = 60;
165
166} // namespace poh
167
Patrick Venture0b02be92018-08-31 11:55:55 -0700168struct get_sys_boot_options_t
169{
Adriana Kobylak40814c62015-10-27 15:58:44 -0500170 uint8_t parameter;
171 uint8_t set;
172 uint8_t block;
Patrick Venture0b02be92018-08-31 11:55:55 -0700173} __attribute__((packed));
Adriana Kobylak40814c62015-10-27 15:58:44 -0500174
Patrick Venture0b02be92018-08-31 11:55:55 -0700175struct get_sys_boot_options_response_t
176{
shgoupfd84fbbf2015-12-17 10:05:51 +0800177 uint8_t version;
178 uint8_t parm;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500179 uint8_t data[SIZE_BOOT_OPTION];
Patrick Venture0b02be92018-08-31 11:55:55 -0700180} __attribute__((packed));
shgoupfd84fbbf2015-12-17 10:05:51 +0800181
Patrick Venture0b02be92018-08-31 11:55:55 -0700182struct set_sys_boot_options_t
183{
shgoupfd84fbbf2015-12-17 10:05:51 +0800184 uint8_t parameter;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500185 uint8_t data[SIZE_BOOT_OPTION];
Patrick Venture0b02be92018-08-31 11:55:55 -0700186} __attribute__((packed));
Ratan Guptafd28dd72016-08-01 04:58:01 -0500187
Ratan Guptadcb10672017-07-10 10:33:50 +0530188int getHostNetworkData(get_sys_boot_options_response_t* respptr)
Ratan Guptafd28dd72016-08-01 04:58:01 -0500189{
Ratan Guptadcb10672017-07-10 10:33:50 +0530190 ipmi::PropertyMap properties;
191 int rc = 0;
Ratan Gupta8c31d232017-08-13 05:49:43 +0530192 uint8_t addrSize = ipmi::network::IPV4_ADDRESS_SIZE_BYTE;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500193
Ratan Guptadcb10672017-07-10 10:33:50 +0530194 try
195 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700196 // TODO There may be cases where an interface is implemented by multiple
Ratan Guptadcb10672017-07-10 10:33:50 +0530197 // objects,to handle such cases we are interested on that object
198 // which are on interested busname.
199 // Currenlty mapper doesn't give the readable busname(gives busid)
200 // so we can't match with bus name so giving some object specific info
201 // as SETTINGS_MATCH.
202 // Later SETTINGS_MATCH will be replaced with busname.
Ratan Guptafd28dd72016-08-01 04:58:01 -0500203
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530204 sdbusplus::bus::bus bus(ipmid_get_sd_bus_connection());
Ratan Guptadcb10672017-07-10 10:33:50 +0530205
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530206 auto ipObjectInfo = ipmi::getDbusObject(bus, IP_INTERFACE,
207 SETTINGS_ROOT, SETTINGS_MATCH);
208
209 auto macObjectInfo = ipmi::getDbusObject(bus, MAC_INTERFACE,
210 SETTINGS_ROOT, SETTINGS_MATCH);
211
Patrick Venture0b02be92018-08-31 11:55:55 -0700212 properties = ipmi::getAllDbusProperties(
213 bus, ipObjectInfo.second, ipObjectInfo.first, IP_INTERFACE);
214 auto variant = ipmi::getDbusProperty(bus, macObjectInfo.second,
215 macObjectInfo.first, MAC_INTERFACE,
216 "MACAddress");
Ratan Guptadcb10672017-07-10 10:33:50 +0530217
Vernon Maueryf442e112019-04-09 11:44:36 -0700218 auto ipAddress = std::get<std::string>(properties["Address"]);
Ratan Guptad70f4532017-08-04 02:07:31 +0530219
Vernon Maueryf442e112019-04-09 11:44:36 -0700220 auto gateway = std::get<std::string>(properties["Gateway"]);
Ratan Guptad70f4532017-08-04 02:07:31 +0530221
Vernon Maueryf442e112019-04-09 11:44:36 -0700222 auto prefix = std::get<uint8_t>(properties["PrefixLength"]);
Ratan Guptad70f4532017-08-04 02:07:31 +0530223
Patrick Venture0b02be92018-08-31 11:55:55 -0700224 uint8_t isStatic =
Vernon Maueryf442e112019-04-09 11:44:36 -0700225 (std::get<std::string>(properties["Origin"]) ==
Patrick Venture0b02be92018-08-31 11:55:55 -0700226 "xyz.openbmc_project.Network.IP.AddressOrigin.Static")
227 ? 1
228 : 0;
Ratan Guptad70f4532017-08-04 02:07:31 +0530229
Vernon Maueryf442e112019-04-09 11:44:36 -0700230 auto MACAddress = std::get<std::string>(variant);
Ratan Guptacc8feb42017-07-25 21:52:10 +0530231
Ratan Guptad70f4532017-08-04 02:07:31 +0530232 // it is expected here that we should get the valid data
233 // but we may also get the default values.
234 // Validation of the data is done by settings.
235 //
236 // if mac address is default mac address then
237 // don't send blank override.
Ratan Gupta8c31d232017-08-13 05:49:43 +0530238 if ((MACAddress == ipmi::network::DEFAULT_MAC_ADDRESS))
Ratan Guptad70f4532017-08-04 02:07:31 +0530239 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700240 std::memset(respptr->data, 0, SIZE_BOOT_OPTION);
Ratan Guptad70f4532017-08-04 02:07:31 +0530241 rc = -1;
242 return rc;
243 }
244 // if addr is static then ipaddress,gateway,prefix
245 // should not be default one,don't send blank override.
246 if (isStatic)
247 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700248 if ((ipAddress == ipmi::network::DEFAULT_ADDRESS) ||
249 (gateway == ipmi::network::DEFAULT_ADDRESS) || (!prefix))
Ratan Guptad70f4532017-08-04 02:07:31 +0530250 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700251 std::memset(respptr->data, 0, SIZE_BOOT_OPTION);
Ratan Guptad70f4532017-08-04 02:07:31 +0530252 rc = -1;
253 return rc;
254 }
255 }
256
Patrick Venture0b02be92018-08-31 11:55:55 -0700257 sscanf(
258 MACAddress.c_str(), ipmi::network::MAC_ADDRESS_FORMAT,
259 (respptr->data + MAC_OFFSET), (respptr->data + MAC_OFFSET + 1),
260 (respptr->data + MAC_OFFSET + 2), (respptr->data + MAC_OFFSET + 3),
261 (respptr->data + MAC_OFFSET + 4), (respptr->data + MAC_OFFSET + 5));
Ratan Guptadcb10672017-07-10 10:33:50 +0530262
Ratan Guptadcb10672017-07-10 10:33:50 +0530263 respptr->data[MAC_OFFSET + 6] = 0x00;
264
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700265 std::memcpy(respptr->data + ADDRTYPE_OFFSET, &isStatic,
266 sizeof(isStatic));
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530267
Vernon Maueryf442e112019-04-09 11:44:36 -0700268 uint8_t addressFamily = (std::get<std::string>(properties["Type"]) ==
269 "xyz.openbmc_project.Network.IP.Protocol.IPv4")
270 ? AF_INET
271 : AF_INET6;
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530272
Patrick Venture0b02be92018-08-31 11:55:55 -0700273 addrSize = (addressFamily == AF_INET)
274 ? ipmi::network::IPV4_ADDRESS_SIZE_BYTE
275 : ipmi::network::IPV6_ADDRESS_SIZE_BYTE;
Ratan Guptadcb10672017-07-10 10:33:50 +0530276
277 // ipaddress and gateway would be in IPv4 format
Ratan Guptad70f4532017-08-04 02:07:31 +0530278 inet_pton(addressFamily, ipAddress.c_str(),
Patrick Venture0b02be92018-08-31 11:55:55 -0700279 (respptr->data + IPADDR_OFFSET));
Ratan Guptadcb10672017-07-10 10:33:50 +0530280
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530281 uint8_t prefixOffset = IPADDR_OFFSET + addrSize;
282
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700283 std::memcpy(respptr->data + prefixOffset, &prefix, sizeof(prefix));
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530284
285 uint8_t gatewayOffset = prefixOffset + sizeof(decltype(prefix));
286
Ratan Guptad70f4532017-08-04 02:07:31 +0530287 inet_pton(addressFamily, gateway.c_str(),
Patrick Venture0b02be92018-08-31 11:55:55 -0700288 (respptr->data + gatewayOffset));
Ratan Guptadcb10672017-07-10 10:33:50 +0530289 }
290 catch (InternalFailure& e)
291 {
292 commit<InternalFailure>();
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700293 std::memset(respptr->data, 0, SIZE_BOOT_OPTION);
Ratan Guptadcb10672017-07-10 10:33:50 +0530294 rc = -1;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500295 return rc;
296 }
297
Patrick Venture0b02be92018-08-31 11:55:55 -0700298 // PetiBoot-Specific
299 // If success then copy the first 9 bytes to the data
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700300 std::memcpy(respptr->data, net_conf_initial_bytes,
301 sizeof(net_conf_initial_bytes));
Ratan Guptafd28dd72016-08-01 04:58:01 -0500302
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700303 std::memcpy(respptr->data + ADDR_SIZE_OFFSET, &addrSize, sizeof(addrSize));
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530304
Ratan Guptafd28dd72016-08-01 04:58:01 -0500305#ifdef _IPMI_DEBUG_
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700306 std::printf("\n===Printing the IPMI Formatted Data========\n");
Ratan Guptafd28dd72016-08-01 04:58:01 -0500307
Ratan Guptadcb10672017-07-10 10:33:50 +0530308 for (uint8_t pos = 0; pos < index; pos++)
309 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700310 std::printf("%02x ", respptr->data[pos]);
Ratan Guptadcb10672017-07-10 10:33:50 +0530311 }
Ratan Guptafd28dd72016-08-01 04:58:01 -0500312#endif
313
Ratan Guptafd28dd72016-08-01 04:58:01 -0500314 return rc;
315}
316
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530317/** @brief convert IPv4 and IPv6 addresses from binary to text form.
318 * @param[in] family - IPv4/Ipv6
319 * @param[in] data - req data pointer.
320 * @param[in] offset - offset in the data.
321 * @param[in] addrSize - size of the data which needs to be read from offset.
322 * @returns address in text form.
323 */
324
Patrick Venture0b02be92018-08-31 11:55:55 -0700325std::string getAddrStr(uint8_t family, uint8_t* data, uint8_t offset,
326 uint8_t addrSize)
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530327{
328 char ipAddr[INET6_ADDRSTRLEN] = {};
329
Patrick Venture0b02be92018-08-31 11:55:55 -0700330 switch (family)
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530331 {
332 case AF_INET:
333 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700334 struct sockaddr_in addr4
335 {
336 };
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700337 std::memcpy(&addr4.sin_addr.s_addr, &data[offset], addrSize);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530338
Patrick Venture0b02be92018-08-31 11:55:55 -0700339 inet_ntop(AF_INET, &addr4.sin_addr, ipAddr, INET_ADDRSTRLEN);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530340
341 break;
342 }
343 case AF_INET6:
344 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700345 struct sockaddr_in6 addr6
346 {
347 };
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700348 std::memcpy(&addr6.sin6_addr.s6_addr, &data[offset], addrSize);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530349
Patrick Venture0b02be92018-08-31 11:55:55 -0700350 inet_ntop(AF_INET6, &addr6.sin6_addr, ipAddr, INET6_ADDRSTRLEN);
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530351
352 break;
353 }
354 default:
355 {
356 return {};
357 }
358 }
359
360 return ipAddr;
361}
362
Ratan Guptadcb10672017-07-10 10:33:50 +0530363int setHostNetworkData(set_sys_boot_options_t* reqptr)
Ratan Guptafd28dd72016-08-01 04:58:01 -0500364{
Ratan Guptadcb10672017-07-10 10:33:50 +0530365 using namespace std::string_literals;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500366 std::string host_network_config;
Patrick Venture0b02be92018-08-31 11:55:55 -0700367 char mac[]{"00:00:00:00:00:00"};
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530368 std::string ipAddress, gateway;
Patrick Venture0b02be92018-08-31 11:55:55 -0700369 char addrOrigin{0};
370 uint8_t addrSize{0};
Ratan Guptadcb10672017-07-10 10:33:50 +0530371 std::string addressOrigin =
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530372 "xyz.openbmc_project.Network.IP.AddressOrigin.DHCP";
Patrick Venture0b02be92018-08-31 11:55:55 -0700373 std::string addressType = "xyz.openbmc_project.Network.IP.Protocol.IPv4";
374 uint8_t prefix{0};
Ratan Guptadcb10672017-07-10 10:33:50 +0530375 uint32_t zeroCookie = 0;
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530376 uint8_t family = AF_INET;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500377
Patrick Venture0b02be92018-08-31 11:55:55 -0700378 // cookie starts from second byte
Ratan Guptafd28dd72016-08-01 04:58:01 -0500379 // version starts from sixth byte
380
Ratan Guptadcb10672017-07-10 10:33:50 +0530381 try
Ratan Guptafd28dd72016-08-01 04:58:01 -0500382 {
Ratan Guptadcb10672017-07-10 10:33:50 +0530383 do
384 {
385 // cookie == 0x21 0x70 0x62 0x21
386 if (memcmp(&(reqptr->data[COOKIE_OFFSET]),
Patrick Venture0b02be92018-08-31 11:55:55 -0700387 (net_conf_initial_bytes + COOKIE_OFFSET),
388 SIZE_COOKIE) != 0)
Ratan Guptadcb10672017-07-10 10:33:50 +0530389 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700390 // cookie == 0
391 if (memcmp(&(reqptr->data[COOKIE_OFFSET]), &zeroCookie,
392 SIZE_COOKIE) == 0)
Ratan Guptadcb10672017-07-10 10:33:50 +0530393 {
394 // need to zero out the network settings.
395 break;
396 }
397
398 log<level::ERR>("Invalid Cookie");
399 elog<InternalFailure>();
400 }
401
402 // vesion == 0x00 0x01
403 if (memcmp(&(reqptr->data[VERSION_OFFSET]),
Patrick Venture0b02be92018-08-31 11:55:55 -0700404 (net_conf_initial_bytes + VERSION_OFFSET),
405 SIZE_VERSION) != 0)
Ratan Guptadcb10672017-07-10 10:33:50 +0530406 {
407
408 log<level::ERR>("Invalid Version");
409 elog<InternalFailure>();
410 }
411
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700412 std::snprintf(
413 mac, SIZE_MAC, ipmi::network::MAC_ADDRESS_FORMAT,
414 reqptr->data[MAC_OFFSET], reqptr->data[MAC_OFFSET + 1],
415 reqptr->data[MAC_OFFSET + 2], reqptr->data[MAC_OFFSET + 3],
416 reqptr->data[MAC_OFFSET + 4], reqptr->data[MAC_OFFSET + 5]);
Ratan Guptadcb10672017-07-10 10:33:50 +0530417
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700418 std::memcpy(&addrOrigin, &(reqptr->data[ADDRTYPE_OFFSET]),
419 sizeof(decltype(addrOrigin)));
Ratan Guptadcb10672017-07-10 10:33:50 +0530420
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530421 if (addrOrigin)
Ratan Guptadcb10672017-07-10 10:33:50 +0530422 {
423 addressOrigin =
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530424 "xyz.openbmc_project.Network.IP.AddressOrigin.Static";
Ratan Guptadcb10672017-07-10 10:33:50 +0530425 }
426
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530427 // Get the address size
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700428 std::memcpy(&addrSize, &reqptr->data[ADDR_SIZE_OFFSET],
429 sizeof(addrSize));
Ratan Guptadcb10672017-07-10 10:33:50 +0530430
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530431 uint8_t prefixOffset = IPADDR_OFFSET + addrSize;
Ratan Guptadcb10672017-07-10 10:33:50 +0530432
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700433 std::memcpy(&prefix, &(reqptr->data[prefixOffset]),
434 sizeof(decltype(prefix)));
Ratan Guptadcb10672017-07-10 10:33:50 +0530435
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530436 uint8_t gatewayOffset = prefixOffset + sizeof(decltype(prefix));
437
Ratan Gupta8c31d232017-08-13 05:49:43 +0530438 if (addrSize != ipmi::network::IPV4_ADDRESS_SIZE_BYTE)
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530439 {
440 addressType = "xyz.openbmc_project.Network.IP.Protocol.IPv6";
441 family = AF_INET6;
442 }
443
Patrick Venture0b02be92018-08-31 11:55:55 -0700444 ipAddress =
445 getAddrStr(family, reqptr->data, IPADDR_OFFSET, addrSize);
Ratan Guptad70f4532017-08-04 02:07:31 +0530446
Ratan Gupta6ec7daa2017-07-15 14:13:01 +0530447 gateway = getAddrStr(family, reqptr->data, gatewayOffset, addrSize);
448
Patrick Venture0b02be92018-08-31 11:55:55 -0700449 } while (0);
Ratan Guptadcb10672017-07-10 10:33:50 +0530450
Patrick Venture0b02be92018-08-31 11:55:55 -0700451 // Cookie == 0 or it is a valid cookie
452 host_network_config += "ipaddress="s + ipAddress + ",prefix="s +
453 std::to_string(prefix) + ",gateway="s + gateway +
454 ",mac="s + mac + ",addressOrigin="s +
455 addressOrigin;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500456
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530457 sdbusplus::bus::bus bus(ipmid_get_sd_bus_connection());
458
459 auto ipObjectInfo = ipmi::getDbusObject(bus, IP_INTERFACE,
460 SETTINGS_ROOT, SETTINGS_MATCH);
461 auto macObjectInfo = ipmi::getDbusObject(bus, MAC_INTERFACE,
462 SETTINGS_ROOT, SETTINGS_MATCH);
Ratan Guptadcb10672017-07-10 10:33:50 +0530463 // set the dbus property
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530464 ipmi::setDbusProperty(bus, ipObjectInfo.second, ipObjectInfo.first,
Patrick Venture0b02be92018-08-31 11:55:55 -0700465 IP_INTERFACE, "Address", std::string(ipAddress));
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530466 ipmi::setDbusProperty(bus, ipObjectInfo.second, ipObjectInfo.first,
Patrick Venture0b02be92018-08-31 11:55:55 -0700467 IP_INTERFACE, "PrefixLength", prefix);
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530468 ipmi::setDbusProperty(bus, ipObjectInfo.second, ipObjectInfo.first,
Patrick Venture0b02be92018-08-31 11:55:55 -0700469 IP_INTERFACE, "Origin", addressOrigin);
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530470 ipmi::setDbusProperty(bus, ipObjectInfo.second, ipObjectInfo.first,
Patrick Venture0b02be92018-08-31 11:55:55 -0700471 IP_INTERFACE, "Gateway", std::string(gateway));
472 ipmi::setDbusProperty(
473 bus, ipObjectInfo.second, ipObjectInfo.first, IP_INTERFACE, "Type",
474 std::string("xyz.openbmc_project.Network.IP.Protocol.IPv4"));
Ratan Gupta01d4bd12017-08-07 15:53:25 +0530475 ipmi::setDbusProperty(bus, macObjectInfo.second, macObjectInfo.first,
Patrick Venture0b02be92018-08-31 11:55:55 -0700476 MAC_INTERFACE, "MACAddress", std::string(mac));
Ratan Guptafd28dd72016-08-01 04:58:01 -0500477
Patrick Venture0b02be92018-08-31 11:55:55 -0700478 log<level::DEBUG>(
479 "Network configuration changed",
480 entry("NETWORKCONFIG=%s", host_network_config.c_str()));
Ratan Guptafd28dd72016-08-01 04:58:01 -0500481 }
Ratan Guptadcb10672017-07-10 10:33:50 +0530482 catch (InternalFailure& e)
483 {
484 commit<InternalFailure>();
485 return -1;
486 }
487
488 return 0;
Ratan Guptafd28dd72016-08-01 04:58:01 -0500489}
490
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500491uint32_t getPOHCounter()
492{
493 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
494
Patrick Venture0b02be92018-08-31 11:55:55 -0700495 auto chassisStateObj =
496 ipmi::getDbusObject(bus, chassisPOHStateIntf, chassisStateRoot, match);
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500497
Patrick Venture0b02be92018-08-31 11:55:55 -0700498 auto service =
499 ipmi::getService(bus, chassisPOHStateIntf, chassisStateObj.first);
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500500
Patrick Venture0b02be92018-08-31 11:55:55 -0700501 auto propValue =
502 ipmi::getDbusProperty(bus, service, chassisStateObj.first,
503 chassisPOHStateIntf, pOHCounterProperty);
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500504
Vernon Maueryf442e112019-04-09 11:44:36 -0700505 return std::get<uint32_t>(propValue);
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -0500506}
507
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500508ipmi_ret_t ipmi_chassis_wildcard(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
509 ipmi_request_t request,
510 ipmi_response_t response,
511 ipmi_data_len_t data_len,
512 ipmi_context_t context)
Adriana Kobylak40814c62015-10-27 15:58:44 -0500513{
Adriana Kobylak40814c62015-10-27 15:58:44 -0500514 // Status code.
Nan Li70aa8d92016-08-29 00:11:10 +0800515 ipmi_ret_t rc = IPMI_CC_INVALID;
Adriana Kobylak40814c62015-10-27 15:58:44 -0500516 *data_len = 0;
517 return rc;
518}
519
Nan Li8d15fb42016-08-16 22:29:40 +0800520ipmi_ret_t ipmi_get_chassis_cap(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
Patrick Venture0b02be92018-08-31 11:55:55 -0700521 ipmi_request_t request,
522 ipmi_response_t response,
523 ipmi_data_len_t data_len,
524 ipmi_context_t context)
Nan Li8d15fb42016-08-16 22:29:40 +0800525{
526 // sd_bus error
527 ipmi_ret_t rc = IPMI_CC_OK;
528
529 ipmi_chassis_cap_t chassis_cap{};
530
Yong Liae4b0402018-11-02 11:12:14 +0800531 if (*data_len != 0)
532 {
533 return IPMI_CC_REQ_DATA_LEN_INVALID;
534 }
535
Nan Li8d15fb42016-08-16 22:29:40 +0800536 *data_len = sizeof(ipmi_chassis_cap_t);
537
Yong Liae4b0402018-11-02 11:12:14 +0800538 try
539 {
540 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
Nan Li8d15fb42016-08-16 22:29:40 +0800541
Yong Liae4b0402018-11-02 11:12:14 +0800542 ipmi::DbusObjectInfo chassisCapObject =
543 ipmi::getDbusObject(bus, chassisCapIntf);
Nan Li8d15fb42016-08-16 22:29:40 +0800544
Yong Liae4b0402018-11-02 11:12:14 +0800545 // capabilities flags
546 // [7..4] - reserved
547 // [3] – 1b = provides power interlock (IPM 1.5)
548 // [2] – 1b = provides Diagnostic Interrupt (FP NMI)
549 // [1] – 1b = provides “Front Panel Lockout” (indicates that the chassis
550 // has capabilities
551 // to lock out external power control and reset button or
552 // front panel interfaces and/or detect tampering with those
553 // interfaces).
554 // [0] -1b = Chassis provides intrusion (physical security) sensor.
555 // set to default value 0x0.
556 ipmi::Value variant = ipmi::getDbusProperty(
557 bus, chassisCapObject.second, chassisCapObject.first,
558 chassisCapIntf, chassisCapFlagsProp);
Vernon Maueryf442e112019-04-09 11:44:36 -0700559 chassis_cap.cap_flags = std::get<uint8_t>(variant);
Nan Li8d15fb42016-08-16 22:29:40 +0800560
Yong Liae4b0402018-11-02 11:12:14 +0800561 variant = ipmi::getDbusProperty(bus, chassisCapObject.second,
562 chassisCapObject.first, chassisCapIntf,
563 chassisFRUDevAddrProp);
564 // Chassis FRU info Device Address.
Vernon Maueryf442e112019-04-09 11:44:36 -0700565 chassis_cap.fru_info_dev_addr = std::get<uint8_t>(variant);
Nan Li8d15fb42016-08-16 22:29:40 +0800566
Yong Liae4b0402018-11-02 11:12:14 +0800567 variant = ipmi::getDbusProperty(bus, chassisCapObject.second,
568 chassisCapObject.first, chassisCapIntf,
569 chassisSDRDevAddrProp);
570 // Chassis SDR Device Address.
Vernon Maueryf442e112019-04-09 11:44:36 -0700571 chassis_cap.sdr_dev_addr = std::get<uint8_t>(variant);
Nan Li8d15fb42016-08-16 22:29:40 +0800572
Yong Liae4b0402018-11-02 11:12:14 +0800573 variant = ipmi::getDbusProperty(bus, chassisCapObject.second,
574 chassisCapObject.first, chassisCapIntf,
575 chassisSELDevAddrProp);
576 // Chassis SEL Device Address.
Vernon Maueryf442e112019-04-09 11:44:36 -0700577 chassis_cap.sel_dev_addr = std::get<uint8_t>(variant);
Nan Li8d15fb42016-08-16 22:29:40 +0800578
Yong Liae4b0402018-11-02 11:12:14 +0800579 variant = ipmi::getDbusProperty(bus, chassisCapObject.second,
580 chassisCapObject.first, chassisCapIntf,
581 chassisSMDevAddrProp);
582 // Chassis System Management Device Address.
Vernon Maueryf442e112019-04-09 11:44:36 -0700583 chassis_cap.system_management_dev_addr = std::get<uint8_t>(variant);
Nan Li8d15fb42016-08-16 22:29:40 +0800584
Yong Liae4b0402018-11-02 11:12:14 +0800585 variant = ipmi::getDbusProperty(bus, chassisCapObject.second,
586 chassisCapObject.first, chassisCapIntf,
587 chassisBridgeDevAddrProp);
588 // Chassis Bridge Device Address.
Vernon Maueryf442e112019-04-09 11:44:36 -0700589 chassis_cap.bridge_dev_addr = std::get<uint8_t>(variant);
Yong Liae4b0402018-11-02 11:12:14 +0800590 uint8_t* respP = reinterpret_cast<uint8_t*>(response);
591 uint8_t* chassisP = reinterpret_cast<uint8_t*>(&chassis_cap);
592 std::copy(chassisP, chassisP + *data_len, respP);
593 }
594 catch (std::exception& e)
595 {
596 log<level::ERR>(e.what());
597 rc = IPMI_CC_UNSPECIFIED_ERROR;
598 *data_len = 0;
599 return rc;
600 }
601
602 return rc;
603}
604
605ipmi_ret_t ipmi_set_chassis_cap(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
606 ipmi_request_t request,
607 ipmi_response_t response,
608 ipmi_data_len_t data_len,
609 ipmi_context_t context)
610{
611 ipmi_ret_t rc = IPMI_CC_OK;
612
613 if (*data_len != sizeof(ipmi_chassis_cap_t))
614 {
615 log<level::ERR>("Unsupported request length",
616 entry("LEN=0x%x", *data_len));
617 *data_len = 0;
618 return IPMI_CC_REQ_DATA_LEN_INVALID;
619 }
620
621 ipmi_chassis_cap_t* chassisCap = static_cast<ipmi_chassis_cap_t*>(request);
622
623 *data_len = 0;
624
625 // check input data
626 if (0 != (chassisCap->cap_flags & ~chassisCapFlagMask))
627 {
628 log<level::ERR>("Unsupported request parameter(CAP Flags)",
629 entry("REQ=0x%x", chassisCap->cap_flags));
630 return IPMI_CC_INVALID_FIELD_REQUEST;
631 }
632
633 if (0 != (chassisCap->fru_info_dev_addr & ~chassisCapAddrMask))
634 {
635 log<level::ERR>("Unsupported request parameter(FRU Addr)",
636 entry("REQ=0x%x", chassisCap->fru_info_dev_addr));
637 return IPMI_CC_INVALID_FIELD_REQUEST;
638 }
639
640 if (0 != (chassisCap->sdr_dev_addr & ~chassisCapAddrMask))
641 {
642 log<level::ERR>("Unsupported request parameter(SDR Addr)",
643 entry("REQ=0x%x", chassisCap->sdr_dev_addr));
644 return IPMI_CC_INVALID_FIELD_REQUEST;
645 }
646
647 if (0 != (chassisCap->sel_dev_addr & ~chassisCapAddrMask))
648 {
649 log<level::ERR>("Unsupported request parameter(SEL Addr)",
650 entry("REQ=0x%x", chassisCap->sel_dev_addr));
651 return IPMI_CC_INVALID_FIELD_REQUEST;
652 }
653
654 if (0 != (chassisCap->system_management_dev_addr & ~chassisCapAddrMask))
655 {
656 log<level::ERR>(
657 "Unsupported request parameter(SM Addr)",
658 entry("REQ=0x%x", chassisCap->system_management_dev_addr));
659 return IPMI_CC_INVALID_FIELD_REQUEST;
660 }
661
662 if (0 != (chassisCap->bridge_dev_addr & ~chassisCapAddrMask))
663 {
664 log<level::ERR>("Unsupported request parameter(Bridge Addr)",
665 entry("REQ=0x%x", chassisCap->bridge_dev_addr));
666 return IPMI_CC_INVALID_FIELD_REQUEST;
667 }
668
669 try
670 {
671 sdbusplus::bus::bus bus(ipmid_get_sd_bus_connection());
672 ipmi::DbusObjectInfo chassisCapObject =
673 ipmi::getDbusObject(bus, chassisCapIntf);
674
675 ipmi::setDbusProperty(bus, chassisCapObject.second,
676 chassisCapObject.first, chassisCapIntf,
677 chassisCapFlagsProp, chassisCap->cap_flags);
678
679 ipmi::setDbusProperty(bus, chassisCapObject.second,
680 chassisCapObject.first, chassisCapIntf,
681 chassisFRUDevAddrProp,
682 chassisCap->fru_info_dev_addr);
683
684 ipmi::setDbusProperty(bus, chassisCapObject.second,
685 chassisCapObject.first, chassisCapIntf,
686 chassisSDRDevAddrProp, chassisCap->sdr_dev_addr);
687
688 ipmi::setDbusProperty(bus, chassisCapObject.second,
689 chassisCapObject.first, chassisCapIntf,
690 chassisSELDevAddrProp, chassisCap->sel_dev_addr);
691
692 ipmi::setDbusProperty(bus, chassisCapObject.second,
693 chassisCapObject.first, chassisCapIntf,
694 chassisSMDevAddrProp,
695 chassisCap->system_management_dev_addr);
696
697 ipmi::setDbusProperty(bus, chassisCapObject.second,
698 chassisCapObject.first, chassisCapIntf,
699 chassisBridgeDevAddrProp,
700 chassisCap->bridge_dev_addr);
701 }
702 catch (std::exception& e)
703 {
704 log<level::ERR>(e.what());
705 rc = IPMI_CC_UNSPECIFIED_ERROR;
706 return rc;
707 }
Nan Li8d15fb42016-08-16 22:29:40 +0800708
709 return rc;
710}
711
Vishwanatha Subbannab12b0c02017-03-07 18:17:19 +0530712//------------------------------------------
713// Calls into Host State Manager Dbus object
714//------------------------------------------
715int initiate_state_transition(State::Host::Transition transition)
vishwa36993272015-11-20 12:43:49 -0600716{
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500717 // OpenBMC Host State Manager dbus framework
Patrick Venture0b02be92018-08-31 11:55:55 -0700718 constexpr auto HOST_STATE_MANAGER_ROOT = "/xyz/openbmc_project/state/host0";
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500719 constexpr auto HOST_STATE_MANAGER_IFACE = "xyz.openbmc_project.State.Host";
Patrick Venture0b02be92018-08-31 11:55:55 -0700720 constexpr auto DBUS_PROPERTY_IFACE = "org.freedesktop.DBus.Properties";
721 constexpr auto PROPERTY = "RequestedHostTransition";
Vishwanatha Subbannab12b0c02017-03-07 18:17:19 +0530722
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500723 // sd_bus error
724 int rc = 0;
Patrick Venture0b02be92018-08-31 11:55:55 -0700725 char* busname = NULL;
vishwa36993272015-11-20 12:43:49 -0600726
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500727 // SD Bus error report mechanism.
728 sd_bus_error bus_error = SD_BUS_ERROR_NULL;
vishwa36993272015-11-20 12:43:49 -0600729
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500730 // Gets a hook onto either a SYSTEM or SESSION bus
Patrick Venture0b02be92018-08-31 11:55:55 -0700731 sd_bus* bus_type = ipmid_get_sd_bus_connection();
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500732 rc = mapper_get_service(bus_type, HOST_STATE_MANAGER_ROOT, &busname);
733 if (rc < 0)
734 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700735 log<level::ERR>(
736 "Failed to get bus name",
737 entry("ERRNO=0x%X, OBJPATH=%s", -rc, HOST_STATE_MANAGER_ROOT));
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500738 return rc;
739 }
Vishwanatha Subbannab12b0c02017-03-07 18:17:19 +0530740
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500741 // Convert to string equivalent of the passed in transition enum.
742 auto request = State::convertForMessage(transition);
Vishwanatha Subbannab12b0c02017-03-07 18:17:19 +0530743
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500744 rc = sd_bus_call_method(bus_type, // On the system bus
745 busname, // Service to contact
746 HOST_STATE_MANAGER_ROOT, // Object path
747 DBUS_PROPERTY_IFACE, // Interface name
748 "Set", // Method to be called
749 &bus_error, // object to return error
750 nullptr, // Response buffer if any
751 "ssv", // Takes 3 arguments
Patrick Venture0b02be92018-08-31 11:55:55 -0700752 HOST_STATE_MANAGER_IFACE, PROPERTY, "s",
753 request.c_str());
754 if (rc < 0)
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500755 {
756 log<level::ERR>("Failed to initiate transition",
Aditya Saripalli5fb14602017-11-09 14:46:27 +0530757 entry("ERRNO=0x%X, REQUEST=%s", -rc, request.c_str()));
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500758 }
759 else
760 {
761 log<level::INFO>("Transition request initiated successfully");
762 }
vishwa36993272015-11-20 12:43:49 -0600763
764 sd_bus_error_free(&bus_error);
Sergey Solomineb9b8142016-08-23 09:07:28 -0500765 free(busname);
vishwa36993272015-11-20 12:43:49 -0600766
Sergey Solomineb9b8142016-08-23 09:07:28 -0500767 return rc;
vishwa36993272015-11-20 12:43:49 -0600768}
769
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500770namespace power_policy
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -0500771{
Nan Lifdd8ec52016-08-28 03:57:40 +0800772
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500773using namespace sdbusplus::xyz::openbmc_project::Control::Power::server;
774using IpmiValue = uint8_t;
775using DbusValue = RestorePolicy::Policy;
Nan Lifdd8ec52016-08-28 03:57:40 +0800776
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700777const std::map<DbusValue, IpmiValue> dbusToIpmi = {
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500778 {RestorePolicy::Policy::AlwaysOff, 0x00},
779 {RestorePolicy::Policy::Restore, 0x01},
Patrick Venture0b02be92018-08-31 11:55:55 -0700780 {RestorePolicy::Policy::AlwaysOn, 0x02}};
Nan Lifdd8ec52016-08-28 03:57:40 +0800781
Yong Lic6713cf2018-09-12 12:35:13 +0800782static constexpr uint8_t noChange = 0x03;
783static constexpr uint8_t allSupport = 0x01 | 0x02 | 0x04;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700784
785/* helper function for Get Chassis Status Command
786 */
787std::optional<uint2_t> getPowerRestorePolicy()
788{
789 uint2_t restorePolicy = 0;
790 using namespace chassis::internal;
791
792 try
793 {
794 const auto& powerRestoreSetting =
795 cache::objects.map.at(powerRestoreIntf).front();
796 ipmi::Value result = ipmi::getDbusProperty(
797 *getSdBus(),
798 cache::objects.service(powerRestoreSetting, powerRestoreIntf)
799 .c_str(),
800 powerRestoreSetting.c_str(), powerRestoreIntf,
801 "PowerRestorePolicy");
802 auto powerRestore = RestorePolicy::convertPolicyFromString(
803 std::get<std::string>(result));
804 restorePolicy = dbusToIpmi.at(powerRestore);
805 }
806 catch (const std::exception& e)
807 {
808 log<level::ERR>(
809 "Failed to fetch pgood property", entry("ERROR=%s", e.what()),
810 entry("PATH=%s",
811 cache::objects.map.at(powerRestoreIntf).front().c_str()),
812 entry("INTERFACE=%s", powerRestoreIntf));
813 return std::nullopt;
814 }
815 return std::make_optional(restorePolicy);
816}
817
818/*
819 * getPowerStatus
820 * helper function for Get Chassis Status Command
821 * return - optional value for pgood (no value on error)
822 */
823std::optional<bool> getPowerStatus()
824{
825 constexpr const char* powerControlObj =
826 "/xyz/openbmc_project/Chassis/Control/Power0";
827 constexpr const char* powerControlIntf =
828 "xyz.openbmc_project.Chassis.Control.Power";
829 bool powerGood = false;
830 std::shared_ptr<sdbusplus::asio::connection> busp = getSdBus();
831 try
832 {
833 auto service =
834 ipmi::getService(*busp, powerControlIntf, powerControlObj);
835
836 ipmi::Value variant = ipmi::getDbusProperty(
837 *busp, service, powerControlObj, powerControlIntf, "pgood");
838 powerGood = static_cast<bool>(std::get<int>(variant));
839 }
840 catch (const std::exception& e)
841 {
842 try
843 {
844 // FIXME: some legacy modules use the older path; try that next
845 constexpr const char* legacyPwrCtrlObj =
846 "/org/openbmc/control/power0";
847 constexpr const char* legacyPwrCtrlIntf =
848 "org.openbmc.control.Power";
849 auto service =
850 ipmi::getService(*busp, legacyPwrCtrlIntf, legacyPwrCtrlObj);
851
852 ipmi::Value variant = ipmi::getDbusProperty(
853 *busp, service, legacyPwrCtrlObj, legacyPwrCtrlIntf, "pgood");
854 powerGood = static_cast<bool>(std::get<int>(variant));
855 }
856 catch (const std::exception& e)
857 {
858 log<level::ERR>("Failed to fetch pgood property",
859 entry("ERROR=%s", e.what()),
860 entry("PATH=%s", powerControlObj),
861 entry("INTERFACE=%s", powerControlIntf));
862 return std::nullopt;
863 }
864 }
865 return std::make_optional(powerGood);
866}
867
Yong Li70ce7352019-05-16 21:15:27 +0800868/*
869 * getACFailStatus
870 * helper function for Get Chassis Status Command
871 * return - bool value for ACFail (false on error)
872 */
873bool getACFailStatus()
874{
875 constexpr const char* powerControlObj =
876 "/xyz/openbmc_project/Chassis/Control/Power0";
877 constexpr const char* powerControlIntf =
878 "xyz.openbmc_project.Chassis.Control.Power";
879 bool acFail = false;
880 std::shared_ptr<sdbusplus::asio::connection> bus = getSdBus();
881 try
882 {
883 auto service =
884 ipmi::getService(*bus, powerControlIntf, powerControlObj);
885
886 ipmi::Value variant = ipmi::getDbusProperty(
887 *bus, service, powerControlObj, powerControlIntf, "PFail");
888 acFail = std::get<bool>(variant);
889 }
890 catch (const std::exception& e)
891 {
892 log<level::ERR>("Failed to fetch PFail property",
893 entry("ERROR=%s", e.what()),
894 entry("PATH=%s", powerControlObj),
895 entry("INTERFACE=%s", powerControlIntf));
896 }
897 return acFail;
898}
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500899} // namespace power_policy
Nan Lifdd8ec52016-08-28 03:57:40 +0800900
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700901static std::optional<bool> getButtonEnabled(const std::string& buttonPath,
902 const std::string& buttonIntf)
903{
904 std::shared_ptr<sdbusplus::asio::connection> busp = getSdBus();
905 bool buttonDisabled = false;
906 try
907 {
908 auto service = ipmi::getService(*busp, buttonIntf, buttonPath);
909 ipmi::Value enabled = ipmi::getDbusProperty(*busp, service, buttonPath,
910 buttonIntf, "Enabled");
911 buttonDisabled = !std::get<bool>(enabled);
912 }
913 catch (sdbusplus::exception::SdBusError& e)
914 {
915 log<level::ERR>("Fail to get button Enabled property",
916 entry("PATH=%s", buttonPath.c_str()),
917 entry("ERROR=%s", e.what()));
918 return std::nullopt;
919 }
920 return std::make_optional(buttonDisabled);
921}
922
Nan Lifdd8ec52016-08-28 03:57:40 +0800923//----------------------------------------------------------------------
924// Get Chassis Status commands
925//----------------------------------------------------------------------
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700926ipmi::RspType<bool, // Power is on
927 bool, // Power overload
928 bool, // Interlock
929 bool, // power fault
930 bool, // power control fault
931 uint2_t, // power restore policy
932 bool, // reserved
933
934 bool, // AC failed
935 bool, // last power down caused by a Power overload
936 bool, // last power down caused by a power interlock
937 bool, // last power down caused by power fault
938 bool, // last ‘Power is on’ state was entered via IPMI command
939 uint3_t, // reserved
940
941 bool, // Chassis intrusion active
942 bool, // Front Panel Lockout active
943 bool, // Drive Fault
944 bool, // Cooling/fan fault detected
945 uint2_t, // Chassis Identify State
946 bool, // Chassis Identify command and state info supported
947 bool, // reserved
948
949 bool, // Power off button disabled
950 bool, // Reset button disabled
951 bool, // Diagnostic Interrupt button disabled
952 bool, // Standby (sleep) button disabled
953 bool, // Power off button disable allowed
954 bool, // Reset button disable allowed
955 bool, // Diagnostic Interrupt button disable allowed
956 bool // Standby (sleep) button disable allowed
957 >
958 ipmiGetChassisStatus()
Nan Lifdd8ec52016-08-28 03:57:40 +0800959{
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500960 using namespace chassis::internal;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700961 std::optional<uint2_t> restorePolicy =
962 power_policy::getPowerRestorePolicy();
963 std::optional<bool> powerGood = power_policy::getPowerStatus();
964 if (!restorePolicy || !powerGood)
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500965 {
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700966 return ipmi::responseUnspecifiedError();
Deepak Kodihalli18b70d12017-07-21 13:36:33 -0500967 }
Nan Lifdd8ec52016-08-28 03:57:40 +0800968
969 // Front Panel Button Capabilities and disable/enable status(Optional)
Vernon Mauery6d5b2f72019-05-16 14:48:47 -0700970 std::optional<bool> powerButtonReading =
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700971 getButtonEnabled(powerButtonPath, powerButtonIntf);
Vernon Mauery6d5b2f72019-05-16 14:48:47 -0700972 // allow disable if the interface is present
973 bool powerButtonDisableAllow = static_cast<bool>(powerButtonReading);
974 // default return the button is enabled (not disabled)
975 bool powerButtonDisabled = false;
976 if (powerButtonDisableAllow)
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700977 {
Vernon Mauery6d5b2f72019-05-16 14:48:47 -0700978 // return the real value of the button status, if present
979 powerButtonDisabled = *powerButtonReading;
980 }
981
982 std::optional<bool> resetButtonReading =
983 getButtonEnabled(resetButtonPath, resetButtonIntf);
984 // allow disable if the interface is present
985 bool resetButtonDisableAllow = static_cast<bool>(resetButtonReading);
986 // default return the button is enabled (not disabled)
987 bool resetButtonDisabled = false;
988 if (resetButtonDisableAllow)
989 {
990 // return the real value of the button status, if present
991 resetButtonDisabled = *resetButtonReading;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700992 }
Nan Lifdd8ec52016-08-28 03:57:40 +0800993
Yong Li70ce7352019-05-16 21:15:27 +0800994 bool powerDownAcFailed = power_policy::getACFailStatus();
995
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -0700996 // This response has a lot of hard-coded, unsupported fields
997 // They are set to false or 0
998 constexpr bool powerOverload = false;
999 constexpr bool chassisInterlock = false;
1000 constexpr bool powerFault = false;
1001 constexpr bool powerControlFault = false;
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001002 constexpr bool powerDownOverload = false;
1003 constexpr bool powerDownInterlock = false;
1004 constexpr bool powerDownPowerFault = false;
1005 constexpr bool powerStatusIPMI = false;
1006 constexpr bool chassisIntrusionActive = false;
1007 constexpr bool frontPanelLockoutActive = false;
1008 constexpr bool driveFault = false;
1009 constexpr bool coolingFanFault = false;
1010 // chassisIdentifySupport set because this command is implemented
1011 constexpr bool chassisIdentifySupport = true;
Yong Lif4e38512019-05-21 14:46:55 +08001012 uint2_t chassisIdentifyState = static_cast<uint2_t>(chassisIDState);
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001013 constexpr bool diagButtonDisabled = false;
1014 constexpr bool sleepButtonDisabled = false;
1015 constexpr bool diagButtonDisableAllow = false;
1016 constexpr bool sleepButtonDisableAllow = false;
1017
1018 return ipmi::responseSuccess(
1019 *powerGood, powerOverload, chassisInterlock, powerFault,
1020 powerControlFault, *restorePolicy,
1021 false, // reserved
1022
1023 powerDownAcFailed, powerDownOverload, powerDownInterlock,
1024 powerDownPowerFault, powerStatusIPMI,
1025 uint3_t(0), // reserved
1026
1027 chassisIntrusionActive, frontPanelLockoutActive, driveFault,
1028 coolingFanFault, chassisIdentifyState, chassisIdentifySupport,
1029 false, // reserved
1030
Vernon Mauery6d5b2f72019-05-16 14:48:47 -07001031 powerButtonDisabled, resetButtonDisabled, diagButtonDisabled,
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001032 sleepButtonDisabled, powerButtonDisableAllow, resetButtonDisableAllow,
1033 diagButtonDisableAllow, sleepButtonDisableAllow);
Nan Lifdd8ec52016-08-28 03:57:40 +08001034}
Chris Austen7888c4d2015-12-03 15:26:20 -06001035
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301036//-------------------------------------------------------------
1037// Send a command to SoftPowerOff application to stop any timer
1038//-------------------------------------------------------------
1039int stop_soft_off_timer()
1040{
Patrick Venture0b02be92018-08-31 11:55:55 -07001041 constexpr auto iface = "org.freedesktop.DBus.Properties";
1042 constexpr auto soft_off_iface = "xyz.openbmc_project.Ipmi.Internal."
1043 "SoftPowerOff";
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301044
Patrick Venture0b02be92018-08-31 11:55:55 -07001045 constexpr auto property = "ResponseReceived";
1046 constexpr auto value = "xyz.openbmc_project.Ipmi.Internal."
1047 "SoftPowerOff.HostResponse.HostShutdown";
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301048
1049 // Get the system bus where most system services are provided.
1050 auto bus = ipmid_get_sd_bus_connection();
1051
1052 // Get the service name
Andrew Geissler2b4e4592017-06-08 11:18:35 -05001053 // TODO openbmc/openbmc#1661 - Mapper refactor
1054 //
1055 // See openbmc/openbmc#1743 for some details but high level summary is that
1056 // for now the code will directly call the soft off interface due to a
1057 // race condition with mapper usage
1058 //
Patrick Venture0b02be92018-08-31 11:55:55 -07001059 // char *busname = nullptr;
1060 // auto r = mapper_get_service(bus, SOFTOFF_OBJPATH, &busname);
1061 // if (r < 0)
Andrew Geissler2b4e4592017-06-08 11:18:35 -05001062 //{
1063 // fprintf(stderr, "Failed to get %s bus name: %s\n",
Aditya Saripalli5fb14602017-11-09 14:46:27 +05301064 // SOFTOFF_OBJPATH, -r);
Andrew Geissler2b4e4592017-06-08 11:18:35 -05001065 // return r;
1066 //}
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301067
1068 // No error object or reply expected.
Andrew Geissler2b4e4592017-06-08 11:18:35 -05001069 int rc = sd_bus_call_method(bus, SOFTOFF_BUSNAME, SOFTOFF_OBJPATH, iface,
Patrick Venture0b02be92018-08-31 11:55:55 -07001070 "Set", nullptr, nullptr, "ssv", soft_off_iface,
1071 property, "s", value);
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301072 if (rc < 0)
1073 {
Aditya Saripalli5fb14602017-11-09 14:46:27 +05301074 log<level::ERR>("Failed to set property in SoftPowerOff object",
1075 entry("ERRNO=0x%X", -rc));
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301076 }
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001077
Patrick Venture0b02be92018-08-31 11:55:55 -07001078 // TODO openbmc/openbmc#1661 - Mapper refactor
1079 // free(busname);
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301080 return rc;
1081}
1082
vishwa36993272015-11-20 12:43:49 -06001083//----------------------------------------------------------------------
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001084// Create file to indicate there is no need for softoff notification to host
1085//----------------------------------------------------------------------
1086void indicate_no_softoff_needed()
1087{
1088 fs::path path{HOST_INBAND_REQUEST_DIR};
1089 if (!fs::is_directory(path))
1090 {
1091 fs::create_directory(path);
1092 }
1093
1094 // Add the host instance (default 0 for now) to the file name
1095 std::string file{HOST_INBAND_REQUEST_FILE};
Patrick Venture0b02be92018-08-31 11:55:55 -07001096 auto size = std::snprintf(nullptr, 0, file.c_str(), 0);
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001097 size++; // null
1098 std::unique_ptr<char[]> buf(new char[size]);
Patrick Venture0b02be92018-08-31 11:55:55 -07001099 std::snprintf(buf.get(), size, file.c_str(), 0);
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001100
1101 // Append file name to directory and create it
1102 path /= buf.get();
1103 std::ofstream(path.c_str());
1104}
1105
anil kumar appanadafff5f2019-04-27 18:06:00 +00001106/** @brief Implementation of chassis control command
1107 *
1108 * @param - chassisControl command byte
1109 *
1110 * @return Success or InvalidFieldRequest.
1111 */
1112ipmi::RspType<> ipmiChassisControl(uint8_t chassisControl)
vishwa36993272015-11-20 12:43:49 -06001113{
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001114 int rc = 0;
anil kumar appanadafff5f2019-04-27 18:06:00 +00001115 switch (chassisControl)
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001116 {
1117 case CMD_POWER_ON:
1118 rc = initiate_state_transition(State::Host::Transition::On);
1119 break;
1120 case CMD_POWER_OFF:
Vishwanatha Subbanna8b26d352017-08-04 18:35:18 +05301121 // This path would be hit in 2 conditions.
1122 // 1: When user asks for power off using ipmi chassis command 0x04
1123 // 2: Host asking for power off post shutting down.
1124
1125 // If it's a host requested power off, then need to nudge Softoff
1126 // application that it needs to stop the watchdog timer if running.
1127 // If it is a user requested power off, then this is not really
1128 // needed. But then we need to differentiate between user and host
1129 // calling this same command
1130
1131 // For now, we are going ahead with trying to nudge the soft off and
1132 // interpret the failure to do so as a non softoff case
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001133 rc = stop_soft_off_timer();
Vishwanatha Subbanna8b26d352017-08-04 18:35:18 +05301134
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001135 // Only request the Off transition if the soft power off
1136 // application is not running
1137 if (rc < 0)
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001138 {
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001139 // First create a file to indicate to the soft off application
Vishwanatha Subbanna8b26d352017-08-04 18:35:18 +05301140 // that it should not run. Not doing this will result in State
1141 // manager doing a default soft power off when asked for power
1142 // off.
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001143 indicate_no_softoff_needed();
1144
1145 // Now request the shutdown
1146 rc = initiate_state_transition(State::Host::Transition::Off);
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001147 }
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001148 else
1149 {
Vishwanatha Subbanna8b26d352017-08-04 18:35:18 +05301150 log<level::INFO>("Soft off is running, so let shutdown target "
1151 "stop the host");
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001152 }
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001153 break;
Vishwanatha Subbanna83b5c1c2017-01-25 18:41:51 +05301154
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001155 case CMD_HARD_RESET:
1156 case CMD_POWER_CYCLE:
1157 // SPEC has a section that says certain implementations can trigger
1158 // PowerOn if power is Off when a command to power cycle is
1159 // requested
Andrew Geisslera6e3a302017-05-31 19:34:00 -05001160
1161 // First create a file to indicate to the soft off application
1162 // that it should not run since this is a direct user initiated
1163 // power reboot request (i.e. a reboot request that is not
1164 // originating via a soft power off SMS request)
1165 indicate_no_softoff_needed();
1166
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001167 rc = initiate_state_transition(State::Host::Transition::Reboot);
1168 break;
Vishwanatha Subbanna8b26d352017-08-04 18:35:18 +05301169
1170 case CMD_SOFT_OFF_VIA_OVER_TEMP:
1171 // Request Host State Manager to do a soft power off
1172 rc = initiate_state_transition(State::Host::Transition::Off);
1173 break;
1174
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001175 default:
1176 {
Aditya Saripalli5fb14602017-11-09 14:46:27 +05301177 log<level::ERR>("Invalid Chassis Control command",
anil kumar appanadafff5f2019-04-27 18:06:00 +00001178 entry("CMD=0x%X", chassisControl));
1179 return ipmi::responseInvalidFieldRequest();
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001180 }
1181 }
vishwa36993272015-11-20 12:43:49 -06001182
anil kumar appanadafff5f2019-04-27 18:06:00 +00001183 return ((rc < 0) ? ipmi::responseUnspecifiedError()
1184 : ipmi::responseSuccess());
vishwa36993272015-11-20 12:43:49 -06001185}
1186
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001187/** @brief Return D-Bus connection string to enclosure identify LED object
1188 *
1189 * @param[in, out] connection - connection to D-Bus object
1190 * @return a IPMI return code
1191 */
1192std::string getEnclosureIdentifyConnection()
Tom Joseph5110c122018-03-23 17:55:40 +05301193{
Tom Joseph5110c122018-03-23 17:55:40 +05301194 // lookup enclosure_identify group owner(s) in mapper
1195 auto mapperCall = chassis::internal::dbus.new_method_call(
Patrick Venture0b02be92018-08-31 11:55:55 -07001196 ipmi::MAPPER_BUS_NAME, ipmi::MAPPER_OBJ, ipmi::MAPPER_INTF,
1197 "GetObject");
Tom Joseph5110c122018-03-23 17:55:40 +05301198
1199 mapperCall.append(identify_led_object_name);
Patrick Venture0b02be92018-08-31 11:55:55 -07001200 static const std::vector<std::string> interfaces = {
1201 "xyz.openbmc_project.Led.Group"};
Tom Joseph5110c122018-03-23 17:55:40 +05301202 mapperCall.append(interfaces);
1203 auto mapperReply = chassis::internal::dbus.call(mapperCall);
1204 if (mapperReply.is_method_error())
1205 {
1206 log<level::ERR>("Chassis Identify: Error communicating to mapper.");
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001207 elog<InternalFailure>();
Tom Joseph5110c122018-03-23 17:55:40 +05301208 }
1209 std::vector<std::pair<std::string, std::vector<std::string>>> mapperResp;
1210 mapperReply.read(mapperResp);
1211
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001212 if (mapperResp.size() != encIdentifyObjectsSize)
Tom Joseph5110c122018-03-23 17:55:40 +05301213 {
Patrick Venture0b02be92018-08-31 11:55:55 -07001214 log<level::ERR>(
1215 "Invalid number of enclosure identify objects.",
1216 entry("ENC_IDENTITY_OBJECTS_SIZE=%d", mapperResp.size()));
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001217 elog<InternalFailure>();
1218 }
1219 auto pair = mapperResp[encIdentifyObjectsSize - 1];
1220 return pair.first;
1221}
Tom Joseph5110c122018-03-23 17:55:40 +05301222
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001223/** @brief Turn On/Off enclosure identify LED
1224 *
1225 * @param[in] flag - true to turn on LED, false to turn off
1226 * @return a IPMI return code
1227 */
1228void enclosureIdentifyLed(bool flag)
1229{
1230 using namespace chassis::internal;
1231 std::string connection = std::move(getEnclosureIdentifyConnection());
Vernon Mauery400cc782018-10-09 13:49:53 -07001232 auto msg = std::string("enclosureIdentifyLed(") +
1233 boost::lexical_cast<std::string>(flag) + ")";
1234 log<level::DEBUG>(msg.c_str());
Patrick Venture0b02be92018-08-31 11:55:55 -07001235 auto led =
1236 dbus.new_method_call(connection.c_str(), identify_led_object_name,
1237 "org.freedesktop.DBus.Properties", "Set");
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001238 led.append("xyz.openbmc_project.Led.Group", "Asserted",
Vernon Mauery16b86932019-05-01 08:36:11 -07001239 std::variant<bool>(flag));
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001240 auto ledReply = dbus.call(led);
1241 if (ledReply.is_method_error())
1242 {
1243 log<level::ERR>("Chassis Identify: Error Setting State On/Off\n",
Patrick Venture0b02be92018-08-31 11:55:55 -07001244 entry("LED_STATE=%d", flag));
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001245 elog<InternalFailure>();
1246 }
1247}
1248
1249/** @brief Callback method to turn off LED
1250 */
1251void enclosureIdentifyLedOff()
1252{
1253 try
1254 {
Yong Lif4e38512019-05-21 14:46:55 +08001255 chassisIDState = ChassisIDState::off;
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001256 enclosureIdentifyLed(false);
1257 }
1258 catch (const InternalFailure& e)
1259 {
1260 report<InternalFailure>();
1261 }
1262}
1263
1264/** @brief Create timer to turn on and off the enclosure LED
1265 */
1266void createIdentifyTimer()
1267{
1268 if (!identifyTimer)
1269 {
Vernon Mauery1181af72018-10-08 12:05:00 -07001270 identifyTimer =
1271 std::make_unique<phosphor::Timer>(enclosureIdentifyLedOff);
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001272 }
1273}
1274
Vernon Mauery400cc782018-10-09 13:49:53 -07001275ipmi::RspType<> ipmiChassisIdentify(std::optional<uint8_t> interval,
1276 std::optional<uint8_t> force)
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001277{
Vernon Mauery400cc782018-10-09 13:49:53 -07001278 uint8_t identifyInterval = interval.value_or(DEFAULT_IDENTIFY_TIME_OUT);
1279 bool forceIdentify = force.value_or(0) & 0x01;
Tom Josephbed26992018-07-31 23:00:24 +05301280
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001281 if (identifyInterval || forceIdentify)
1282 {
Vernon Mauery400cc782018-10-09 13:49:53 -07001283 // stop the timer if already started;
1284 // for force identify we should not turn off LED
Vernon Mauery1181af72018-10-08 12:05:00 -07001285 identifyTimer->stop();
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001286 try
Tom Joseph5110c122018-03-23 17:55:40 +05301287 {
Yong Lif4e38512019-05-21 14:46:55 +08001288 chassisIDState = ChassisIDState::temporaryOn;
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001289 enclosureIdentifyLed(true);
1290 }
1291 catch (const InternalFailure& e)
1292 {
1293 report<InternalFailure>();
Vernon Mauery400cc782018-10-09 13:49:53 -07001294 return ipmi::responseResponseError();
Tom Joseph5110c122018-03-23 17:55:40 +05301295 }
1296
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001297 if (forceIdentify)
Tom Joseph5110c122018-03-23 17:55:40 +05301298 {
Yong Lif4e38512019-05-21 14:46:55 +08001299 chassisIDState = ChassisIDState::indefiniteOn;
Vernon Mauery400cc782018-10-09 13:49:53 -07001300 return ipmi::responseSuccess();
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001301 }
1302 // start the timer
1303 auto time = std::chrono::duration_cast<std::chrono::microseconds>(
Patrick Venture0b02be92018-08-31 11:55:55 -07001304 std::chrono::seconds(identifyInterval));
Vernon Mauery1181af72018-10-08 12:05:00 -07001305 identifyTimer->start(time);
Tom Joseph5110c122018-03-23 17:55:40 +05301306 }
Tom Josephbed26992018-07-31 23:00:24 +05301307 else if (!identifyInterval)
1308 {
Vernon Mauery1181af72018-10-08 12:05:00 -07001309 identifyTimer->stop();
Tom Josephbed26992018-07-31 23:00:24 +05301310 enclosureIdentifyLedOff();
1311 }
Vernon Mauery400cc782018-10-09 13:49:53 -07001312 return ipmi::responseSuccess();
Tom Joseph5110c122018-03-23 17:55:40 +05301313}
1314
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001315namespace boot_options
1316{
1317
1318using namespace sdbusplus::xyz::openbmc_project::Control::Boot::server;
1319using IpmiValue = uint8_t;
1320constexpr auto ipmiDefault = 0;
1321
Patrick Venture0b02be92018-08-31 11:55:55 -07001322std::map<IpmiValue, Source::Sources> sourceIpmiToDbus = {
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001323 {0x01, Source::Sources::Network},
1324 {0x02, Source::Sources::Disk},
1325 {0x05, Source::Sources::ExternalMedia},
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08001326 {0x0f, Source::Sources::RemovableMedia},
Patrick Venture0b02be92018-08-31 11:55:55 -07001327 {ipmiDefault, Source::Sources::Default}};
shgoupfd84fbbf2015-12-17 10:05:51 +08001328
Patrick Venture0b02be92018-08-31 11:55:55 -07001329std::map<IpmiValue, Mode::Modes> modeIpmiToDbus = {
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001330 {0x03, Mode::Modes::Safe},
1331 {0x06, Mode::Modes::Setup},
Patrick Venture0b02be92018-08-31 11:55:55 -07001332 {ipmiDefault, Mode::Modes::Regular}};
shgoupfd84fbbf2015-12-17 10:05:51 +08001333
Patrick Venture0b02be92018-08-31 11:55:55 -07001334std::map<Source::Sources, IpmiValue> sourceDbusToIpmi = {
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001335 {Source::Sources::Network, 0x01},
1336 {Source::Sources::Disk, 0x02},
1337 {Source::Sources::ExternalMedia, 0x05},
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08001338 {Source::Sources::RemovableMedia, 0x0f},
Patrick Venture0b02be92018-08-31 11:55:55 -07001339 {Source::Sources::Default, ipmiDefault}};
shgoupfd84fbbf2015-12-17 10:05:51 +08001340
Patrick Venture0b02be92018-08-31 11:55:55 -07001341std::map<Mode::Modes, IpmiValue> modeDbusToIpmi = {
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001342 {Mode::Modes::Safe, 0x03},
1343 {Mode::Modes::Setup, 0x06},
Patrick Venture0b02be92018-08-31 11:55:55 -07001344 {Mode::Modes::Regular, ipmiDefault}};
shgoupfd84fbbf2015-12-17 10:05:51 +08001345
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001346} // namespace boot_options
shgoupfd84fbbf2015-12-17 10:05:51 +08001347
Marri Devender Rao81719702018-05-07 00:53:48 -05001348/** @brief Set the property value for boot source
1349 * @param[in] source - boot source value
1350 * @return On failure return IPMI error.
1351 */
1352static ipmi_ret_t setBootSource(const Source::Sources& source)
1353{
1354 using namespace chassis::internal;
1355 using namespace chassis::internal::cache;
Vernon Mauery16b86932019-05-01 08:36:11 -07001356 std::variant<std::string> property = convertForMessage(source);
Marri Devender Rao81719702018-05-07 00:53:48 -05001357 auto bootSetting = settings::boot::setting(objects, bootSourceIntf);
1358 const auto& bootSourceSetting = std::get<settings::Path>(bootSetting);
Patrick Venture0b02be92018-08-31 11:55:55 -07001359 auto method = dbus.new_method_call(
1360 objects.service(bootSourceSetting, bootSourceIntf).c_str(),
1361 bootSourceSetting.c_str(), ipmi::PROP_INTF, "Set");
Marri Devender Rao81719702018-05-07 00:53:48 -05001362 method.append(bootSourceIntf, "BootSource", property);
1363 auto reply = dbus.call(method);
1364 if (reply.is_method_error())
1365 {
1366 log<level::ERR>("Error in BootSource Set");
1367 report<InternalFailure>();
1368 return IPMI_CC_UNSPECIFIED_ERROR;
1369 }
1370 return IPMI_CC_OK;
1371}
1372
Patrick Venture0b02be92018-08-31 11:55:55 -07001373/** @brief Set the property value for boot mode
Marri Devender Rao81719702018-05-07 00:53:48 -05001374 * @param[in] mode - boot mode value
1375 * @return On failure return IPMI error.
1376 */
1377static ipmi_ret_t setBootMode(const Mode::Modes& mode)
1378{
1379 using namespace chassis::internal;
1380 using namespace chassis::internal::cache;
Vernon Mauery16b86932019-05-01 08:36:11 -07001381 std::variant<std::string> property = convertForMessage(mode);
Marri Devender Rao81719702018-05-07 00:53:48 -05001382 auto bootSetting = settings::boot::setting(objects, bootModeIntf);
1383 const auto& bootModeSetting = std::get<settings::Path>(bootSetting);
Patrick Venture0b02be92018-08-31 11:55:55 -07001384 auto method = dbus.new_method_call(
1385 objects.service(bootModeSetting, bootModeIntf).c_str(),
1386 bootModeSetting.c_str(), ipmi::PROP_INTF, "Set");
Marri Devender Rao81719702018-05-07 00:53:48 -05001387 method.append(bootModeIntf, "BootMode", property);
1388 auto reply = dbus.call(method);
1389 if (reply.is_method_error())
1390 {
1391 log<level::ERR>("Error in BootMode Set");
1392 report<InternalFailure>();
1393 return IPMI_CC_UNSPECIFIED_ERROR;
1394 }
1395 return IPMI_CC_OK;
1396}
1397
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001398ipmi_ret_t ipmi_chassis_get_sys_boot_options(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
1399 ipmi_request_t request,
1400 ipmi_response_t response,
1401 ipmi_data_len_t data_len,
1402 ipmi_context_t context)
Adriana Kobylak40814c62015-10-27 15:58:44 -05001403{
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001404 using namespace boot_options;
shgoupfd84fbbf2015-12-17 10:05:51 +08001405 ipmi_ret_t rc = IPMI_CC_PARM_NOT_SUPPORTED;
Patrick Venture0b02be92018-08-31 11:55:55 -07001406 char* p = NULL;
1407 get_sys_boot_options_response_t* resp =
1408 (get_sys_boot_options_response_t*)response;
1409 get_sys_boot_options_t* reqptr = (get_sys_boot_options_t*)request;
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001410 IpmiValue bootOption = ipmiDefault;
Adriana Kobylak40814c62015-10-27 15:58:44 -05001411
Patrick Ventureb51bf9c2018-09-10 15:53:14 -07001412 std::memset(resp, 0, sizeof(*resp));
Patrick Venture0b02be92018-08-31 11:55:55 -07001413 resp->version = SET_PARM_VERSION;
1414 resp->parm = 5;
1415 resp->data[0] = SET_PARM_BOOT_FLAGS_VALID_ONE_TIME;
Adriana Kobylak40814c62015-10-27 15:58:44 -05001416
shgoupfd84fbbf2015-12-17 10:05:51 +08001417 /*
1418 * Parameter #5 means boot flags. Please refer to 28.13 of ipmi doc.
1419 * This is the only parameter used by petitboot.
1420 */
Patrick Venture0b02be92018-08-31 11:55:55 -07001421 if (reqptr->parameter ==
1422 static_cast<uint8_t>(BootOptionParameter::BOOT_FLAGS))
1423 {
shgoupfd84fbbf2015-12-17 10:05:51 +08001424
Ratan Guptafd28dd72016-08-01 04:58:01 -05001425 *data_len = static_cast<uint8_t>(BootOptionResponseSize::BOOT_FLAGS);
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001426 using namespace chassis::internal;
1427 using namespace chassis::internal::cache;
shgoupfd84fbbf2015-12-17 10:05:51 +08001428
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001429 try
ratagupta6f6bff2016-04-04 06:20:11 -05001430 {
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001431 auto bootSetting = settings::boot::setting(objects, bootSourceIntf);
1432 const auto& bootSourceSetting =
1433 std::get<settings::Path>(bootSetting);
1434 auto oneTimeEnabled =
1435 std::get<settings::boot::OneTimeEnabled>(bootSetting);
Patrick Venture0b02be92018-08-31 11:55:55 -07001436 auto method = dbus.new_method_call(
1437 objects.service(bootSourceSetting, bootSourceIntf).c_str(),
1438 bootSourceSetting.c_str(), ipmi::PROP_INTF, "Get");
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001439 method.append(bootSourceIntf, "BootSource");
1440 auto reply = dbus.call(method);
1441 if (reply.is_method_error())
1442 {
1443 log<level::ERR>("Error in BootSource Get");
1444 report<InternalFailure>();
1445 *data_len = 0;
1446 return IPMI_CC_UNSPECIFIED_ERROR;
1447 }
Vernon Mauery16b86932019-05-01 08:36:11 -07001448 std::variant<std::string> result;
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001449 reply.read(result);
Vernon Maueryf442e112019-04-09 11:44:36 -07001450 auto bootSource =
1451 Source::convertSourcesFromString(std::get<std::string>(result));
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001452
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001453 bootSetting = settings::boot::setting(objects, bootModeIntf);
1454 const auto& bootModeSetting = std::get<settings::Path>(bootSetting);
1455 method = dbus.new_method_call(
Patrick Venture0b02be92018-08-31 11:55:55 -07001456 objects.service(bootModeSetting, bootModeIntf).c_str(),
1457 bootModeSetting.c_str(), ipmi::PROP_INTF, "Get");
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001458 method.append(bootModeIntf, "BootMode");
1459 reply = dbus.call(method);
1460 if (reply.is_method_error())
1461 {
1462 log<level::ERR>("Error in BootMode Get");
1463 report<InternalFailure>();
1464 *data_len = 0;
1465 return IPMI_CC_UNSPECIFIED_ERROR;
1466 }
1467 reply.read(result);
Vernon Maueryf442e112019-04-09 11:44:36 -07001468 auto bootMode =
1469 Mode::convertModesFromString(std::get<std::string>(result));
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001470
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001471 bootOption = sourceDbusToIpmi.at(bootSource);
1472 if ((Mode::Modes::Regular == bootMode) &&
1473 (Source::Sources::Default == bootSource))
1474 {
1475 bootOption = ipmiDefault;
1476 }
1477 else if (Source::Sources::Default == bootSource)
1478 {
1479 bootOption = modeDbusToIpmi.at(bootMode);
1480 }
1481 resp->data[1] = (bootOption << 2);
ratagupta6f6bff2016-04-04 06:20:11 -05001482
Patrick Venture0b02be92018-08-31 11:55:55 -07001483 resp->data[0] = oneTimeEnabled
1484 ? SET_PARM_BOOT_FLAGS_VALID_ONE_TIME
1485 : SET_PARM_BOOT_FLAGS_VALID_PERMANENT;
ratagupta6f6bff2016-04-04 06:20:11 -05001486
ratagupta6f6bff2016-04-04 06:20:11 -05001487 rc = IPMI_CC_OK;
ratagupta6f6bff2016-04-04 06:20:11 -05001488 }
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001489 catch (InternalFailure& e)
1490 {
1491 report<InternalFailure>();
1492 *data_len = 0;
1493 return IPMI_CC_UNSPECIFIED_ERROR;
1494 }
Patrick Venture0b02be92018-08-31 11:55:55 -07001495 }
1496 else if (reqptr->parameter ==
1497 static_cast<uint8_t>(BootOptionParameter::OPAL_NETWORK_SETTINGS))
1498 {
Ratan Guptafd28dd72016-08-01 04:58:01 -05001499
Patrick Venture0b02be92018-08-31 11:55:55 -07001500 *data_len =
1501 static_cast<uint8_t>(BootOptionResponseSize::OPAL_NETWORK_SETTINGS);
Ratan Guptafd28dd72016-08-01 04:58:01 -05001502
Patrick Venture0b02be92018-08-31 11:55:55 -07001503 resp->parm =
1504 static_cast<uint8_t>(BootOptionParameter::OPAL_NETWORK_SETTINGS);
Ratan Guptafd28dd72016-08-01 04:58:01 -05001505
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001506 int ret = getHostNetworkData(resp);
Ratan Guptafd28dd72016-08-01 04:58:01 -05001507
Patrick Venture0b02be92018-08-31 11:55:55 -07001508 if (ret < 0)
1509 {
Ratan Guptafd28dd72016-08-01 04:58:01 -05001510
Aditya Saripalli5fb14602017-11-09 14:46:27 +05301511 log<level::ERR>(
Patrick Venture0b02be92018-08-31 11:55:55 -07001512 "getHostNetworkData failed for get_sys_boot_options.");
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001513 rc = IPMI_CC_UNSPECIFIED_ERROR;
Patrick Venture0b02be92018-08-31 11:55:55 -07001514 }
1515 else
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001516 rc = IPMI_CC_OK;
Ratan Guptafd28dd72016-08-01 04:58:01 -05001517 }
1518
Patrick Venture0b02be92018-08-31 11:55:55 -07001519 else
1520 {
1521 log<level::ERR>("Unsupported parameter",
1522 entry("PARAM=0x%x", reqptr->parameter));
shgoupfd84fbbf2015-12-17 10:05:51 +08001523 }
1524
1525 if (p)
1526 free(p);
1527
Ratan Guptafd28dd72016-08-01 04:58:01 -05001528 if (rc == IPMI_CC_OK)
1529 {
1530 *data_len += 2;
1531 }
1532
shgoupfd84fbbf2015-12-17 10:05:51 +08001533 return rc;
1534}
1535
shgoupfd84fbbf2015-12-17 10:05:51 +08001536ipmi_ret_t ipmi_chassis_set_sys_boot_options(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
Andrew Geisslerfca6a4f2017-05-30 10:55:39 -05001537 ipmi_request_t request,
1538 ipmi_response_t response,
1539 ipmi_data_len_t data_len,
1540 ipmi_context_t context)
shgoupfd84fbbf2015-12-17 10:05:51 +08001541{
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001542 using namespace boot_options;
shgoupfd84fbbf2015-12-17 10:05:51 +08001543 ipmi_ret_t rc = IPMI_CC_OK;
Patrick Venture0b02be92018-08-31 11:55:55 -07001544 set_sys_boot_options_t* reqptr = (set_sys_boot_options_t*)request;
shgoupfd84fbbf2015-12-17 10:05:51 +08001545
Patrick Ventureb51bf9c2018-09-10 15:53:14 -07001546 std::printf("IPMI SET_SYS_BOOT_OPTIONS reqptr->parameter =[%d]\n",
1547 reqptr->parameter);
Ratan Guptafd28dd72016-08-01 04:58:01 -05001548
shgoupfd84fbbf2015-12-17 10:05:51 +08001549 // This IPMI command does not have any resposne data
1550 *data_len = 0;
1551
1552 /* 000101
1553 * Parameter #5 means boot flags. Please refer to 28.13 of ipmi doc.
1554 * This is the only parameter used by petitboot.
1555 */
Ratan Guptafd28dd72016-08-01 04:58:01 -05001556
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001557 if (reqptr->parameter == (uint8_t)BootOptionParameter::BOOT_FLAGS)
1558 {
1559 IpmiValue bootOption = ((reqptr->data[1] & 0x3C) >> 2);
1560 using namespace chassis::internal;
1561 using namespace chassis::internal::cache;
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001562 auto oneTimeEnabled = false;
1563 constexpr auto enabledIntf = "xyz.openbmc_project.Object.Enable";
Tom Joseph57e8eb72017-09-25 18:05:02 +05301564 constexpr auto oneTimePath =
Patrick Venture0b02be92018-08-31 11:55:55 -07001565 "/xyz/openbmc_project/control/host0/boot/one_time";
shgoupfd84fbbf2015-12-17 10:05:51 +08001566
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001567 try
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001568 {
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001569 bool permanent =
1570 (reqptr->data[0] & SET_PARM_BOOT_FLAGS_PERMANENT) ==
1571 SET_PARM_BOOT_FLAGS_PERMANENT;
1572
Patrick Venture0b02be92018-08-31 11:55:55 -07001573 auto bootSetting = settings::boot::setting(objects, bootSourceIntf);
Tom Joseph57e8eb72017-09-25 18:05:02 +05301574
1575 oneTimeEnabled =
1576 std::get<settings::boot::OneTimeEnabled>(bootSetting);
1577
1578 /*
1579 * Check if the current boot setting is onetime or permanent, if the
1580 * request in the command is otherwise, then set the "Enabled"
1581 * property in one_time object path to 'True' to indicate onetime
1582 * and 'False' to indicate permanent.
1583 *
1584 * Once the onetime/permanent setting is applied, then the bootMode
1585 * and bootSource is updated for the corresponding object.
1586 */
1587 if ((permanent && oneTimeEnabled) ||
1588 (!permanent && !oneTimeEnabled))
1589 {
1590 auto service = ipmi::getService(dbus, enabledIntf, oneTimePath);
1591
Patrick Venture0b02be92018-08-31 11:55:55 -07001592 ipmi::setDbusProperty(dbus, service, oneTimePath, enabledIntf,
1593 "Enabled", !permanent);
Tom Joseph57e8eb72017-09-25 18:05:02 +05301594 }
1595
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001596 auto modeItr = modeIpmiToDbus.find(bootOption);
1597 auto sourceItr = sourceIpmiToDbus.find(bootOption);
1598 if (sourceIpmiToDbus.end() != sourceItr)
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001599 {
Marri Devender Rao81719702018-05-07 00:53:48 -05001600 rc = setBootSource(sourceItr->second);
1601 if (rc != IPMI_CC_OK)
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001602 {
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001603 *data_len = 0;
Marri Devender Rao81719702018-05-07 00:53:48 -05001604 return rc;
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001605 }
Marri Devender Rao54fa1302018-05-07 01:06:23 -05001606 // If a set boot device is mapping to a boot source, then reset
1607 // the boot mode D-Bus property to default.
1608 // This way the ipmid code can determine which property is not
1609 // at the default value
Patrick Venture0b02be92018-08-31 11:55:55 -07001610 if (sourceItr->second != Source::Sources::Default)
Marri Devender Rao54fa1302018-05-07 01:06:23 -05001611 {
1612 setBootMode(Mode::Modes::Regular);
1613 }
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001614 }
1615 if (modeIpmiToDbus.end() != modeItr)
1616 {
Marri Devender Rao81719702018-05-07 00:53:48 -05001617 rc = setBootMode(modeItr->second);
1618 if (rc != IPMI_CC_OK)
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001619 {
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001620 *data_len = 0;
Marri Devender Rao81719702018-05-07 00:53:48 -05001621 return rc;
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001622 }
Marri Devender Rao54fa1302018-05-07 01:06:23 -05001623 // If a set boot device is mapping to a boot mode, then reset
1624 // the boot source D-Bus property to default.
1625 // This way the ipmid code can determine which property is not
1626 // at the default value
Patrick Venture0b02be92018-08-31 11:55:55 -07001627 if (modeItr->second != Mode::Modes::Regular)
Marri Devender Rao54fa1302018-05-07 01:06:23 -05001628 {
1629 setBootSource(Source::Sources::Default);
1630 }
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001631 }
Jia, chunhui67c5e5d2019-05-06 11:29:54 +08001632 if ((modeIpmiToDbus.end() == modeItr) &&
1633 (sourceIpmiToDbus.end() == sourceItr))
1634 {
1635 // return error if boot option is not supported
1636 *data_len = 0;
1637 return IPMI_CC_INVALID_FIELD_REQUEST;
1638 }
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001639 }
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001640 catch (InternalFailure& e)
Deepak Kodihalli8cc19362017-07-21 11:18:38 -05001641 {
Deepak Kodihalli13791bd2017-08-28 06:50:51 -05001642 report<InternalFailure>();
1643 *data_len = 0;
1644 return IPMI_CC_UNSPECIFIED_ERROR;
shgoupfd84fbbf2015-12-17 10:05:51 +08001645 }
Patrick Venture0b02be92018-08-31 11:55:55 -07001646 }
1647 else if (reqptr->parameter ==
1648 (uint8_t)BootOptionParameter::OPAL_NETWORK_SETTINGS)
1649 {
Ratan Guptafd28dd72016-08-01 04:58:01 -05001650
1651 int ret = setHostNetworkData(reqptr);
Patrick Venture0b02be92018-08-31 11:55:55 -07001652 if (ret < 0)
1653 {
Aditya Saripalli5fb14602017-11-09 14:46:27 +05301654 log<level::ERR>(
Patrick Venture0b02be92018-08-31 11:55:55 -07001655 "setHostNetworkData failed for set_sys_boot_options");
Ratan Guptafd28dd72016-08-01 04:58:01 -05001656 rc = IPMI_CC_UNSPECIFIED_ERROR;
1657 }
Patrick Venture0b02be92018-08-31 11:55:55 -07001658 }
1659 else if (reqptr->parameter ==
1660 static_cast<uint8_t>(BootOptionParameter::BOOT_INFO))
1661 {
Tom Josephf536c902017-09-25 18:08:15 +05301662 // Handle parameter #4 and return command completed normally
1663 // (IPMI_CC_OK). There is no implementation in OpenBMC for this
1664 // parameter. This is added to support the ipmitool command `chassis
1665 // bootdev` which sends set on parameter #4, before setting the boot
1666 // flags.
1667 rc = IPMI_CC_OK;
Patrick Venture0b02be92018-08-31 11:55:55 -07001668 }
1669 else
1670 {
1671 log<level::ERR>("Unsupported parameter",
1672 entry("PARAM=0x%x", reqptr->parameter));
shgoupfd84fbbf2015-12-17 10:05:51 +08001673 rc = IPMI_CC_PARM_NOT_SUPPORTED;
Adriana Kobylak40814c62015-10-27 15:58:44 -05001674 }
1675
1676 return rc;
1677}
1678
anil kumar appanaa5a76eb2019-04-30 14:57:24 +00001679/** @brief implements Get POH counter command
1680 * @parameter
1681 * - none
1682 * @returns IPMI completion code plus response data
1683 * - minPerCount - Minutes per count
1684 * - counterReading - counter reading
1685 */
1686ipmi::RspType<uint8_t, // Minutes per count
1687 uint32_t // Counter reading
1688 >
1689 ipmiGetPOHCounter()
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05001690{
1691 // sd_bus error
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05001692 try
1693 {
anil kumar appanaa5a76eb2019-04-30 14:57:24 +00001694 return ipmi::responseSuccess(static_cast<uint8_t>(poh::minutesPerCount),
1695 getPOHCounter());
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05001696 }
1697 catch (std::exception& e)
1698 {
1699 log<level::ERR>(e.what());
anil kumar appanaa5a76eb2019-04-30 14:57:24 +00001700 return ipmi::responseUnspecifiedError();
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05001701 }
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05001702}
1703
Jason M. Billsbc996a32019-06-17 15:46:37 -07001704ipmi::RspType<uint3_t, // policy support
1705 uint5_t // reserved
1706 >
Vernon Mauerye278ead2018-10-09 09:23:43 -07001707 ipmiChassisSetPowerRestorePolicy(boost::asio::yield_context yield,
Jason M. Billsbc996a32019-06-17 15:46:37 -07001708 uint3_t policy, uint5_t reserved)
Yong Lic6713cf2018-09-12 12:35:13 +08001709{
Yong Lic6713cf2018-09-12 12:35:13 +08001710 power_policy::DbusValue value =
1711 power_policy::RestorePolicy::Policy::AlwaysOff;
1712
Jason M. Billsbc996a32019-06-17 15:46:37 -07001713 if (reserved || (policy > power_policy::noChange))
Yong Lic6713cf2018-09-12 12:35:13 +08001714 {
Vernon Mauerye278ead2018-10-09 09:23:43 -07001715 phosphor::logging::log<level::ERR>(
1716 "Reserved request parameter",
1717 entry("REQ=0x%x", static_cast<int>(policy)));
Jason M. Billsbc996a32019-06-17 15:46:37 -07001718 return ipmi::responseInvalidFieldRequest();
Yong Lic6713cf2018-09-12 12:35:13 +08001719 }
1720
Vernon Mauerye278ead2018-10-09 09:23:43 -07001721 if (policy == power_policy::noChange)
Yong Lic6713cf2018-09-12 12:35:13 +08001722 {
1723 // just return the supported policy
Jason M. Billsbc996a32019-06-17 15:46:37 -07001724 return ipmi::responseSuccess(power_policy::allSupport, reserved);
Yong Lic6713cf2018-09-12 12:35:13 +08001725 }
1726
1727 for (auto const& it : power_policy::dbusToIpmi)
1728 {
Vernon Mauerye278ead2018-10-09 09:23:43 -07001729 if (it.second == policy)
Yong Lic6713cf2018-09-12 12:35:13 +08001730 {
1731 value = it.first;
1732 break;
1733 }
1734 }
1735
1736 try
1737 {
1738 const settings::Path& powerRestoreSetting =
1739 chassis::internal::cache::objects.map
1740 .at(chassis::internal::powerRestoreIntf)
1741 .front();
Vernon Mauery16b86932019-05-01 08:36:11 -07001742 std::variant<std::string> property = convertForMessage(value);
Yong Lic6713cf2018-09-12 12:35:13 +08001743
Vernon Mauerye278ead2018-10-09 09:23:43 -07001744 auto sdbusp = getSdBus();
1745 boost::system::error_code ec;
1746 sdbusp->yield_method_call<void>(
1747 yield, ec,
Yong Lic6713cf2018-09-12 12:35:13 +08001748 chassis::internal::cache::objects
1749 .service(powerRestoreSetting,
1750 chassis::internal::powerRestoreIntf)
1751 .c_str(),
Vernon Mauerye278ead2018-10-09 09:23:43 -07001752 powerRestoreSetting, ipmi::PROP_INTF, "Set",
1753 chassis::internal::powerRestoreIntf, "PowerRestorePolicy",
1754 property);
1755 if (ec)
Yong Lic6713cf2018-09-12 12:35:13 +08001756 {
1757 phosphor::logging::log<level::ERR>("Unspecified Error");
Vernon Mauerye278ead2018-10-09 09:23:43 -07001758 return ipmi::responseUnspecifiedError();
Yong Lic6713cf2018-09-12 12:35:13 +08001759 }
1760 }
1761 catch (InternalFailure& e)
1762 {
1763 report<InternalFailure>();
Vernon Mauerye278ead2018-10-09 09:23:43 -07001764 return ipmi::responseUnspecifiedError();
Yong Lic6713cf2018-09-12 12:35:13 +08001765 }
1766
Jason M. Billsbc996a32019-06-17 15:46:37 -07001767 return ipmi::responseSuccess(power_policy::allSupport, reserved);
Yong Lic6713cf2018-09-12 12:35:13 +08001768}
1769
Adriana Kobylak40814c62015-10-27 15:58:44 -05001770void register_netfn_chassis_functions()
1771{
Marri Devender Rao6706c1c2018-05-14 00:29:38 -05001772 createIdentifyTimer();
1773
Tom05732372016-09-06 17:21:23 +05301774 // <Wildcard Command>
Patrick Venture0b02be92018-08-31 11:55:55 -07001775 ipmi_register_callback(NETFUN_CHASSIS, IPMI_CMD_WILDCARD, NULL,
1776 ipmi_chassis_wildcard, PRIVILEGE_USER);
Adriana Kobylak40814c62015-10-27 15:58:44 -05001777
Tom05732372016-09-06 17:21:23 +05301778 // Get Chassis Capabilities
Patrick Venture0b02be92018-08-31 11:55:55 -07001779 ipmi_register_callback(NETFUN_CHASSIS, IPMI_CMD_GET_CHASSIS_CAP, NULL,
1780 ipmi_get_chassis_cap, PRIVILEGE_USER);
Nan Li8d15fb42016-08-16 22:29:40 +08001781
Yong Liae4b0402018-11-02 11:12:14 +08001782 // Set Chassis Capabilities
1783 ipmi_register_callback(NETFUN_CHASSIS, IPMI_CMD_SET_CHASSIS_CAP, NULL,
1784 ipmi_set_chassis_cap, PRIVILEGE_USER);
1785
Tom05732372016-09-06 17:21:23 +05301786 // <Get System Boot Options>
Tom05732372016-09-06 17:21:23 +05301787 ipmi_register_callback(NETFUN_CHASSIS, IPMI_CMD_GET_SYS_BOOT_OPTIONS, NULL,
Patrick Venture0b02be92018-08-31 11:55:55 -07001788 ipmi_chassis_get_sys_boot_options,
1789 PRIVILEGE_OPERATOR);
Adriana Kobylak40814c62015-10-27 15:58:44 -05001790
Tom05732372016-09-06 17:21:23 +05301791 // <Get Chassis Status>
Vernon Mauery4a8a4eb2019-04-04 15:09:37 -07001792 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
1793 ipmi::chassis::cmdGetChassisStatus,
1794 ipmi::Privilege::User, ipmiGetChassisStatus);
Nan Lifdd8ec52016-08-28 03:57:40 +08001795
Tom05732372016-09-06 17:21:23 +05301796 // <Chassis Control>
anil kumar appanadafff5f2019-04-27 18:06:00 +00001797 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
1798 ipmi::chassis::cmdChassisControl,
1799 ipmi::Privilege::Operator, ipmiChassisControl);
shgoupfd84fbbf2015-12-17 10:05:51 +08001800
Tom Joseph5110c122018-03-23 17:55:40 +05301801 // <Chassis Identify>
Vernon Mauery400cc782018-10-09 13:49:53 -07001802 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
1803 ipmi::chassis::cmdChassisIdentify,
1804 ipmi::Privilege::Operator, ipmiChassisIdentify);
Tom Joseph5110c122018-03-23 17:55:40 +05301805
Tom05732372016-09-06 17:21:23 +05301806 // <Set System Boot Options>
Tom05732372016-09-06 17:21:23 +05301807 ipmi_register_callback(NETFUN_CHASSIS, IPMI_CMD_SET_SYS_BOOT_OPTIONS, NULL,
Patrick Venture0b02be92018-08-31 11:55:55 -07001808 ipmi_chassis_set_sys_boot_options,
1809 PRIVILEGE_OPERATOR);
Nagaraju Gorugantia59d83f2018-04-06 05:55:42 -05001810 // <Get POH Counter>
anil kumar appanaa5a76eb2019-04-30 14:57:24 +00001811 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
1812 ipmi::chassis::cmdGetPohCounter,
1813 ipmi::Privilege::User, ipmiGetPOHCounter);
Yong Lic6713cf2018-09-12 12:35:13 +08001814
1815 // <Set Power Restore Policy>
Vernon Mauerye278ead2018-10-09 09:23:43 -07001816 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnChassis,
1817 ipmi::chassis::cmdSetPowerRestorePolicy,
1818 ipmi::Privilege::Operator,
1819 ipmiChassisSetPowerRestorePolicy);
vishwa36993272015-11-20 12:43:49 -06001820}