blob: 0c4b7408586ff63071d7a6368679018979e28cd0 [file] [log] [blame]
Patrick Venturebf58cd62018-12-11 09:05:46 -08001/*
2 * Copyright 2018 Google Inc.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "updater.hpp"
18
Patrick Ventured61b0ff2019-05-15 15:58:06 -070019#include "firmware_handler.hpp"
Patrick Venture3ecb3502019-05-17 11:03:51 -070020#include "status.hpp"
Patrick Venture2bc23fe2018-12-13 10:16:36 -080021#include "tool_errors.hpp"
Patrick Venture7dad86f2019-05-17 08:52:20 -070022#include "util.hpp"
Patrick Venture0533d0b2018-12-13 08:48:24 -080023
Patrick Venture00887592018-12-11 10:57:06 -080024#include <algorithm>
Patrick Venture664c5bc2019-03-07 08:09:45 -080025#include <blobs-ipmid/blobs.hpp>
Patrick Venture339dece2018-12-14 18:32:04 -080026#include <cstring>
Patrick Venture664c5bc2019-03-07 08:09:45 -080027#include <ipmiblob/blob_errors.hpp>
Patrick Ventureaf696252018-12-11 10:22:14 -080028#include <memory>
Patrick Venture2a927e82019-02-01 07:29:47 -080029#include <string>
Patrick Ventured61b0ff2019-05-15 15:58:06 -070030#include <thread>
Patrick Venture55646de2019-05-16 10:06:26 -070031#include <vector>
Patrick Ventureaf696252018-12-11 10:22:14 -080032
Patrick Venture9b534f02018-12-13 16:10:02 -080033namespace host_tool
34{
35
Patrick Venture55646de2019-05-16 10:06:26 -070036bool UpdateHandler::checkAvailable(const std::string& goalFirmware)
37{
38 std::vector<std::string> blobs = blob->getBlobList();
39
40 auto blobInst = std::find_if(
41 blobs.begin(), blobs.end(), [&goalFirmware](const std::string& iter) {
42 /* Running into weird scenarios where the string comparison doesn't
43 * work. TODO: revisit.
44 */
45 return (0 == std::memcmp(goalFirmware.c_str(), iter.c_str(),
46 goalFirmware.length()));
47 // return (goalFirmware.compare(iter));
48 });
49 if (blobInst == blobs.end())
50 {
51 std::fprintf(stderr, "%s not found\n", goalFirmware.c_str());
52 return false;
53 }
54
55 /* Call stat on /flash/image (or /flash/tarball) and check if data interface
56 * is supported.
57 */
58 ipmiblob::StatResponse stat;
59
60 try
61 {
62 stat = blob->getStat(goalFirmware);
63 }
64 catch (const ipmiblob::BlobException& b)
65 {
66 std::fprintf(stderr, "Received exception '%s' on getStat\n", b.what());
67 return false;
68 }
69
70 auto supported = handler->supportedType();
71 if ((stat.blob_state & supported) == 0)
72 {
73 std::fprintf(stderr, "data interface selected not supported.\n");
74 return false;
75 }
76
77 return true;
78}
79
80void UpdateHandler::sendFile(const std::string& target, const std::string& path)
81{
82 std::uint16_t session;
83 auto supported = handler->supportedType();
84
85 try
86 {
87 session = blob->openBlob(
88 target, static_cast<std::uint16_t>(supported) |
89 static_cast<std::uint16_t>(blobs::OpenFlags::write));
90 }
91 catch (const ipmiblob::BlobException& b)
92 {
93 throw ToolException("blob exception received: " +
94 std::string(b.what()));
95 }
96
97 if (!handler->sendContents(path, session))
98 {
99 /* Need to close the session on failure, or it's stuck open (until the
100 * blob handler timeout is implemented, and even then, why make it wait.
101 */
102 blob->closeBlob(session);
103 throw ToolException("Failed to send contents of " + path);
104 }
105
106 blob->closeBlob(session);
107}
108
Patrick Ventured61b0ff2019-05-15 15:58:06 -0700109/* Poll an open verification session. Handling closing the session is not yet
Patrick Venture1f09d412019-06-19 16:01:06 -0700110 * owned by this method.
111 */
Patrick Venture14713be2019-06-05 13:42:28 -0700112bool pollStatus(std::uint16_t session, ipmiblob::BlobInterface* blob)
Patrick Ventured61b0ff2019-05-15 15:58:06 -0700113{
114 using namespace std::chrono_literals;
115
116 static constexpr auto verificationSleep = 5s;
Patrick Ventureda66fd82019-06-03 11:11:24 -0700117 ipmi_flash::ActionStatus result = ipmi_flash::ActionStatus::unknown;
Patrick Ventured61b0ff2019-05-15 15:58:06 -0700118
119 try
120 {
Patrick Venturec6744742019-05-28 15:57:21 -0700121 static constexpr int commandAttempts = 20;
122 int attempts = 0;
123 bool exitLoop = false;
124
Patrick Ventured61b0ff2019-05-15 15:58:06 -0700125 /* Reach back the current status from the verification service output.
126 */
127 while (attempts++ < commandAttempts)
128 {
129 ipmiblob::StatResponse resp = blob->getStat(session);
130
131 if (resp.metadata.size() != sizeof(std::uint8_t))
132 {
133 /* TODO: How do we want to handle the verification failures,
134 * because closing the session to the verify blob has a special
135 * as-of-yet not fully defined behavior.
136 */
137 std::fprintf(stderr, "Received invalid metadata response!!!\n");
138 }
139
Patrick Ventureda66fd82019-06-03 11:11:24 -0700140 result = static_cast<ipmi_flash::ActionStatus>(resp.metadata[0]);
Patrick Ventured61b0ff2019-05-15 15:58:06 -0700141
142 switch (result)
143 {
Patrick Ventureda66fd82019-06-03 11:11:24 -0700144 case ipmi_flash::ActionStatus::failed:
Patrick Ventured61b0ff2019-05-15 15:58:06 -0700145 std::fprintf(stderr, "failed\n");
146 exitLoop = true;
147 break;
Patrick Ventureda66fd82019-06-03 11:11:24 -0700148 case ipmi_flash::ActionStatus::unknown:
Patrick Ventured61b0ff2019-05-15 15:58:06 -0700149 std::fprintf(stderr, "other\n");
150 break;
Patrick Ventureda66fd82019-06-03 11:11:24 -0700151 case ipmi_flash::ActionStatus::running:
Patrick Ventured61b0ff2019-05-15 15:58:06 -0700152 std::fprintf(stderr, "running\n");
153 break;
Patrick Ventureda66fd82019-06-03 11:11:24 -0700154 case ipmi_flash::ActionStatus::success:
Patrick Ventured61b0ff2019-05-15 15:58:06 -0700155 std::fprintf(stderr, "success\n");
156 exitLoop = true;
157 break;
158 default:
159 std::fprintf(stderr, "wat\n");
160 }
161
162 if (exitLoop)
163 {
164 break;
165 }
166 std::this_thread::sleep_for(verificationSleep);
167 }
168 }
169 catch (const ipmiblob::BlobException& b)
170 {
171 throw ToolException("blob exception received: " +
172 std::string(b.what()));
173 }
174
175 /* TODO: If this is reached and it's not success, it may be worth just
176 * throwing a ToolException with a timeout message specifying the final
177 * read's value.
178 *
179 * TODO: Given that excepting from certain points leaves the BMC update
180 * state machine in an inconsistent state, we need to carefully evaluate
181 * which exceptions from the lower layers allow one to try and delete the
182 * blobs to rollback the state and progress.
183 */
Patrick Ventureda66fd82019-06-03 11:11:24 -0700184 return (result == ipmi_flash::ActionStatus::success);
Patrick Ventured61b0ff2019-05-15 15:58:06 -0700185}
186
Patrick Venture55646de2019-05-16 10:06:26 -0700187bool UpdateHandler::verifyFile(const std::string& target)
Patrick Venturebf58cd62018-12-11 09:05:46 -0800188{
Patrick Venture0533d0b2018-12-13 08:48:24 -0800189 std::uint16_t session;
Patrick Venture55646de2019-05-16 10:06:26 -0700190 bool success = false;
191
Patrick Venture0533d0b2018-12-13 08:48:24 -0800192 try
193 {
Patrick Venture664c5bc2019-03-07 08:09:45 -0800194 session = blob->openBlob(
Patrick Venture55646de2019-05-16 10:06:26 -0700195 target, static_cast<std::uint16_t>(blobs::OpenFlags::write));
Patrick Venture7dcca5d2019-05-15 12:32:33 -0700196 }
197 catch (const ipmiblob::BlobException& b)
198 {
199 throw ToolException("blob exception received: " +
200 std::string(b.what()));
201 }
202
Patrick Venturef6ea2e82019-06-12 12:57:47 -0700203 std::fprintf(stderr, "Committing to %s to trigger service\n",
204 target.c_str());
Patrick Venture55646de2019-05-16 10:06:26 -0700205
Patrick Venture7dcca5d2019-05-15 12:32:33 -0700206 try
207 {
208 blob->commit(session, {});
209 }
210 catch (const ipmiblob::BlobException& b)
211 {
212 throw ToolException("blob exception received: " +
213 std::string(b.what()));
214 }
215
Patrick Venturef6ea2e82019-06-12 12:57:47 -0700216 std::fprintf(stderr, "Calling stat on %s session to check status\n",
217 target.c_str());
Patrick Venture7dcca5d2019-05-15 12:32:33 -0700218
Patrick Venture14713be2019-06-05 13:42:28 -0700219 if (pollStatus(session, blob))
Patrick Ventured61b0ff2019-05-15 15:58:06 -0700220 {
Patrick Venturef6ea2e82019-06-12 12:57:47 -0700221 std::fprintf(stderr, "Returned success\n");
Patrick Venture55646de2019-05-16 10:06:26 -0700222 success = true;
Patrick Ventured61b0ff2019-05-15 15:58:06 -0700223 }
224 else
225 {
Patrick Venturef6ea2e82019-06-12 12:57:47 -0700226 std::fprintf(stderr, "Returned non-success (could still "
Patrick Ventured61b0ff2019-05-15 15:58:06 -0700227 "be running (unlikely))\n");
228 }
229
Patrick Venture7dcca5d2019-05-15 12:32:33 -0700230 blob->closeBlob(session);
Patrick Venture55646de2019-05-16 10:06:26 -0700231 return (success == true);
232}
233
Patrick Venture5f2fcc42019-06-20 07:21:05 -0700234void UpdateHandler::cleanArtifacts()
235{
236 /* open(), commit(), close() */
237 std::uint16_t session;
238
239 /* Errors aren't important for this call. */
240 try
241 {
242 std::fprintf(stderr, "Opening the cleanup blob\n");
243 session =
244 blob->openBlob(ipmi_flash::cleanupBlobId,
245 static_cast<std::uint16_t>(blobs::OpenFlags::write));
246 std::fprintf(stderr, "Committing to the cleanup blob\n");
247 blob->commit(session, {});
248 std::fprintf(stderr, "Closing cleanup blob\n");
249 blob->closeBlob(session);
250 }
251 catch (...)
252 {
253 }
254}
255
Patrick Venture1f09d412019-06-19 16:01:06 -0700256void updaterMain(UpdateHandlerInterface* updater, const std::string& imagePath,
Patrick Venture55646de2019-05-16 10:06:26 -0700257 const std::string& signaturePath)
258{
259 /* TODO(venture): Add optional parameter to specify the flash type, default
260 * to legacy for now.
Patrick Venture55646de2019-05-16 10:06:26 -0700261 */
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700262 bool goalSupported =
263 updater->checkAvailable(ipmi_flash::staticLayoutBlobId);
Patrick Venture55646de2019-05-16 10:06:26 -0700264 if (!goalSupported)
265 {
266 throw ToolException("Goal firmware or interface not supported");
267 }
268
269 /* Yay, our data handler is supported. */
Patrick Venture5f2fcc42019-06-20 07:21:05 -0700270 try
Patrick Venture55646de2019-05-16 10:06:26 -0700271 {
Patrick Venture14713be2019-06-05 13:42:28 -0700272
Patrick Venture5f2fcc42019-06-20 07:21:05 -0700273 /* Send over the firmware image. */
274 std::fprintf(stderr, "Sending over the firmware image.\n");
275 updater->sendFile(ipmi_flash::staticLayoutBlobId, imagePath);
276
277 /* Send over the hash contents. */
278 std::fprintf(stderr, "Sending over the hash file.\n");
279 updater->sendFile(ipmi_flash::hashBlobId, signaturePath);
280
281 /* Trigger the verification by opening and committing the verify file.
Patrick Venture14713be2019-06-05 13:42:28 -0700282 */
Patrick Venture5f2fcc42019-06-20 07:21:05 -0700283 std::fprintf(stderr, "Opening the verification file\n");
284 if (updater->verifyFile(ipmi_flash::verifyBlobId))
285 {
286 std::fprintf(stderr, "succeeded\n");
287 }
288 else
289 {
290 std::fprintf(stderr, "failed\n");
291 throw ToolException("Verification failed");
292 }
293
294 /* Trigger the update by opening and committing the update file. */
295 std::fprintf(stderr, "Opening the update file\n");
296 if (updater->verifyFile(ipmi_flash::updateBlobId))
297 {
298 std::fprintf(stderr, "succeeded\n");
299 }
300 else
301 {
302 /* Depending on the update mechanism used, this may be
303 * uninteresting. For instance, for the static layout, we use the
304 * reboot update mechanism. Which doesn't always lead to a
305 * successful return before the BMC starts shutting down services.
306 */
307 std::fprintf(stderr, "failed\n");
308 throw ToolException("Update failed");
309 }
310 }
311 catch (...)
312 {
313 updater->cleanArtifacts();
314 throw;
Patrick Venture55646de2019-05-16 10:06:26 -0700315 }
Patrick Venturebf58cd62018-12-11 09:05:46 -0800316}
Patrick Venture9b534f02018-12-13 16:10:02 -0800317
318} // namespace host_tool