1 #include "side_switch.hpp"
2 
3 #include "utils.hpp"
4 
5 #include <phosphor-logging/lg2.hpp>
6 
7 #include <exception>
8 #include <string>
9 #include <thread>
10 #include <variant>
11 #include <vector>
12 
13 PHOSPHOR_LOG2_USING;
14 
sideSwitchNeeded(sdbusplus::bus_t & bus)15 bool sideSwitchNeeded(sdbusplus::bus_t& bus)
16 {
17     std::string fwRunningVersionPath;
18     uint8_t fwRunningPriority = 0;
19 
20     // Get active image
21     try
22     {
23         std::vector<std::string> paths =
24             utils::getProperty<std::vector<std::string>>(
25                 bus, "/xyz/openbmc_project/software/functional",
26                 "xyz.openbmc_project.Association", "endpoints");
27         if (paths.size() != 1)
28         {
29             info("side-switch only supports BMC-purpose image systems");
30             return (false);
31         }
32         fwRunningVersionPath = paths[0];
33         info("Running firmware version path is {FW_PATH}", "FW_PATH",
34              fwRunningVersionPath);
35     }
36     catch (const std::exception& e)
37     {
38         error("failed to retrieve active firmware version: {ERROR}", "ERROR",
39               e);
40         return (false);
41     }
42 
43     // Check if active image has highest priority (0)
44     try
45     {
46         fwRunningPriority = utils::getProperty<uint8_t>(
47             bus, fwRunningVersionPath,
48             "xyz.openbmc_project.Software.RedundancyPriority", "Priority");
49         info("Running firmware version priority is {FW_PRIORITY}",
50              "FW_PRIORITY", fwRunningPriority);
51     }
52     catch (const std::exception& e)
53     {
54         error("failed to read priority from active image: {ERROR}", "ERROR", e);
55         return (false);
56     }
57 
58     // If running at highest priority (0) then no side switch needed
59     if (fwRunningPriority == 0)
60     {
61         info("Running image is at priority 0, no side switch needed");
62         return (false);
63     }
64 
65     // Need to check if any other BMC images on system have a higher priority
66     std::vector<std::string> allSoftwarePaths;
67     try
68     {
69         auto method = bus.new_method_call(
70             "xyz.openbmc_project.ObjectMapper",
71             "/xyz/openbmc_project/object_mapper",
72             "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths");
73         method.append("/xyz/openbmc_project/software");
74         method.append(0); // Depth 0 to search all
75         method.append(
76             std::vector<std::string>({"xyz.openbmc_project.Software.Version"}));
77         auto reply = bus.call(method);
78         reply.read(allSoftwarePaths);
79         if (allSoftwarePaths.size() <= 1)
80         {
81             info("only 1 image present in flash so no side switch needed");
82             return (false);
83         }
84     }
85     catch (const std::exception& e)
86     {
87         error("failed to retrieve all firmware versions: {ERROR}", "ERROR", e);
88         return (false);
89     }
90 
91     // Cycle through all firmware images looking for a BMC version that
92     // has a higher priority then our running image
93     for (auto& fwPath : allSoftwarePaths)
94     {
95         if (fwPath == fwRunningVersionPath)
96         {
97             info("{FW_PATH} is the running image, skip", "FW_PATH", fwPath);
98             continue;
99         }
100         try
101         {
102             uint8_t thisPathPri = utils::getProperty<uint8_t>(
103                 bus, fwPath, "xyz.openbmc_project.Software.RedundancyPriority",
104                 "Priority");
105 
106             if (thisPathPri < fwRunningPriority)
107             {
108                 info(
109                     "{FW_PATH} has a higher priority, {FW_PRIORITY}, then running priority",
110                     "FW_PATH", fwPath, "FW_PRIORITY", thisPathPri);
111                 return (true);
112             }
113         }
114         catch (const std::exception& e)
115         {
116             // This could just be a host firmware image, just keep going
117             info("failed to read a BMC priority from {FW_PATH}: {ERROR}",
118                  "FW_PATH", fwPath, "ERROR", e);
119             continue;
120         }
121     }
122 
123     return (false);
124 }
125 
powerOffSystem(sdbusplus::bus_t & bus)126 bool powerOffSystem(sdbusplus::bus_t& bus)
127 {
128     try
129     {
130         utils::PropertyValue chassOff =
131             "xyz.openbmc_project.State.Chassis.Transition.Off";
132         utils::setProperty(bus, "/xyz/openbmc_project/state/chassis0",
133                            "xyz.openbmc_project.State.Chassis",
134                            "RequestedPowerTransition", chassOff);
135     }
136     catch (const std::exception& e)
137     {
138         error("chassis off request failed: {ERROR}", "ERROR", e);
139         return (false);
140     }
141 
142     // Now just wait for host and power to turn off
143     // Worst case is a systemd service hangs in power off for 2 minutes so
144     // take that and double it to avoid any timing issues. The user has
145     // requested we switch to the other side, so a lengthy delay is warranted
146     // if needed. On most systems the power off takes 5-15 seconds.
147     for (int i = 0; i < 240; i++)
148     {
149         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
150         try
151         {
152             // First wait for host to be off
153             auto currentHostState = utils::getProperty<std::string>(
154                 bus, "/xyz/openbmc_project/state/host0",
155                 "xyz.openbmc_project.State.Host", "CurrentHostState");
156 
157             if (currentHostState ==
158                 "xyz.openbmc_project.State.Host.HostState.Off")
159             {
160                 info("host is off");
161             }
162             else
163             {
164                 continue;
165             }
166 
167             // Then verify chassis power is off
168             auto currentPwrState = utils::getProperty<std::string>(
169                 bus, "/xyz/openbmc_project/state/chassis0",
170                 "xyz.openbmc_project.State.Chassis", "CurrentPowerState");
171 
172             if (currentPwrState ==
173                 "xyz.openbmc_project.State.Chassis.PowerState.Off")
174             {
175                 info("chassis power is off");
176                 return (true);
177             }
178             else
179             {
180                 continue;
181             }
182         }
183         catch (const std::exception& e)
184         {
185             error("reading chassis power state failed: {ERROR}", "ERROR", e);
186             return (false);
187         }
188     }
189     error("timeout waiting for chassis power to turn off");
190     return (false);
191 }
192 
setAutoPowerRestart(sdbusplus::bus_t & bus)193 bool setAutoPowerRestart(sdbusplus::bus_t& bus)
194 {
195     try
196     {
197         // Set the one-time power on policy to AlwaysOn so system auto boots
198         // after BMC reboot
199         utils::PropertyValue restorePolicyOn =
200             "xyz.openbmc_project.Control.Power.RestorePolicy.Policy.AlwaysOn";
201 
202         utils::setProperty(
203             bus,
204             "/xyz/openbmc_project/control/host0/power_restore_policy/one_time",
205             "xyz.openbmc_project.Control.Power.RestorePolicy",
206             "PowerRestorePolicy", restorePolicyOn);
207     }
208     catch (const std::exception& e)
209     {
210         error("setting power policy to always on failed: {ERROR}", "ERROR", e);
211         return (false);
212     }
213     info("RestorePolicy set to AlwaysOn");
214     return (true);
215 }
216 
rebootTheBmc(sdbusplus::bus_t & bus)217 bool rebootTheBmc(sdbusplus::bus_t& bus)
218 {
219     try
220     {
221         utils::PropertyValue bmcReboot =
222             "xyz.openbmc_project.State.BMC.Transition.Reboot";
223 
224         utils::setProperty(bus, "/xyz/openbmc_project/state/bmc0",
225                            "xyz.openbmc_project.State.BMC",
226                            "RequestedBMCTransition", bmcReboot);
227     }
228     catch (const std::exception& e)
229     {
230         error("rebooting the bmc failed: {ERROR}", "ERROR", e);
231         return (false);
232     }
233     info("BMC reboot initiated");
234     return (true);
235 }
236 
main()237 int main()
238 {
239     info("Checking for side switch reboot");
240 
241     auto bus = sdbusplus::bus::new_default();
242 
243     if (!sideSwitchNeeded(bus))
244     {
245         info("Side switch not needed");
246         return 0;
247     }
248 
249     if (!powerOffSystem(bus))
250     {
251         error("unable to power off chassis");
252         return 0;
253     }
254 
255     if (!setAutoPowerRestart(bus))
256     {
257         error("unable to set the auto power on restart policy");
258         // system has been powered off, best to at least continue and
259         // switch to new firmware image so continue
260     }
261 
262     if (!rebootTheBmc(bus))
263     {
264         error("unable to reboot the BMC");
265         // Return invalid rc to trigger systemd target recovery and appropriate
266         // error logging
267         return -1;
268     }
269 
270     return 0;
271 }
272