blob: 59ef65103399729fbccb5233104bdf643fc66fc8 [file] [log] [blame]
Patrick Venturec7ca2912018-11-02 11:38:33 -07001#include "firmware_handler.hpp"
2
Patrick Venturea78e39f2018-11-06 18:37:06 -08003#include "image_handler.hpp"
4
Patrick Venture137ad2c2018-11-06 11:30:43 -08005#include <algorithm>
Patrick Venture192d60f2018-11-06 11:11:59 -08006#include <cstdint>
Patrick Venture18235e62018-11-08 10:21:09 -08007#include <cstring>
Patrick Venture68cf64f2018-11-06 10:46:51 -08008#include <memory>
Patrick Venturefa6c4d92018-11-02 18:34:53 -07009#include <string>
10#include <vector>
11
Patrick Venturec7ca2912018-11-02 11:38:33 -070012namespace blobs
13{
14
Patrick Venture21be45a2018-11-06 12:08:52 -080015const std::string FirmwareBlobHandler::hashBlobID = "/flash/hash";
Patrick Venture7b9256f2018-11-06 15:06:04 -080016const std::string FirmwareBlobHandler::activeImageBlobID =
17 "/flash/active/image";
18const std::string FirmwareBlobHandler::activeHashBlobID = "/flash/active/hash";
Patrick Venture4cceb8e2018-11-06 11:56:48 -080019
Patrick Venture68cf64f2018-11-06 10:46:51 -080020std::unique_ptr<GenericBlobInterface>
Patrick Venture148cd652018-11-06 10:59:47 -080021 FirmwareBlobHandler::CreateFirmwareBlobHandler(
Patrick Venture1cde5f92018-11-07 08:26:47 -080022 const std::vector<HandlerPack>& firmwares,
23 const std::vector<DataHandlerPack>& transports)
Patrick Venture68cf64f2018-11-06 10:46:51 -080024{
Patrick Venture52854622018-11-06 12:30:00 -080025 /* There must be at least one. */
26 if (!firmwares.size())
27 {
28 return nullptr;
29 }
Patrick Venture1cde5f92018-11-07 08:26:47 -080030 if (!transports.size())
31 {
32 return nullptr;
33 }
Patrick Venture52854622018-11-06 12:30:00 -080034
Patrick Venturea78e39f2018-11-06 18:37:06 -080035 std::vector<std::string> blobs;
36 for (const auto& item : firmwares)
37 {
38 blobs.push_back(item.blobName);
39 }
Patrick Venture18235e62018-11-08 10:21:09 -080040
41 if (0 == std::count(blobs.begin(), blobs.end(), hashBlobID))
42 {
43 return nullptr;
44 }
Patrick Venture4cceb8e2018-11-06 11:56:48 -080045
Patrick Venture1cde5f92018-11-07 08:26:47 -080046 std::uint16_t bitmask = 0;
47 for (const auto& item : transports)
48 {
49 /* TODO: can use std::accumulate() unless I'm mistaken. :D */
50 bitmask |= item.bitmask;
51 }
52
53 return std::make_unique<FirmwareBlobHandler>(firmwares, blobs, transports,
54 bitmask);
Patrick Venture68cf64f2018-11-06 10:46:51 -080055}
56
Patrick Venturec7ca2912018-11-02 11:38:33 -070057bool FirmwareBlobHandler::canHandleBlob(const std::string& path)
58{
Patrick Venture53977962018-11-02 18:59:35 -070059 /* Check if the path is in our supported list (or active list). */
Patrick Venture4cceb8e2018-11-06 11:56:48 -080060 if (std::count(blobIDs.begin(), blobIDs.end(), path))
Patrick Venture137ad2c2018-11-06 11:30:43 -080061 {
62 return true;
63 }
64
Patrick Venturec7ca2912018-11-02 11:38:33 -070065 return false;
66}
Patrick Venture53977962018-11-02 18:59:35 -070067
Patrick Venturec7ca2912018-11-02 11:38:33 -070068std::vector<std::string> FirmwareBlobHandler::getBlobIds()
69{
Patrick Venturefa6c4d92018-11-02 18:34:53 -070070 /*
71 * Grab the list of supported firmware.
Patrick Venture137ad2c2018-11-06 11:30:43 -080072 *
73 * If there's an open firmware session, it'll already be present in the
74 * list as "/flash/active/image", and if the hash has started,
75 * "/flash/active/hash" regardless of mechanism. This is done in the open
76 * comamnd, no extra work is required here.
Patrick Venturefa6c4d92018-11-02 18:34:53 -070077 */
Patrick Venture4cceb8e2018-11-06 11:56:48 -080078 return blobIDs;
Patrick Venturec7ca2912018-11-02 11:38:33 -070079}
Patrick Venture53977962018-11-02 18:59:35 -070080
Patrick Venturec7ca2912018-11-02 11:38:33 -070081bool FirmwareBlobHandler::deleteBlob(const std::string& path)
82{
Patrick Venture53977962018-11-02 18:59:35 -070083 /*
84 * Per the design, this mean abort, and this will trigger whatever
85 * appropriate actions are required to abort the process.
86 */
Patrick Venturec7ca2912018-11-02 11:38:33 -070087 return false;
88}
Patrick Venture53977962018-11-02 18:59:35 -070089
Patrick Venturec7ca2912018-11-02 11:38:33 -070090bool FirmwareBlobHandler::stat(const std::string& path, struct BlobMeta* meta)
91{
Patrick Venture53977962018-11-02 18:59:35 -070092 /*
93 * Stat on the files will return information such as what supported
94 * transport mechanisms are available.
95 *
96 * Stat on an active file or hash will return information such as the size
97 * of the data cached, and any additional pertinent information. The
98 * blob_state on the active files will return the state of the update.
99 */
Patrick Venture46637c82018-11-06 15:20:24 -0800100
101 /* We know we support this path because canHandle is called ahead */
102 if (path == FirmwareBlobHandler::activeImageBlobID)
103 {
104 /* We need to return information for the image that's staged. */
105 }
106 else if (path == FirmwareBlobHandler::activeHashBlobID)
107 {
108 /* We need to return information for the hash that's staged. */
109 }
110 else
111 {
112 /* They are requesting information about the generic blob_id. */
Patrick Venture1cde5f92018-11-07 08:26:47 -0800113 meta->blobState = bitmask;
Patrick Venture46637c82018-11-06 15:20:24 -0800114 meta->size = 0;
115
116 /* The generic blob_ids state is only the bits related to the transport
117 * mechanisms. */
118 return true;
119 }
120
Patrick Venturec7ca2912018-11-02 11:38:33 -0700121 return false;
122}
Patrick Venture53977962018-11-02 18:59:35 -0700123
Patrick Venturec02849b2018-11-06 17:31:15 -0800124/*
125 * If you open /flash/image or /flash/tarball, or /flash/hash it will
126 * interpret the open flags and perform whatever actions are required for
127 * that update process. The session returned can be used immediately for
128 * sending data down, without requiring one to open the new active file.
129 *
130 * If you open the active flash image or active hash it will let you
131 * overwrite pieces, depending on the state.
132 *
133 * Once the verification process has started the active files cannot be
134 * opened.
135 *
136 * You can only have one open session at a time. Which means, you can only
137 * have one file open at a time. Trying to open the hash blob_id while you
138 * still have the flash image blob_id open will fail. Opening the flash
139 * blob_id when it is already open will fail.
140 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700141bool FirmwareBlobHandler::open(uint16_t session, uint16_t flags,
142 const std::string& path)
143{
Patrick Venturec02849b2018-11-06 17:31:15 -0800144 /* Check that they've opened for writing - read back not supported. */
145 if ((flags & OpenFlags::write) == 0)
146 {
147 return false;
148 }
149
150 /* TODO: Is the verification process underway? */
151
152 /* Is there an open session already? We only allow one at a time.
153 * TODO: Temporarily using a simple boolean flag until there's a full
154 * session object to check.
Patrick Venture7c8b97e2018-11-08 09:14:30 -0800155 *
156 * Further on this, if there's an active session to the hash we don't allow
157 * re-opening the image, and if we have the image open, we don't allow
158 * opening the hash. This design decision may be re-evaluated, and changed
159 * to only allow one session per object type (of the two types). But,
160 * consider if the hash is open, do we want to allow writing to the image?
161 * And why would we? But, really, the point of no-return is once the
162 * verification process has begun -- which is done via commit() on the hash
163 * blob_id, we no longer want to allow updating the contents.
Patrick Venture53977962018-11-02 18:59:35 -0700164 */
Patrick Venturec02849b2018-11-06 17:31:15 -0800165 if (fileOpen)
166 {
167 return false;
168 }
169
170 /* There are two abstractions at play, how you get the data and how you
171 * handle that data. such that, whether the data comes from the PCI bridge
172 * or LPC bridge is not connected to whether the data goes into a static
173 * layout flash update or a UBI tarball.
174 */
175
176 /* Check the flags for the transport mechanism: if none match we don't
Patrick Venture18235e62018-11-08 10:21:09 -0800177 * support what they request.
178 */
Patrick Venture1cde5f92018-11-07 08:26:47 -0800179 if ((flags & bitmask) == 0)
Patrick Venturec02849b2018-11-06 17:31:15 -0800180 {
181 return false;
182 }
183
184 /* 2) there isn't, so what are they opening? */
185 if (path == activeImageBlobID)
186 {
187 /* 2a) are they opening the active image? this can only happen if they
Patrick Venture18235e62018-11-08 10:21:09 -0800188 * already started one (due to canHandleBlob's behavior).
189 */
Patrick Venturec02849b2018-11-06 17:31:15 -0800190 }
191 else if (path == activeHashBlobID)
192 {
193 /* 2b) are they opening the active hash? this can only happen if they
Patrick Venture18235e62018-11-08 10:21:09 -0800194 * already started one (due to canHandleBlob's behavior).
195 */
Patrick Venturec02849b2018-11-06 17:31:15 -0800196 }
Patrick Venture18235e62018-11-08 10:21:09 -0800197
198 /* How are they expecting to copy this data? */
199 auto d = std::find_if(
200 transports.begin(), transports.end(),
201 [&flags](const auto& iter) { return (iter.bitmask & flags); });
202 if (d == transports.end())
Patrick Venturec02849b2018-11-06 17:31:15 -0800203 {
Patrick Venture18235e62018-11-08 10:21:09 -0800204 return false;
205 }
206
207 /* We found the transport handler they requested, no surprise since
208 * above we verify they selected at least one we wanted.
209 */
210 Session* curr;
211
212 if (path == hashBlobID)
213 {
214 curr = &activeHash;
215
Patrick Venturec02849b2018-11-06 17:31:15 -0800216 /* 2c) are they opening the /flash/hash ? (to start the process) */
Patrick Venture7c8b97e2018-11-08 09:14:30 -0800217
218 /* Add active hash blob_id to canHandle list. */
219 blobIDs.push_back(activeHashBlobID);
Patrick Venturec02849b2018-11-06 17:31:15 -0800220 }
221 else
222 {
Patrick Venture18235e62018-11-08 10:21:09 -0800223 curr = &activeImage;
Patrick Venture72388d72018-11-07 15:06:36 -0800224
Patrick Venture7c8b97e2018-11-08 09:14:30 -0800225 /* add active image blob_id to canHandle list. */
226 blobIDs.push_back(activeImageBlobID);
Patrick Venturec02849b2018-11-06 17:31:15 -0800227 }
228
Patrick Venture18235e62018-11-08 10:21:09 -0800229 /* 2d) are they opening the /flash/tarball ? (to start the UBI process)
230 */
231 /* 2e) are they opening the /flash/image ? (to start the process) */
232 /* 2...) are they opening the /flash/... ? (to start the process) */
233
234 auto h = std::find_if(
235 handlers.begin(), handlers.end(),
236 [&path](const auto& iter) { return (iter.blobName == path); });
237 if (h == handlers.end())
238 {
239 return false;
240 }
241
242 /* Ok, so we found a handler that matched, so call open() */
243 if (!h->handler->open(path))
244 {
245 return false;
246 }
247
248 curr->flags = flags;
249 curr->dataHandler = d->handler;
250 curr->imageHandler = h->handler;
251
252 lookup[session] = curr;
253
254 return true;
Patrick Venturec7ca2912018-11-02 11:38:33 -0700255}
Patrick Venture53977962018-11-02 18:59:35 -0700256
Patrick Venturec7ca2912018-11-02 11:38:33 -0700257std::vector<uint8_t> FirmwareBlobHandler::read(uint16_t session,
258 uint32_t offset,
259 uint32_t requestedSize)
260{
Patrick Venture53977962018-11-02 18:59:35 -0700261 /*
262 * Currently, the design does not provide this with a function, however,
263 * it will likely change to support reading data back.
264 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700265 return {};
266}
Patrick Venture53977962018-11-02 18:59:35 -0700267
Patrick Venture18235e62018-11-08 10:21:09 -0800268/**
269 * The write command really just grabs the data from wherever it is and sends it
270 * to the image handler. It's the image handler's responsibility to deal with
271 * the data provided.
272 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700273bool FirmwareBlobHandler::write(uint16_t session, uint32_t offset,
274 const std::vector<uint8_t>& data)
275{
Patrick Venture18235e62018-11-08 10:21:09 -0800276 auto item = lookup.find(session);
277 if (item == lookup.end())
278 {
279 return false;
280 }
281
282 std::vector<std::uint8_t> bytes;
283
284 if (item->second->flags & FirmwareUpdateFlags::ipmi)
285 {
286 bytes = data;
287 }
288 else
289 {
290 /* little endian required per design, and so on, but TODO: do endianness
291 * with boost.
292 */
293 struct ExtChunkHdr header;
294
295 if (data.size() != sizeof(header))
296 {
297 return false;
298 }
299
300 std::memcpy(&header, data.data(), data.size());
301 bytes = item->second->dataHandler->copyFrom(header.length);
302 }
303
304 return item->second->imageHandler->write(offset, bytes);
Patrick Venturec7ca2912018-11-02 11:38:33 -0700305}
Patrick Venture18235e62018-11-08 10:21:09 -0800306
Patrick Venture8c535332018-11-08 15:58:00 -0800307/*
308 * If the active session (image or hash) is over LPC, this allows
309 * configuring it. This option is only available before you start
310 * writing data for the given item (image or hash). This will return
311 * false at any other part. -- the lpc handler portion will know to return
312 * false.
313 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700314bool FirmwareBlobHandler::writeMeta(uint16_t session, uint32_t offset,
315 const std::vector<uint8_t>& data)
316{
Patrick Venture8c535332018-11-08 15:58:00 -0800317 auto item = lookup.find(session);
318 if (item == lookup.end())
319 {
320 return false;
321 }
322
323 if (item->second->flags & FirmwareUpdateFlags::ipmi)
324 {
325 return false;
326 }
327
328 return item->second->dataHandler->write(data);
Patrick Venturec7ca2912018-11-02 11:38:33 -0700329}
Patrick Venture8c535332018-11-08 15:58:00 -0800330
Patrick Venturec7ca2912018-11-02 11:38:33 -0700331bool FirmwareBlobHandler::commit(uint16_t session,
332 const std::vector<uint8_t>& data)
333{
Patrick Venture53977962018-11-02 18:59:35 -0700334 /*
335 * If this command is called on the session for the hash image, it'll
336 * trigger a systemd service `verify_image.service` to attempt to verify
337 * the image. Before doing this, if the transport mechanism is not IPMI
338 * BT, it'll shut down the mechanism used for transport preventing the
339 * host from updating anything.
340 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700341 return false;
342}
343bool FirmwareBlobHandler::close(uint16_t session)
344{
Patrick Venture53977962018-11-02 18:59:35 -0700345 /*
346 * Close must be called on the firmware image before triggering
347 * verification via commit. Once the verification is complete, you can
348 * then close the hash file.
349 *
350 * If the `verify_image.service` returned success, closing the hash file
351 * will have a specific behavior depending on the update. If it's UBI,
352 * it'll perform the install. If it's static layout, it'll do nothing. The
353 * verify_image service in the static layout case is responsible for placing
354 * the file in the correct staging position.
355 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700356 return false;
357}
358bool FirmwareBlobHandler::stat(uint16_t session, struct BlobMeta* meta)
359{
Patrick Venture53977962018-11-02 18:59:35 -0700360 /*
Patrick Venture46637c82018-11-06 15:20:24 -0800361 * Return session specific information.
Patrick Venture53977962018-11-02 18:59:35 -0700362 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700363 return false;
364}
365bool FirmwareBlobHandler::expire(uint16_t session)
366{
367 return false;
368}
369} // namespace blobs