1 #pragma once
2 
3 #include "config.h"
4 
5 #include "xyz/openbmc_project/State/Chassis/server.hpp"
6 #include "xyz/openbmc_project/State/PowerOnHours/server.hpp"
7 
8 #include <cereal/cereal.hpp>
9 #include <sdbusplus/bus.hpp>
10 #include <sdeventplus/clock.hpp>
11 #include <sdeventplus/event.hpp>
12 #include <sdeventplus/utility/timer.hpp>
13 
14 #include <chrono>
15 #include <filesystem>
16 #include <functional>
17 
18 namespace phosphor
19 {
20 namespace state
21 {
22 namespace manager
23 {
24 
25 using ChassisInherit = sdbusplus::server::object::object<
26     sdbusplus::xyz::openbmc_project::State::server::Chassis,
27     sdbusplus::xyz::openbmc_project::State::server::PowerOnHours>;
28 namespace sdbusRule = sdbusplus::bus::match::rules;
29 namespace fs = std::filesystem;
30 
31 /** @class Chassis
32  *  @brief OpenBMC chassis state management implementation.
33  *  @details A concrete implementation for xyz.openbmc_project.State.Chassis
34  *  DBus API.
35  */
36 class Chassis : public ChassisInherit
37 {
38   public:
39     /** @brief Constructs Chassis State Manager
40      *
41      * @note This constructor passes 'true' to the base class in order to
42      *       defer dbus object registration until we can run
43      *       determineInitialState() and set our properties
44      *
45      * @param[in] bus       - The Dbus bus object
46      * @param[in] objPath   - The Dbus object path
47      * @param[in] id        - Chassis id
48      */
49     Chassis(sdbusplus::bus::bus& bus, const char* objPath, size_t id) :
50         ChassisInherit(bus, objPath, ChassisInherit::action::defer_emit),
51         bus(bus),
52         systemdSignals(
53             bus,
54             sdbusRule::type::signal() + sdbusRule::member("JobRemoved") +
55                 sdbusRule::path("/org/freedesktop/systemd1") +
56                 sdbusRule::interface("org.freedesktop.systemd1.Manager"),
57             std::bind(std::mem_fn(&Chassis::sysStateChange), this,
58                       std::placeholders::_1)),
59         id(id), pohTimer(sdeventplus::Event::get_default(),
60                          std::bind(&Chassis::pohCallback, this),
61                          std::chrono::hours{1}, std::chrono::minutes{1})
62     {
63         subscribeToSystemdSignals();
64 
65         createSystemdTargetTable();
66 
67         restoreChassisStateChangeTime();
68 
69         determineInitialState();
70 
71         restorePOHCounter(); // restore POHCounter from persisted file
72 
73         // We deferred this until we could get our property correct
74         this->emit_object_added();
75     }
76 
77     /** @brief Set value of RequestedPowerTransition */
78     Transition requestedPowerTransition(Transition value) override;
79 
80     /** @brief Set value of CurrentPowerState */
81     PowerState currentPowerState(PowerState value) override;
82 
83     /** @brief Get value of POHCounter */
84     using ChassisInherit::pohCounter;
85 
86     /** @brief Increment POHCounter if Chassis Power state is ON */
87     void startPOHCounter();
88 
89   private:
90     /** @brief Create systemd target instance names and mapping table */
91     void createSystemdTargetTable();
92 
93     /** @brief Determine initial chassis state and set internally */
94     void determineInitialState();
95 
96     /** @brief Determine status of power into system by examining all the
97      *        power-related interfaces of interest
98      */
99     void determineStatusOfPower();
100 
101     /** @brief Determine status of power provided by an Uninterruptible Power
102      *         Supply into the system
103      */
104     void determineStatusOfUPSPower();
105 
106     /** @brief Determine status of power provided by the power supply units into
107      *         the system
108      */
109     void determineStatusOfPSUPower();
110 
111     /**
112      * @brief subscribe to the systemd signals
113      *
114      * This object needs to capture when it's systemd targets complete
115      * so it can keep it's state updated
116      *
117      **/
118     void subscribeToSystemdSignals();
119 
120     /** @brief Start the systemd unit requested
121      *
122      * This function calls `StartUnit` on the systemd unit given.
123      *
124      * @param[in] sysdUnit    - Systemd unit
125      */
126     void startUnit(const std::string& sysdUnit);
127 
128     /**
129      * @brief Determine if target is active
130      *
131      * This function determines if the target is active and
132      * helps prevent misleading log recorded states.
133      *
134      * @param[in] target - Target string to check on
135      *
136      * @return boolean corresponding to state active
137      **/
138     bool stateActive(const std::string& target);
139 
140     /** @brief Check if systemd state change is relevant to this object
141      *
142      * Instance specific interface to handle the detected systemd state
143      * change
144      *
145      * @param[in]  msg       - Data associated with subscribed signal
146      *
147      */
148     int sysStateChange(sdbusplus::message::message& msg);
149 
150     /** @brief Persistent sdbusplus DBus connection. */
151     sdbusplus::bus::bus& bus;
152 
153     /** @brief Used to subscribe to dbus systemd signals **/
154     sdbusplus::bus::match_t systemdSignals;
155 
156     /** @brief Watch for any changes to UPS properties **/
157     std::unique_ptr<sdbusplus::bus::match_t> uPowerPropChangeSignal;
158 
159     /** @brief Watch for any changes to PowerSystemInputs properties **/
160     std::unique_ptr<sdbusplus::bus::match_t> powerSysInputsPropChangeSignal;
161 
162     /** @brief Chassis id. **/
163     const size_t id = 0;
164 
165     /** @brief Transition state to systemd target mapping table. **/
166     std::map<Transition, std::string> systemdTargetTable;
167 
168     /** @brief Used to Set value of POHCounter */
169     uint32_t pohCounter(uint32_t value) override;
170 
171     /** @brief Used by the timer to update the POHCounter */
172     void pohCallback();
173 
174     /** @brief Used to restore POHCounter value from persisted file */
175     void restorePOHCounter();
176 
177     /** @brief Serialize and persist requested POH counter.
178      *
179      *  @return fs::path - pathname of persisted requested POH counter.
180      */
181     fs::path serializePOH();
182 
183     /** @brief Deserialize a persisted requested POH counter.
184      *
185      *  @param[in] retCounter - deserialized POH counter value
186      *
187      *  @return bool - true if the deserialization was successful, false
188      *                 otherwise.
189      */
190     bool deserializePOH(uint32_t& retCounter);
191 
192     /** @brief Sets the LastStateChangeTime property and persists it. */
193     void setStateChangeTime();
194 
195     /** @brief Serialize the last power state change time.
196      *
197      *  Save the time the state changed and the state itself.
198      *  The state needs to be saved as well so that during rediscovery
199      *  on reboots there's a way to know not to update the time again.
200      */
201     void serializeStateChangeTime();
202 
203     /** @brief Deserialize the last power state change time.
204      *
205      *  @param[out] time - Deserialized time
206      *  @param[out] state - Deserialized power state
207      *
208      *  @return bool - true if successful, false otherwise.
209      */
210     bool deserializeStateChangeTime(uint64_t& time, PowerState& state);
211 
212     /** @brief Restores the power state change time.
213      *
214      *  The time is loaded into the LastStateChangeTime D-Bus property.
215      *  On the very first start after this code has been applied but
216      *  before the state has changed, the LastStateChangeTime value
217      *  will be zero.
218      */
219     void restoreChassisStateChangeTime();
220 
221     /** @brief Timer used for tracking power on hours */
222     sdeventplus::utility::Timer<sdeventplus::ClockId::Monotonic> pohTimer;
223 
224     /** @brief Function to check for a standby voltage regulator fault
225      *
226      *  Determine if a standby voltage regulator fault was detected and
227      *  return true or false accordingly.
228      *
229      *  @return true if fault detected, else false
230      */
231     bool standbyVoltageRegulatorFault();
232 
233     /** @brief Process UPS property changes
234      *
235      * Instance specific interface to monitor for changes to the UPS
236      * properties which may impact CurrentPowerStatus
237      *
238      * @param[in]  msg              - Data associated with subscribed signal
239      *
240      */
241     void uPowerChangeEvent(sdbusplus::message::message& msg);
242 
243     /** @brief Process PowerSystemInputs property changes
244      *
245      * Instance specific interface to monitor for changes to the
246      * PowerSystemInputs properties which may impact CurrentPowerStatus
247      *
248      * @param[in]  msg              - Data associated with subscribed signal
249      *
250      */
251     void powerSysInputsChangeEvent(sdbusplus::message::message& msg);
252 };
253 
254 } // namespace manager
255 } // namespace state
256 } // namespace phosphor
257