blob: e7f09789607846b02ccacee2bf02f81fc5b3e8e5 [file] [log] [blame]
Andrew Geissler769a62f2019-12-06 13:36:08 -06001#include "config.h"
Andrew Geisslere426b582020-05-28 12:40:55 -05002
Michael Tritz3ed10082017-03-20 23:28:09 -05003#include "host_state_manager.hpp"
Deepak Kodihalli55f132b2017-07-25 07:36:06 -05004#include "settings.hpp"
Andrew Geissler49e67132022-01-26 14:27:52 -06005#include "utils.hpp"
Deepak Kodihalli55f132b2017-07-25 07:36:06 -05006#include "xyz/openbmc_project/Common/error.hpp"
7#include "xyz/openbmc_project/Control/Power/RestorePolicy/server.hpp"
Michael Tritz3ed10082017-03-20 23:28:09 -05008
Andrew Geisslere426b582020-05-28 12:40:55 -05009#include <getopt.h>
10#include <systemd/sd-bus.h>
11
12#include <phosphor-logging/elog-errors.hpp>
Andrew Geissler8ffdb262021-09-20 15:25:19 -050013#include <phosphor-logging/lg2.hpp>
Andrew Geisslere426b582020-05-28 12:40:55 -050014#include <sdbusplus/exception.hpp>
15#include <sdbusplus/server.hpp>
16
17#include <iostream>
18#include <map>
19#include <string>
20
Michael Tritz3ed10082017-03-20 23:28:09 -050021namespace phosphor
22{
23namespace state
24{
25namespace manager
26{
27
Andrew Geissler8ffdb262021-09-20 15:25:19 -050028PHOSPHOR_LOG2_USING;
29
Michael Tritz3ed10082017-03-20 23:28:09 -050030using namespace phosphor::logging;
Deepak Kodihalli55f132b2017-07-25 07:36:06 -050031using namespace sdbusplus::xyz::openbmc_project::Common::Error;
32using namespace sdbusplus::xyz::openbmc_project::Control::Power::server;
Michael Tritz3ed10082017-03-20 23:28:09 -050033
Michael Tritz3ed10082017-03-20 23:28:09 -050034} // namespace manager
35} // namespace state
Andrew Geisslera965cf02018-08-31 08:37:05 -070036} // namespace phosphor
Michael Tritz3ed10082017-03-20 23:28:09 -050037
Michael Tritzd50f6572017-09-05 16:38:11 -050038int main(int argc, char** argv)
Michael Tritz3ed10082017-03-20 23:28:09 -050039{
Deepak Kodihalli55f132b2017-07-25 07:36:06 -050040 using namespace phosphor::logging;
41
Potin Laic328a4c2022-03-18 23:49:37 +080042 size_t hostId = 0;
Michael Tritzd50f6572017-09-05 16:38:11 -050043 std::string hostPath = "/xyz/openbmc_project/state/host0";
44 int arg;
45 int optIndex = 0;
46
Andrew Geissler58a18012018-01-19 19:36:05 -080047 static struct option longOpts[] = {{"host", required_argument, 0, 'h'},
48 {0, 0, 0, 0}};
Michael Tritzd50f6572017-09-05 16:38:11 -050049
Andrew Geissler58a18012018-01-19 19:36:05 -080050 while ((arg = getopt_long(argc, argv, "h:", longOpts, &optIndex)) != -1)
Michael Tritzd50f6572017-09-05 16:38:11 -050051 {
52 switch (arg)
53 {
54 case 'h':
Potin Laic328a4c2022-03-18 23:49:37 +080055 hostId = std::stoul(optarg);
Andrew Geissler58a18012018-01-19 19:36:05 -080056 hostPath =
57 std::string("/xyz/openbmc_project/state/host") + optarg;
Michael Tritzd50f6572017-09-05 16:38:11 -050058 break;
59 default:
60 break;
61 }
62 }
63
Michael Tritz3ed10082017-03-20 23:28:09 -050064 auto bus = sdbusplus::bus::new_default();
65
Deepak Kodihalli55f132b2017-07-25 07:36:06 -050066 using namespace settings;
Potin Laic328a4c2022-03-18 23:49:37 +080067 HostObjects settings(bus, hostId);
Deepak Kodihalli55f132b2017-07-25 07:36:06 -050068
Michael Tritz3ed10082017-03-20 23:28:09 -050069 using namespace phosphor::state::manager;
70 namespace server = sdbusplus::xyz::openbmc_project::State::server;
71
Andrew Geissler033fc3b2017-08-30 15:11:44 -050072 // This application is only run if chassis power is off
Michael Tritz3ed10082017-03-20 23:28:09 -050073
Andrew Geisslerb2b3d9c2022-01-26 14:45:10 -060074 // If the BMC was rebooted due to a user initiated pinhole reset, do not
75 // implement any power restore policies
76 auto bmcRebootCause = phosphor::state::manager::utils::getProperty(
77 bus, "/xyz/openbmc_project/state/bmc0", BMC_BUSNAME, "LastRebootCause");
78 if (bmcRebootCause ==
79 "xyz.openbmc_project.State.BMC.RebootCause.PinholeReset")
80 {
81 info(
82 "BMC was reset due to pinhole reset, no power restore policy will be run");
83 return 0;
84 }
Thang Q. Nguyenb669ea32022-02-22 07:15:15 +000085 else if (bmcRebootCause ==
86 "xyz.openbmc_project.State.BMC.RebootCause.Watchdog")
87 {
88 info(
89 "BMC was reset due to cold reset, no power restore policy will be run");
90 return 0;
91 }
Andrew Geisslerb2b3d9c2022-01-26 14:45:10 -060092
Andrew Geissler35ca2e32021-02-09 13:54:26 -060093 /* The logic here is to first check the one-time PowerRestorePolicy setting.
94 * If this property is not the default then look at the persistent
95 * user setting in the non one-time object, otherwise honor the one-time
96 * setting.
97 */
98 auto methodOneTime = bus.new_method_call(
99 settings.service(settings.powerRestorePolicy, powerRestoreIntf).c_str(),
100 settings.powerRestorePolicyOneTime.c_str(),
101 "org.freedesktop.DBus.Properties", "Get");
102 methodOneTime.append(powerRestoreIntf, "PowerRestorePolicy");
103
104 auto methodUserSetting = bus.new_method_call(
Andrew Geissler58a18012018-01-19 19:36:05 -0800105 settings.service(settings.powerRestorePolicy, powerRestoreIntf).c_str(),
106 settings.powerRestorePolicy.c_str(), "org.freedesktop.DBus.Properties",
107 "Get");
Andrew Geissler35ca2e32021-02-09 13:54:26 -0600108 methodUserSetting.append(powerRestoreIntf, "PowerRestorePolicy");
Anthony Wilson32c532e2018-10-25 21:56:07 -0500109
Patrick Williams2975e262020-05-13 18:01:09 -0500110 std::variant<std::string> result;
Anthony Wilson32c532e2018-10-25 21:56:07 -0500111 try
Michael Tritz3ed10082017-03-20 23:28:09 -0500112 {
Andrew Geissler35ca2e32021-02-09 13:54:26 -0600113 auto reply = bus.call(methodOneTime);
Anthony Wilson32c532e2018-10-25 21:56:07 -0500114 reply.read(result);
Andrew Geissler35ca2e32021-02-09 13:54:26 -0600115 auto powerPolicy = std::get<std::string>(result);
116
117 if (RestorePolicy::Policy::None ==
118 RestorePolicy::convertPolicyFromString(powerPolicy))
119 {
120 // one_time is set to None so use the customer setting
Andrew Geissler8ffdb262021-09-20 15:25:19 -0500121 info("One time not set, check user setting of power policy");
Andrew Geissler35ca2e32021-02-09 13:54:26 -0600122 auto reply = bus.call(methodUserSetting);
123 reply.read(result);
124 powerPolicy = std::get<std::string>(result);
125 }
126 else
127 {
128 // one_time setting was set so we're going to use it. Reset it
129 // to default for next time.
Andrew Geissler8ffdb262021-09-20 15:25:19 -0500130 info("One time set, use it and reset to default");
Andrew Geissler49e67132022-01-26 14:27:52 -0600131 phosphor::state::manager::utils::setProperty(
132 bus, settings.powerRestorePolicyOneTime.c_str(),
133 powerRestoreIntf, "PowerRestorePolicy",
134 convertForMessage(RestorePolicy::Policy::None));
Andrew Geissler35ca2e32021-02-09 13:54:26 -0600135 }
136
Andrew Geissler8ffdb262021-09-20 15:25:19 -0500137 info("Host power is off, processing power policy {POWER_POLICY}",
138 "POWER_POLICY", powerPolicy);
Andrew Geissler35ca2e32021-02-09 13:54:26 -0600139
140 if (RestorePolicy::Policy::AlwaysOn ==
141 RestorePolicy::convertPolicyFromString(powerPolicy))
142 {
Andrew Geissler8ffdb262021-09-20 15:25:19 -0500143 info("power_policy=ALWAYS_POWER_ON, powering host on");
Andrew Geissler49e67132022-01-26 14:27:52 -0600144 phosphor::state::manager::utils::setProperty(
145 bus, hostPath, HOST_BUSNAME, "RestartCause",
146 convertForMessage(
147 server::Host::RestartCause::PowerPolicyAlwaysOn));
148 phosphor::state::manager::utils::setProperty(
149 bus, hostPath, HOST_BUSNAME, "RequestedHostTransition",
150 convertForMessage(server::Host::Transition::On));
Andrew Geissler35ca2e32021-02-09 13:54:26 -0600151 }
Thang Tran1fc48452022-02-08 16:04:11 +0700152 else if (RestorePolicy::Policy::AlwaysOff ==
153 RestorePolicy::convertPolicyFromString(powerPolicy))
154 {
155 info("power_policy=ALWAYS_POWER_OFF, set requested state to off");
Thang Tran6810ad52022-02-24 09:36:57 +0700156 // Read last requested state and re-request it to execute it
157 auto hostReqState = phosphor::state::manager::utils::getProperty(
158 bus, hostPath, HOST_BUSNAME, "RequestedHostTransition");
159 if (hostReqState == convertForMessage(server::Host::Transition::On))
160 {
161 phosphor::state::manager::utils::setProperty(
162 bus, hostPath, HOST_BUSNAME, "RequestedHostTransition",
163 convertForMessage(server::Host::Transition::Off));
164 }
Thang Tran1fc48452022-02-08 16:04:11 +0700165 }
Andrew Geissler35ca2e32021-02-09 13:54:26 -0600166 else if (RestorePolicy::Policy::Restore ==
167 RestorePolicy::convertPolicyFromString(powerPolicy))
168 {
Andrew Geissler8ffdb262021-09-20 15:25:19 -0500169 info("power_policy=RESTORE, restoring last state");
Andrew Geissler35ca2e32021-02-09 13:54:26 -0600170 // Read last requested state and re-request it to execute it
Andrew Geissler49e67132022-01-26 14:27:52 -0600171 auto hostReqState = phosphor::state::manager::utils::getProperty(
172 bus, hostPath, HOST_BUSNAME, "RequestedHostTransition");
Thang Tran6810ad52022-02-24 09:36:57 +0700173 if (hostReqState == convertForMessage(server::Host::Transition::On))
174 {
175 phosphor::state::manager::utils::setProperty(
176 bus, hostPath, HOST_BUSNAME, "RestartCause",
177 convertForMessage(
178 server::Host::RestartCause::PowerPolicyPreviousState));
179 phosphor::state::manager::utils::setProperty(
180 bus, hostPath, HOST_BUSNAME, "RequestedHostTransition",
181 hostReqState);
182 }
Andrew Geissler35ca2e32021-02-09 13:54:26 -0600183 }
Anthony Wilson32c532e2018-10-25 21:56:07 -0500184 }
Patrick Williams0a675212021-09-02 09:49:43 -0500185 catch (const sdbusplus::exception::exception& e)
Anthony Wilson32c532e2018-10-25 21:56:07 -0500186 {
Andrew Geissler8ffdb262021-09-20 15:25:19 -0500187 error("Error in PowerRestorePolicy Get: {ERROR}", "ERROR", e);
Andrew Geissler033fc3b2017-08-30 15:11:44 -0500188 elog<InternalFailure>();
189 }
Deepak Kodihalli55f132b2017-07-25 07:36:06 -0500190
Michael Tritz3ed10082017-03-20 23:28:09 -0500191 return 0;
192}