blob: 9cb78fb576aba8edb7e506775f8499d9eef98ca2 [file] [log] [blame]
Patrick Venture22e38752018-11-21 08:52:49 -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
Patrick Venturec7ca2912018-11-02 11:38:33 -070017#include "firmware_handler.hpp"
18
Patrick Venturea78e39f2018-11-06 18:37:06 -080019#include "image_handler.hpp"
Patrick Venture7dad86f2019-05-17 08:52:20 -070020#include "util.hpp"
Patrick Venture26a17262019-05-20 11:03:35 -070021#include "verify.hpp"
Patrick Venturea78e39f2018-11-06 18:37:06 -080022
Patrick Venture137ad2c2018-11-06 11:30:43 -080023#include <algorithm>
Patrick Venture192d60f2018-11-06 11:11:59 -080024#include <cstdint>
Patrick Venture18235e62018-11-08 10:21:09 -080025#include <cstring>
Patrick Ventureb3b4db72019-05-15 11:30:24 -070026#include <fstream>
Patrick Venture68cf64f2018-11-06 10:46:51 -080027#include <memory>
Patrick Ventured333a872018-12-03 16:24:26 -080028#include <phosphor-logging/log.hpp>
Patrick Venturefa6c4d92018-11-02 18:34:53 -070029#include <string>
30#include <vector>
31
Patrick Ventured333a872018-12-03 16:24:26 -080032using namespace phosphor::logging;
33
Patrick Venture1d5a31c2019-05-20 11:38:22 -070034namespace ipmi_flash
Patrick Venturec7ca2912018-11-02 11:38:33 -070035{
Patrick Ventureb3b4db72019-05-15 11:30:24 -070036
Patrick Venture1d5a31c2019-05-20 11:38:22 -070037std::unique_ptr<blobs::GenericBlobInterface>
Patrick Venture148cd652018-11-06 10:59:47 -080038 FirmwareBlobHandler::CreateFirmwareBlobHandler(
Patrick Venture3ecb3502019-05-17 11:03:51 -070039 const std::vector<HandlerPack>& firmwares,
Patrick Venture74059d62019-05-17 10:40:26 -070040 const std::vector<DataHandlerPack>& transports,
Patrick Venture27ac5822019-05-20 17:39:31 -070041 std::unique_ptr<VerificationInterface> verification,
42 std::unique_ptr<UpdateInterface> update)
Patrick Venture68cf64f2018-11-06 10:46:51 -080043{
Patrick Venture52854622018-11-06 12:30:00 -080044 /* There must be at least one. */
45 if (!firmwares.size())
46 {
Patrick Ventured333a872018-12-03 16:24:26 -080047 log<level::ERR>("Must provide at least one firmware handler.");
Patrick Venture52854622018-11-06 12:30:00 -080048 return nullptr;
49 }
Patrick Venture1cde5f92018-11-07 08:26:47 -080050 if (!transports.size())
51 {
52 return nullptr;
53 }
Patrick Venture52854622018-11-06 12:30:00 -080054
Patrick Venturea78e39f2018-11-06 18:37:06 -080055 std::vector<std::string> blobs;
56 for (const auto& item : firmwares)
57 {
58 blobs.push_back(item.blobName);
59 }
Patrick Venture18235e62018-11-08 10:21:09 -080060
Patrick Venture7dad86f2019-05-17 08:52:20 -070061 if (0 == std::count(blobs.begin(), blobs.end(), hashBlobId))
Patrick Venture18235e62018-11-08 10:21:09 -080062 {
63 return nullptr;
64 }
Patrick Venture4cceb8e2018-11-06 11:56:48 -080065
Patrick Venture1cde5f92018-11-07 08:26:47 -080066 std::uint16_t bitmask = 0;
67 for (const auto& item : transports)
68 {
69 /* TODO: can use std::accumulate() unless I'm mistaken. :D */
70 bitmask |= item.bitmask;
71 }
72
Patrick Venture3ecb3502019-05-17 11:03:51 -070073 return std::make_unique<FirmwareBlobHandler>(
Patrick Venture27ac5822019-05-20 17:39:31 -070074 firmwares, blobs, transports, bitmask, std::move(verification),
75 std::move(update));
Patrick Venture68cf64f2018-11-06 10:46:51 -080076}
77
Patrick Ventured6461d62018-11-09 17:30:25 -080078/* Check if the path is in our supported list (or active list). */
Patrick Venturec7ca2912018-11-02 11:38:33 -070079bool FirmwareBlobHandler::canHandleBlob(const std::string& path)
80{
Patrick Venture6032dc02019-05-17 11:01:44 -070081 return (std::count(blobIDs.begin(), blobIDs.end(), path) > 0);
Patrick Venturec7ca2912018-11-02 11:38:33 -070082}
Patrick Venture53977962018-11-02 18:59:35 -070083
Patrick Ventured6461d62018-11-09 17:30:25 -080084/*
85 * Grab the list of supported firmware.
86 *
87 * If there's an open firmware session, it'll already be present in the
88 * list as "/flash/active/image", and if the hash has started,
89 * "/flash/active/hash" regardless of mechanism. This is done in the open
90 * comamnd, no extra work is required here.
91 */
Patrick Venturec7ca2912018-11-02 11:38:33 -070092std::vector<std::string> FirmwareBlobHandler::getBlobIds()
93{
Patrick Venture4cceb8e2018-11-06 11:56:48 -080094 return blobIDs;
Patrick Venturec7ca2912018-11-02 11:38:33 -070095}
Patrick Venture53977962018-11-02 18:59:35 -070096
Patrick Ventured6461d62018-11-09 17:30:25 -080097/*
98 * Per the design, this mean abort, and this will trigger whatever
99 * appropriate actions are required to abort the process.
Patrick Venture9e5aab22018-11-09 20:49:28 -0800100 *
101 * You cannot delete a blob that has an open handle in the system, therefore
102 * this is never called if there's an open session. Guaranteed by the blob
103 * manager.
Patrick Ventured6461d62018-11-09 17:30:25 -0800104 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700105bool FirmwareBlobHandler::deleteBlob(const std::string& path)
106{
Patrick Venture9e5aab22018-11-09 20:49:28 -0800107 const std::string* toDelete;
108
Patrick Ventureffcc5502018-11-16 12:32:38 -0800109 /* You cannot delete the verify blob -- trying to delete it, currently has
110 * no impact.
111 * TODO: Should trying to delete this cause an abort?
112 */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700113 if (path == verifyBlobId)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800114 {
115 return false;
116 }
117
Patrick Venture7dad86f2019-05-17 08:52:20 -0700118 if (path == hashBlobId || path == activeHashBlobId)
Patrick Venture9e5aab22018-11-09 20:49:28 -0800119 {
120 /* They're deleting the hash. */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700121 toDelete = &activeHashBlobId;
Patrick Venture9e5aab22018-11-09 20:49:28 -0800122 }
123 else
124 {
125 /* They're deleting the image. */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700126 toDelete = &activeImageBlobId;
Patrick Venture9e5aab22018-11-09 20:49:28 -0800127 }
128
129 auto it = std::find_if(
130 blobIDs.begin(), blobIDs.end(),
131 [toDelete](const auto& iter) { return (iter == *toDelete); });
132 if (it == blobIDs.end())
133 {
134 /* Somehow they've asked to delete something we didn't say we could
135 * handle.
136 */
137 return false;
138 }
139
140 blobIDs.erase(it);
141
142 /* TODO: Handle aborting the process and fixing up the state. */
143
144 return true;
Patrick Venturec7ca2912018-11-02 11:38:33 -0700145}
Patrick Venture53977962018-11-02 18:59:35 -0700146
Patrick Ventured6461d62018-11-09 17:30:25 -0800147/*
148 * Stat on the files will return information such as what supported
149 * transport mechanisms are available.
150 *
151 * Stat on an active file or hash will return information such as the size
152 * of the data cached, and any additional pertinent information. The
153 * blob_state on the active files will return the state of the update.
154 */
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700155bool FirmwareBlobHandler::stat(const std::string& path,
156 struct blobs::BlobMeta* meta)
Patrick Venturec7ca2912018-11-02 11:38:33 -0700157{
Patrick Venture46637c82018-11-06 15:20:24 -0800158 /* We know we support this path because canHandle is called ahead */
Patrick Ventured342a952019-05-29 09:09:10 -0700159 if (path == verifyBlobId || path == activeImageBlobId ||
Patrick Venture5f562692019-05-30 16:49:46 -0700160 path == activeHashBlobId || path == updateBlobId)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800161 {
Patrick Ventured342a952019-05-29 09:09:10 -0700162 /* These blobs are placeholders that indicate things, or allow actions,
163 * but are not stat-able as-is.
Patrick Ventureffcc5502018-11-16 12:32:38 -0800164 */
Patrick Ventured342a952019-05-29 09:09:10 -0700165 return false;
Patrick Venture46637c82018-11-06 15:20:24 -0800166 }
167
Patrick Ventured342a952019-05-29 09:09:10 -0700168 /* They are requesting information about the generic blob_id. */
169 meta->blobState = bitmask;
170 meta->size = 0;
171
172 /* The generic blob_ids state is only the bits related to the transport
173 * mechanisms.
174 */
175 return true;
Patrick Venturec7ca2912018-11-02 11:38:33 -0700176}
Patrick Venture53977962018-11-02 18:59:35 -0700177
Patrick Venturea2d82392019-06-03 10:55:17 -0700178VerifyCheckResponses FirmwareBlobHandler::getVerifyStatus()
179{
180 VerifyCheckResponses value = VerifyCheckResponses::other;
181
182 switch (state)
183 {
184 case UpdateState::verificationPending:
185 value = VerifyCheckResponses::other;
186 break;
187 case UpdateState::verificationStarted:
188 value = verification->status();
189 lastVerificationResponse = value;
190 break;
191 case UpdateState::verificationCompleted:
192 value = lastVerificationResponse;
193 break;
194 default:
195 break;
196 }
197
198 return value;
199}
200
201UpdateStatus FirmwareBlobHandler::getUpdateStatus()
202{
203 UpdateStatus value = UpdateStatus::unknown;
204
205 switch (state)
206 {
207 case UpdateState::updatePending:
208 value = UpdateStatus::unknown;
209 break;
210 case UpdateState::updateStarted:
211 value = update->status();
212 lastUpdateStatus = value;
213 break;
214 case UpdateState::updateCompleted:
215 value = lastUpdateStatus;
216 break;
217 default:
218 break;
219 }
220
221 return value;
222}
223
Patrick Venturec02849b2018-11-06 17:31:15 -0800224/*
Patrick Ventured6461d62018-11-09 17:30:25 -0800225 * Return stat information on an open session. It therefore must be an active
226 * handle to either the active image or active hash.
Patrick Ventured6461d62018-11-09 17:30:25 -0800227 */
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700228bool FirmwareBlobHandler::stat(uint16_t session, struct blobs::BlobMeta* meta)
Patrick Ventured6461d62018-11-09 17:30:25 -0800229{
Patrick Venturecc7d1602018-11-15 13:58:33 -0800230 auto item = lookup.find(session);
231 if (item == lookup.end())
232 {
233 return false;
234 }
235
Patrick Ventureb3b4db72019-05-15 11:30:24 -0700236 /* The size here refers to the size of the file -- of something analagous.
237 */
238 meta->size = (item->second->imageHandler)
239 ? item->second->imageHandler->getSize()
240 : 0;
241
242 meta->metadata.clear();
243
Patrick Venture7dad86f2019-05-17 08:52:20 -0700244 if (item->second->activePath == verifyBlobId)
Patrick Ventureb3b4db72019-05-15 11:30:24 -0700245 {
Patrick Venturea2d82392019-06-03 10:55:17 -0700246 VerifyCheckResponses value = getVerifyStatus();
Patrick Venture699750d2019-05-15 09:24:09 -0700247
Patrick Venturee955e072019-05-15 16:16:46 -0700248 meta->metadata.push_back(static_cast<std::uint8_t>(value));
249
250 /* Change the firmware handler's state and the blob's stat value
251 * depending.
252 */
253 if (value == VerifyCheckResponses::success ||
254 value == VerifyCheckResponses::failed)
255 {
256 state = UpdateState::verificationCompleted;
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700257 item->second->flags &= ~blobs::StateFlags::committing;
Patrick Venturee955e072019-05-15 16:16:46 -0700258
259 if (value == VerifyCheckResponses::success)
260 {
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700261 item->second->flags |= blobs::StateFlags::committed;
Patrick Venturee955e072019-05-15 16:16:46 -0700262 }
263 else
264 {
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700265 item->second->flags |= blobs::StateFlags::commit_error;
Patrick Venturee955e072019-05-15 16:16:46 -0700266 }
267 }
Patrick Ventureb3b4db72019-05-15 11:30:24 -0700268 }
Patrick Venture40d7ffc2019-05-30 17:12:06 -0700269 else if (item->second->activePath == updateBlobId)
270 {
Patrick Venturea2d82392019-06-03 10:55:17 -0700271 UpdateStatus value = getUpdateStatus();
Patrick Venture40d7ffc2019-05-30 17:12:06 -0700272
273 meta->metadata.push_back(static_cast<std::uint8_t>(value));
Patrick Venturef1f0f652019-06-03 09:10:19 -0700274
275 if (value == UpdateStatus::success || value == UpdateStatus::failed)
276 {
277 state = UpdateState::updateCompleted;
278 item->second->flags &= ~blobs::StateFlags::committing;
279
280 if (value == UpdateStatus::success)
281 {
282 item->second->flags |= blobs::StateFlags::committed;
283 }
284 else
285 {
286 item->second->flags |= blobs::StateFlags::commit_error;
287 }
288 }
Patrick Venture40d7ffc2019-05-30 17:12:06 -0700289 }
Patrick Venturecc7d1602018-11-15 13:58:33 -0800290
Patrick Venturee955e072019-05-15 16:16:46 -0700291 /* The blobState here relates to an active sesion, so we should return the
292 * flags used to open this session.
293 */
294 meta->blobState = item->second->flags;
295
Patrick Venturecc7d1602018-11-15 13:58:33 -0800296 /* The metadata blob returned comes from the data handler... it's used for
297 * instance, in P2A bridging to get required information about the mapping,
298 * and is the "opposite" of the lpc writemeta requirement.
299 */
Patrick Venturecc7d1602018-11-15 13:58:33 -0800300 if (item->second->dataHandler)
301 {
Patrick Venture74304642019-01-17 09:31:04 -0800302 auto bytes = item->second->dataHandler->readMeta();
Patrick Venturecc7d1602018-11-15 13:58:33 -0800303 meta->metadata.insert(meta->metadata.begin(), bytes.begin(),
304 bytes.end());
305 }
306
Patrick Venturecc7d1602018-11-15 13:58:33 -0800307 return true;
Patrick Ventured6461d62018-11-09 17:30:25 -0800308}
309
310/*
Patrick Venturec02849b2018-11-06 17:31:15 -0800311 * If you open /flash/image or /flash/tarball, or /flash/hash it will
312 * interpret the open flags and perform whatever actions are required for
313 * that update process. The session returned can be used immediately for
314 * sending data down, without requiring one to open the new active file.
315 *
316 * If you open the active flash image or active hash it will let you
317 * overwrite pieces, depending on the state.
318 *
319 * Once the verification process has started the active files cannot be
320 * opened.
321 *
322 * You can only have one open session at a time. Which means, you can only
323 * have one file open at a time. Trying to open the hash blob_id while you
324 * still have the flash image blob_id open will fail. Opening the flash
325 * blob_id when it is already open will fail.
326 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700327bool FirmwareBlobHandler::open(uint16_t session, uint16_t flags,
328 const std::string& path)
329{
Patrick Venture6e307a72018-11-09 18:21:17 -0800330 /* Check that they've opened for writing - read back not currently
331 * supported.
332 */
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700333 if ((flags & blobs::OpenFlags::write) == 0)
Patrick Venturec02849b2018-11-06 17:31:15 -0800334 {
335 return false;
336 }
337
Patrick Ventureb1b68fc2018-11-09 09:37:04 -0800338 /* Is the verification process underway? */
339 if (state == UpdateState::verificationStarted)
340 {
341 return false;
342 }
Patrick Venturec02849b2018-11-06 17:31:15 -0800343
344 /* Is there an open session already? We only allow one at a time.
Patrick Venture6e307a72018-11-09 18:21:17 -0800345 *
Patrick Venturec02849b2018-11-06 17:31:15 -0800346 * TODO: Temporarily using a simple boolean flag until there's a full
347 * session object to check.
Patrick Venture7c8b97e2018-11-08 09:14:30 -0800348 *
349 * Further on this, if there's an active session to the hash we don't allow
350 * re-opening the image, and if we have the image open, we don't allow
351 * opening the hash. This design decision may be re-evaluated, and changed
352 * to only allow one session per object type (of the two types). But,
353 * consider if the hash is open, do we want to allow writing to the image?
354 * And why would we? But, really, the point of no-return is once the
355 * verification process has begun -- which is done via commit() on the hash
356 * blob_id, we no longer want to allow updating the contents.
Patrick Venture53977962018-11-02 18:59:35 -0700357 */
Patrick Venturec02849b2018-11-06 17:31:15 -0800358 if (fileOpen)
359 {
360 return false;
361 }
362
Patrick Venture19f5d882019-05-30 14:34:55 -0700363 /* When in this state, they can only open the updateBlobId */
364 if (state == UpdateState::updatePending)
365 {
366 if (path != updateBlobId)
367 {
368 return false;
369 }
370 else
371 {
372 /* Similarly to verifyBlodId, this is special. */
373 updateImage.flags = flags;
374 updateImage.state = Session::State::open;
375
376 lookup[session] = &updateImage;
377
378 fileOpen = true;
379 return true;
380 }
381 }
382
Patrick Ventureffcc5502018-11-16 12:32:38 -0800383 /* Handle opening the verifyBlobId --> we know the image and hash aren't
384 * open because of the fileOpen check.
385 *
386 * The file must be opened for writing, but no transport mechanism specified
387 * since it's irrelevant.
388 */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700389 if (path == verifyBlobId)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800390 {
391 /* In this case, there's no image handler to use, or data handler,
392 * simply set up a session.
393 */
394 verifyImage.flags = flags;
395 verifyImage.state = Session::State::open;
396
397 lookup[session] = &verifyImage;
398
399 fileOpen = true;
Patrick Ventureffcc5502018-11-16 12:32:38 -0800400 return true;
401 }
402
Patrick Venturec02849b2018-11-06 17:31:15 -0800403 /* There are two abstractions at play, how you get the data and how you
404 * handle that data. such that, whether the data comes from the PCI bridge
405 * or LPC bridge is not connected to whether the data goes into a static
406 * layout flash update or a UBI tarball.
407 */
408
Patrick Venture19f5d882019-05-30 14:34:55 -0700409 /* 2) there isn't, so what are they opening? */
410 if (path == activeImageBlobId || path == activeHashBlobId)
411 {
412 /* 2a) are they opening the active image? this can only happen if they
413 * already started one (due to canHandleBlob's behavior).
414 */
415 /* 2b) are they opening the active hash? this can only happen if they
416 * already started one (due to canHandleBlob's behavior).
417 */
418 return false;
419 }
420
Patrick Venturec02849b2018-11-06 17:31:15 -0800421 /* Check the flags for the transport mechanism: if none match we don't
Patrick Venture18235e62018-11-08 10:21:09 -0800422 * support what they request.
423 */
Patrick Venture1cde5f92018-11-07 08:26:47 -0800424 if ((flags & bitmask) == 0)
Patrick Venturec02849b2018-11-06 17:31:15 -0800425 {
426 return false;
427 }
428
Patrick Venture18235e62018-11-08 10:21:09 -0800429 /* How are they expecting to copy this data? */
430 auto d = std::find_if(
431 transports.begin(), transports.end(),
432 [&flags](const auto& iter) { return (iter.bitmask & flags); });
433 if (d == transports.end())
Patrick Venturec02849b2018-11-06 17:31:15 -0800434 {
Patrick Venture18235e62018-11-08 10:21:09 -0800435 return false;
436 }
437
438 /* We found the transport handler they requested, no surprise since
439 * above we verify they selected at least one we wanted.
440 */
Patrick Venturec02849b2018-11-06 17:31:15 -0800441
Patrick Venture6e307a72018-11-09 18:21:17 -0800442 /* Elsewhere I do this check by checking "if ::ipmi" because that's the
443 * only non-external data pathway -- but this is just a more generic
444 * approach to that.
445 */
446 if (d->handler)
447 {
448 /* If the data handler open call fails, open fails. */
449 if (!d->handler->open())
450 {
451 return false;
452 }
453 }
454
Patrick Venture70e30bf2019-01-17 10:29:28 -0800455 /* Do we have a file handler for the type of file they're opening.
456 * Note: This should only fail if something is somehow crazy wrong.
457 * Since the canHandle() said yes, and that's tied into the list of explicit
458 * firmware handers (and file handlers, like this'll know where to write the
459 * tarball, etc).
Patrick Venture18235e62018-11-08 10:21:09 -0800460 */
Patrick Venture18235e62018-11-08 10:21:09 -0800461 auto h = std::find_if(
462 handlers.begin(), handlers.end(),
463 [&path](const auto& iter) { return (iter.blobName == path); });
464 if (h == handlers.end())
465 {
466 return false;
467 }
468
469 /* Ok, so we found a handler that matched, so call open() */
470 if (!h->handler->open(path))
471 {
472 return false;
473 }
474
Patrick Venture70e30bf2019-01-17 10:29:28 -0800475 Session* curr;
476 const std::string* active;
477
Patrick Venture7dad86f2019-05-17 08:52:20 -0700478 if (path == hashBlobId)
Patrick Venture70e30bf2019-01-17 10:29:28 -0800479 {
480 /* 2c) are they opening the /flash/hash ? (to start the process) */
481 curr = &activeHash;
Patrick Venture7dad86f2019-05-17 08:52:20 -0700482 active = &activeHashBlobId;
Patrick Venture70e30bf2019-01-17 10:29:28 -0800483 }
484 else
485 {
486 curr = &activeImage;
Patrick Venture7dad86f2019-05-17 08:52:20 -0700487 active = &activeImageBlobId;
Patrick Venture70e30bf2019-01-17 10:29:28 -0800488 }
489
Patrick Venture18235e62018-11-08 10:21:09 -0800490 curr->flags = flags;
491 curr->dataHandler = d->handler;
492 curr->imageHandler = h->handler;
Patrick Venturecd310222018-11-09 18:47:13 -0800493 curr->state = Session::State::open;
Patrick Venture18235e62018-11-08 10:21:09 -0800494
495 lookup[session] = curr;
496
Patrick Ventureefba42d2019-05-24 10:48:16 -0700497 addBlobId(*active);
Patrick Venture930c7b72019-05-24 11:11:08 -0700498 removeBlobId(verifyBlobId);
Patrick Venturedb253bf2018-11-09 19:36:03 -0800499
Patrick Venture12233c52019-05-16 09:26:59 -0700500 state = UpdateState::uploadInProgress;
Patrick Venture991910a2018-11-09 19:43:48 -0800501 fileOpen = true;
502
Patrick Venture18235e62018-11-08 10:21:09 -0800503 return true;
Patrick Venturec7ca2912018-11-02 11:38:33 -0700504}
Patrick Venture53977962018-11-02 18:59:35 -0700505
Patrick Venture18235e62018-11-08 10:21:09 -0800506/**
507 * The write command really just grabs the data from wherever it is and sends it
508 * to the image handler. It's the image handler's responsibility to deal with
509 * the data provided.
Patrick Ventured6461d62018-11-09 17:30:25 -0800510 *
511 * This receives a session from the blob manager, therefore it is always called
512 * between open() and close().
Patrick Venture18235e62018-11-08 10:21:09 -0800513 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700514bool FirmwareBlobHandler::write(uint16_t session, uint32_t offset,
515 const std::vector<uint8_t>& data)
516{
Patrick Venture18235e62018-11-08 10:21:09 -0800517 auto item = lookup.find(session);
518 if (item == lookup.end())
519 {
520 return false;
521 }
522
Patrick Ventureb1b68fc2018-11-09 09:37:04 -0800523 /* Prevent writing during verification. */
524 if (state == UpdateState::verificationStarted)
525 {
526 return false;
527 }
528
Patrick Venture4e2fdcd2019-05-30 14:58:57 -0700529 /* Prevent writing to the verification or update blobs. */
530 if (item->second->activePath == verifyBlobId ||
531 item->second->activePath == updateBlobId)
Patrick Venture8af15eb2019-05-15 09:39:22 -0700532 {
533 return false;
534 }
Patrick Venture699750d2019-05-15 09:24:09 -0700535
Patrick Venture18235e62018-11-08 10:21:09 -0800536 std::vector<std::uint8_t> bytes;
537
Patrick Venture05abf7e2018-11-09 11:02:56 -0800538 if (item->second->flags & UpdateFlags::ipmi)
Patrick Venture18235e62018-11-08 10:21:09 -0800539 {
540 bytes = data;
541 }
542 else
543 {
544 /* little endian required per design, and so on, but TODO: do endianness
545 * with boost.
546 */
547 struct ExtChunkHdr header;
548
549 if (data.size() != sizeof(header))
550 {
551 return false;
552 }
553
554 std::memcpy(&header, data.data(), data.size());
555 bytes = item->second->dataHandler->copyFrom(header.length);
556 }
557
558 return item->second->imageHandler->write(offset, bytes);
Patrick Venturec7ca2912018-11-02 11:38:33 -0700559}
Patrick Venture18235e62018-11-08 10:21:09 -0800560
Patrick Venture8c535332018-11-08 15:58:00 -0800561/*
562 * If the active session (image or hash) is over LPC, this allows
563 * configuring it. This option is only available before you start
564 * writing data for the given item (image or hash). This will return
565 * false at any other part. -- the lpc handler portion will know to return
566 * false.
567 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700568bool FirmwareBlobHandler::writeMeta(uint16_t session, uint32_t offset,
569 const std::vector<uint8_t>& data)
570{
Patrick Venture8c535332018-11-08 15:58:00 -0800571 auto item = lookup.find(session);
572 if (item == lookup.end())
573 {
574 return false;
575 }
576
Patrick Venture05abf7e2018-11-09 11:02:56 -0800577 if (item->second->flags & UpdateFlags::ipmi)
Patrick Venture8c535332018-11-08 15:58:00 -0800578 {
579 return false;
580 }
581
Patrick Ventured56097a2019-05-15 09:47:55 -0700582 /* Prevent writing meta to the verification blob (it has no data handler).
583 */
584 if (item->second->dataHandler)
585 {
586 return item->second->dataHandler->writeMeta(data);
587 }
Patrick Venture699750d2019-05-15 09:24:09 -0700588
Patrick Ventured56097a2019-05-15 09:47:55 -0700589 return false;
Patrick Venturec7ca2912018-11-02 11:38:33 -0700590}
Patrick Venture8c535332018-11-08 15:58:00 -0800591
Patrick Ventured6461d62018-11-09 17:30:25 -0800592/*
Patrick Venture7dad86f2019-05-17 08:52:20 -0700593 * If this command is called on the session for the verifyBlobId, it'll
Patrick Ventured6461d62018-11-09 17:30:25 -0800594 * trigger a systemd service `verify_image.service` to attempt to verify
Patrick Ventureffcc5502018-11-16 12:32:38 -0800595 * the image.
596 *
597 * For this file to have opened, the other two must be closed, which means any
598 * out-of-band transport mechanism involved is closed.
Patrick Ventured6461d62018-11-09 17:30:25 -0800599 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700600bool FirmwareBlobHandler::commit(uint16_t session,
601 const std::vector<uint8_t>& data)
602{
Patrick Ventureffcc5502018-11-16 12:32:38 -0800603 auto item = lookup.find(session);
604 if (item == lookup.end())
605 {
606 return false;
607 }
608
Patrick Venture1a406fe2019-05-31 07:29:56 -0700609 /* You can only commit on the verifyBlodId or updateBlobId */
610 if (item->second->activePath != verifyBlobId &&
611 item->second->activePath != updateBlobId)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800612 {
Patrick Venture1a406fe2019-05-31 07:29:56 -0700613 std::fprintf(stderr, "path: '%s' not expected for commit\n",
614 item->second->activePath.c_str());
Patrick Ventureffcc5502018-11-16 12:32:38 -0800615 return false;
616 }
617
Patrick Venture433cbc32019-05-30 09:53:10 -0700618 switch (state)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800619 {
Patrick Venture1a406fe2019-05-31 07:29:56 -0700620 case UpdateState::verificationPending:
621 /* Set state to committing. */
622 item->second->flags |= blobs::StateFlags::committing;
623 return triggerVerification();
Patrick Venture433cbc32019-05-30 09:53:10 -0700624 case UpdateState::verificationStarted:
625 /* Calling repeatedly has no effect within an update process. */
626 return true;
627 case UpdateState::verificationCompleted:
628 /* Calling after the verification process has completed returns
629 * failure. */
630 return false;
Patrick Venture1a406fe2019-05-31 07:29:56 -0700631 case UpdateState::updatePending:
Patrick Venture433cbc32019-05-30 09:53:10 -0700632 item->second->flags |= blobs::StateFlags::committing;
Patrick Venture1a406fe2019-05-31 07:29:56 -0700633 return triggerUpdate();
Patrick Venture0079d892019-05-31 11:27:44 -0700634 case UpdateState::updateStarted:
635 /* Calling repeatedly has no effect within an update process. */
636 return true;
Patrick Venture1a406fe2019-05-31 07:29:56 -0700637 default:
638 return false;
Patrick Ventureffcc5502018-11-16 12:32:38 -0800639 }
Patrick Venturec7ca2912018-11-02 11:38:33 -0700640}
Patrick Ventured6461d62018-11-09 17:30:25 -0800641
642/*
643 * Close must be called on the firmware image before triggering
644 * verification via commit. Once the verification is complete, you can
645 * then close the hash file.
646 *
647 * If the `verify_image.service` returned success, closing the hash file
648 * will have a specific behavior depending on the update. If it's UBI,
649 * it'll perform the install. If it's static layout, it'll do nothing. The
650 * verify_image service in the static layout case is responsible for placing
651 * the file in the correct staging position.
652 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700653bool FirmwareBlobHandler::close(uint16_t session)
654{
Patrick Venture68bb1432018-11-09 20:08:48 -0800655 auto item = lookup.find(session);
656 if (item == lookup.end())
657 {
658 return false;
659 }
660
Patrick Ventureffcc5502018-11-16 12:32:38 -0800661 /* Are you closing the verify blob? */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700662 if (item->second->activePath == verifyBlobId)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800663 {
Patrick Venture1c6d8f52019-05-30 10:53:49 -0700664 switch (state)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800665 {
Patrick Venture1c6d8f52019-05-30 10:53:49 -0700666 case UpdateState::verificationStarted:
667 /* TODO: If they close this blob before verification finishes,
668 * that's an abort.
669 */
670 return false;
671 case UpdateState::verificationCompleted:
672 if (lastVerificationResponse == VerifyCheckResponses::success)
673 {
674 state = UpdateState::updatePending;
675 addBlobId(updateBlobId);
Patrick Venturead933832019-05-30 14:13:29 -0700676 removeBlobId(verifyBlobId);
Patrick Venture1c6d8f52019-05-30 10:53:49 -0700677 }
678 else
679 {
680 /* TODO: Verification failed, what now? */
681 state = UpdateState::notYetStarted;
682 }
Patrick Venture40d7ffc2019-05-30 17:12:06 -0700683 break;
Patrick Venture1c6d8f52019-05-30 10:53:49 -0700684 default:
Patrick Venture40d7ffc2019-05-30 17:12:06 -0700685 break;
Patrick Venture12233c52019-05-16 09:26:59 -0700686 }
687 /* Must be verificationPending... not yet started, they may re-open and
688 * trigger verification.
689 */
690 }
Patrick Venture6b0aa182019-05-30 14:47:32 -0700691 else if (item->second->activePath == updateBlobId)
692 {
693 /* nothing interesting. */
694 }
Patrick Venture12233c52019-05-16 09:26:59 -0700695 else
696 {
697 /* They are closing a data pathway (image, tarball, hash). */
698 state = UpdateState::verificationPending;
Patrick Venture930c7b72019-05-24 11:11:08 -0700699
700 /* Add verify blob ID now that we can expect it. */
701 addBlobId(verifyBlobId);
Patrick Ventureffcc5502018-11-16 12:32:38 -0800702 }
703
Patrick Venture68bb1432018-11-09 20:08:48 -0800704 if (item->second->dataHandler)
705 {
706 item->second->dataHandler->close();
707 }
Patrick Ventureffcc5502018-11-16 12:32:38 -0800708 if (item->second->imageHandler)
709 {
710 item->second->imageHandler->close();
711 }
712
Patrick Venture68bb1432018-11-09 20:08:48 -0800713 item->second->state = Session::State::closed;
Patrick Venture68bb1432018-11-09 20:08:48 -0800714 lookup.erase(item);
Patrick Venture991910a2018-11-09 19:43:48 -0800715 fileOpen = false;
Patrick Venture68bb1432018-11-09 20:08:48 -0800716 return true;
Patrick Venturec7ca2912018-11-02 11:38:33 -0700717}
Patrick Ventured6461d62018-11-09 17:30:25 -0800718
Patrick Venturec7ca2912018-11-02 11:38:33 -0700719bool FirmwareBlobHandler::expire(uint16_t session)
720{
721 return false;
722}
Patrick Ventured6461d62018-11-09 17:30:25 -0800723
724/*
725 * Currently, the design does not provide this with a function, however,
726 * it will likely change to support reading data back.
727 */
728std::vector<uint8_t> FirmwareBlobHandler::read(uint16_t session,
729 uint32_t offset,
730 uint32_t requestedSize)
731{
732 return {};
733}
734
Patrick Ventureffcc5502018-11-16 12:32:38 -0800735bool FirmwareBlobHandler::triggerVerification()
736{
Patrick Venture3ecb3502019-05-17 11:03:51 -0700737 bool result = verification->triggerVerification();
738 if (result)
Patrick Venturecabc1172018-11-16 16:14:26 -0800739 {
Patrick Venture453f06a2019-01-17 10:02:12 -0800740 state = UpdateState::verificationStarted;
Patrick Venturecabc1172018-11-16 16:14:26 -0800741 }
Patrick Venturecabc1172018-11-16 16:14:26 -0800742
Patrick Venture3ecb3502019-05-17 11:03:51 -0700743 return result;
Patrick Ventureffcc5502018-11-16 12:32:38 -0800744}
745
Patrick Venture1a406fe2019-05-31 07:29:56 -0700746bool FirmwareBlobHandler::triggerUpdate()
747{
748 bool result = update->triggerUpdate();
749 if (result)
750 {
751 state = UpdateState::updateStarted;
752 }
753
754 return result;
755}
756
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700757} // namespace ipmi_flash