1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
#include <sdbusplus/bus.hpp>
#include <phosphor-logging/log.hpp>
#include "chassis_state_manager.hpp"
namespace phosphor
{
namespace state
{
namespace manager
{
// When you see server:: you know we're referencing our base class
namespace server = sdbusplus::xyz::openbmc_project::State::server;
using namespace phosphor::logging;
constexpr auto CHASSIS_STATE_POWEROFF_TGT = "obmc-chassis-poweroff@0.target";
constexpr auto CHASSIS_STATE_HARD_POWEROFF_TGT = "obmc-chassis-hard-poweroff@0.target";
constexpr auto CHASSIS_STATE_POWERON_TGT = "obmc-chassis-poweron@0.target";
constexpr auto ACTIVE_STATE = "active";
constexpr auto ACTIVATING_STATE = "activating";
/* Map a transition to it's systemd target */
const std::map<server::Chassis::Transition,std::string> SYSTEMD_TARGET_TABLE =
{
// Use the hard off target to ensure we shutdown immediately
{server::Chassis::Transition::Off, CHASSIS_STATE_HARD_POWEROFF_TGT},
{server::Chassis::Transition::On, CHASSIS_STATE_POWERON_TGT}
};
constexpr auto SYSTEMD_SERVICE = "org.freedesktop.systemd1";
constexpr auto SYSTEMD_OBJ_PATH = "/org/freedesktop/systemd1";
constexpr auto SYSTEMD_INTERFACE = "org.freedesktop.systemd1.Manager";
constexpr auto SYSTEMD_PROPERTY_IFACE = "org.freedesktop.DBus.Properties";
constexpr auto SYSTEMD_INTERFACE_UNIT = "org.freedesktop.systemd1.Unit";
void Chassis::subscribeToSystemdSignals()
{
auto method = this->bus.new_method_call(SYSTEMD_SERVICE,
SYSTEMD_OBJ_PATH,
SYSTEMD_INTERFACE,
"Subscribe");
this->bus.call_noreply(method);
return;
}
// TODO - Will be rewritten once sdbusplus client bindings are in place
// and persistent storage design is in place and sdbusplus
// has read property function
void Chassis::determineInitialState()
{
sdbusplus::message::variant<int> pgood = -1;
auto method = this->bus.new_method_call("org.openbmc.control.Power",
"/org/openbmc/control/power0",
"org.freedesktop.DBus.Properties",
"Get");
method.append("org.openbmc.control.Power", "pgood");
auto reply = this->bus.call(method);
reply.read(pgood);
if(pgood == 1)
{
log<level::INFO>("Initial Chassis State will be On",
entry("CHASSIS_CURRENT_POWER_STATE=%s",
convertForMessage(PowerState::On).c_str()));
server::Chassis::currentPowerState(PowerState::On);
server::Chassis::requestedPowerTransition(Transition::On);
}
else
{
log<level::INFO>("Initial Chassis State will be Off",
entry("CHASSIS_CURRENT_POWER_STATE=%s",
convertForMessage(PowerState::Off).c_str()));
server::Chassis::currentPowerState(PowerState::Off);
server::Chassis::requestedPowerTransition(Transition::Off);
}
return;
}
void Chassis::executeTransition(Transition tranReq)
{
auto sysdTarget = SYSTEMD_TARGET_TABLE.find(tranReq)->second;
auto method = this->bus.new_method_call(SYSTEMD_SERVICE,
SYSTEMD_OBJ_PATH,
SYSTEMD_INTERFACE,
"StartUnit");
method.append(sysdTarget);
method.append("replace");
this->bus.call_noreply(method);
return;
}
bool Chassis::stateActive(const std::string& target)
{
sdbusplus::message::variant<std::string> currentState;
sdbusplus::message::object_path unitTargetPath;
auto method = this->bus.new_method_call(SYSTEMD_SERVICE,
SYSTEMD_OBJ_PATH,
SYSTEMD_INTERFACE,
"GetUnit");
method.append(target);
auto result = this->bus.call(method);
//Check that the bus call didn't result in an error
if(result.is_method_error())
{
log<level::ERR>("Error in bus call - could not resolve GetUnit for:",
entry(" %s", SYSTEMD_INTERFACE));
return false;
}
result.read(unitTargetPath);
method = this->bus.new_method_call(SYSTEMD_SERVICE,
static_cast<const std::string&>
(unitTargetPath).c_str(),
SYSTEMD_PROPERTY_IFACE,
"Get");
method.append(SYSTEMD_INTERFACE_UNIT, "ActiveState");
result = this->bus.call(method);
//Check that the bus call didn't result in an error
if(result.is_method_error())
{
log<level::ERR>("Error in bus call - could not resolve Get for:",
entry(" %s", SYSTEMD_PROPERTY_IFACE));
return false;
}
result.read(currentState);
if(currentState != ACTIVE_STATE && currentState != ACTIVATING_STATE)
{
//False - not active
return false;
}
//True - active
return true;
}
int Chassis::sysStateChange(sdbusplus::message::message& msg)
{
uint32_t newStateID {};
sdbusplus::message::object_path newStateObjPath;
std::string newStateUnit{};
std::string newStateResult{};
//Read the msg and populate each variable
msg.read(newStateID, newStateObjPath, newStateUnit, newStateResult);
if((newStateUnit == CHASSIS_STATE_POWEROFF_TGT) &&
(newStateResult == "done") &&
(!stateActive(CHASSIS_STATE_POWERON_TGT)))
{
log<level::INFO>("Received signal that power OFF is complete");
this->currentPowerState(server::Chassis::PowerState::Off);
}
else if((newStateUnit == CHASSIS_STATE_POWERON_TGT) &&
(newStateResult == "done") &&
(stateActive(CHASSIS_STATE_POWERON_TGT)))
{
log<level::INFO>("Received signal that power ON is complete");
this->currentPowerState(server::Chassis::PowerState::On);
}
return 0;
}
Chassis::Transition Chassis::requestedPowerTransition(Transition value)
{
log<level::INFO>("Change to Chassis Requested Power State",
entry("CHASSIS_REQUESTED_POWER_STATE=%s",
convertForMessage(value).c_str()));
executeTransition(value);
return server::Chassis::requestedPowerTransition(value);
}
Chassis::PowerState Chassis::currentPowerState(PowerState value)
{
log<level::INFO>("Change to Chassis Power State",
entry("CHASSIS_CURRENT_POWER_STATE=%s",
convertForMessage(value).c_str()));
return server::Chassis::currentPowerState(value);
}
} // namespace manager
} // namespace state
} // namepsace phosphor
|
