blob: 4dadceb5e0c266dd9c29814201e093d754984106 [file] [log] [blame]
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001/*
2 * Copyright (C) 2014 The Android Open Source Project
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 <ctype.h>
18#include <errno.h>
Sami Tolvanen90221202014-12-09 16:39:47 +000019#include <dirent.h>
Doug Zongkerbc7ffed2014-08-15 14:31:52 -070020#include <fcntl.h>
Tao Baoba9a42a2015-06-23 23:23:33 -070021#include <linux/fs.h>
Doug Zongkerbc7ffed2014-08-15 14:31:52 -070022#include <pthread.h>
23#include <stdarg.h>
24#include <stdio.h>
25#include <stdlib.h>
26#include <string.h>
Sami Tolvanen90221202014-12-09 16:39:47 +000027#include <sys/stat.h>
Doug Zongkerbc7ffed2014-08-15 14:31:52 -070028#include <sys/types.h>
29#include <sys/wait.h>
30#include <sys/ioctl.h>
31#include <time.h>
32#include <unistd.h>
Sami Tolvanen0a7b4732015-06-25 10:25:36 +010033#include <fec/io.h>
Doug Zongkerbc7ffed2014-08-15 14:31:52 -070034
Tao Baoe6aa3322015-08-05 15:20:27 -070035#include <memory>
36#include <string>
Tianjie Xu8cf5c8f2016-09-08 20:10:11 -070037#include <unordered_map>
Tao Bao0940fe12015-08-27 16:41:21 -070038#include <vector>
Tao Baoe6aa3322015-08-05 15:20:27 -070039
Tao Bao039f2da2016-11-22 16:29:50 -080040#include <android-base/logging.h>
Elliott Hughes4b166f02015-12-04 15:30:20 -080041#include <android-base/parseint.h>
42#include <android-base/strings.h>
Elliott Hughesbcabd092016-03-22 20:19:22 -070043#include <android-base/unique_fd.h>
Tianjie Xu8cf5c8f2016-09-08 20:10:11 -070044#include <ziparchive/zip_archive.h>
Tao Baoe6aa3322015-08-05 15:20:27 -070045
Doug Zongkerbc7ffed2014-08-15 14:31:52 -070046#include "applypatch/applypatch.h"
47#include "edify/expr.h"
Tianjie Xu16255832016-04-30 11:49:59 -070048#include "error_code.h"
Tao Bao0c7839a2016-10-10 15:48:37 -070049#include "updater/install.h"
Sen Jiangc48cb5e2016-02-04 16:23:21 +080050#include "openssl/sha.h"
Jed Estep39c1b5e2015-12-15 16:04:53 -080051#include "ota_io.h"
Tao Baoe6aa3322015-08-05 15:20:27 -070052#include "print_sha1.h"
Tao Bao0c7839a2016-10-10 15:48:37 -070053#include "updater/updater.h"
Doug Zongkerbc7ffed2014-08-15 14:31:52 -070054
Tao Bao039f2da2016-11-22 16:29:50 -080055static constexpr size_t BLOCKSIZE = 4096;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -070056
Sami Tolvanene82fa182015-06-10 15:58:12 +000057// Set this to 0 to interpret 'erase' transfers to mean do a
58// BLKDISCARD ioctl (the normal behavior). Set to 1 to interpret
59// erase to mean fill the region with zeroes.
60#define DEBUG_ERASE 0
61
Sami Tolvanen90221202014-12-09 16:39:47 +000062#define STASH_DIRECTORY_BASE "/cache/recovery"
63#define STASH_DIRECTORY_MODE 0700
64#define STASH_FILE_MODE 0600
65
Tao Bao0940fe12015-08-27 16:41:21 -070066struct RangeSet {
67 size_t count; // Limit is INT_MAX.
Shrinivas Sahukara6153df2015-08-19 13:01:45 +053068 size_t size;
Tao Bao0940fe12015-08-27 16:41:21 -070069 std::vector<size_t> pos; // Actual limit is INT_MAX.
70};
Doug Zongkerbc7ffed2014-08-15 14:31:52 -070071
Tianjie Xu16255832016-04-30 11:49:59 -070072static CauseCode failure_type = kNoCause;
Tianjie Xu7ce287d2016-05-31 09:29:49 -070073static bool is_retry = false;
Tianjie Xu8cf5c8f2016-09-08 20:10:11 -070074static std::unordered_map<std::string, RangeSet> stash_map;
Tianjie Xu7eca97e2016-03-22 18:08:12 -070075
Tao Baobaad2d42015-12-06 16:56:27 -080076static void parse_range(const std::string& range_text, RangeSet& rs) {
Sami Tolvanenf2bac042015-05-12 12:48:46 +010077
Tao Baobaad2d42015-12-06 16:56:27 -080078 std::vector<std::string> pieces = android::base::Split(range_text, ",");
Tao Bao0940fe12015-08-27 16:41:21 -070079 if (pieces.size() < 3) {
Sami Tolvanenf2bac042015-05-12 12:48:46 +010080 goto err;
81 }
82
Tao Baob15fd222015-09-24 11:10:51 -070083 size_t num;
84 if (!android::base::ParseUint(pieces[0].c_str(), &num, static_cast<size_t>(INT_MAX))) {
Sami Tolvanenf2bac042015-05-12 12:48:46 +010085 goto err;
86 }
87
Tao Baob15fd222015-09-24 11:10:51 -070088 if (num == 0 || num % 2) {
89 goto err; // must be even
90 } else if (num != pieces.size() - 1) {
91 goto err;
92 }
Sami Tolvanenf2bac042015-05-12 12:48:46 +010093
Tao Bao0940fe12015-08-27 16:41:21 -070094 rs.pos.resize(num);
95 rs.count = num / 2;
96 rs.size = 0;
Sami Tolvanenf2bac042015-05-12 12:48:46 +010097
Tao Bao0940fe12015-08-27 16:41:21 -070098 for (size_t i = 0; i < num; i += 2) {
Tao Baob15fd222015-09-24 11:10:51 -070099 if (!android::base::ParseUint(pieces[i+1].c_str(), &rs.pos[i],
100 static_cast<size_t>(INT_MAX))) {
Sami Tolvanenf2bac042015-05-12 12:48:46 +0100101 goto err;
102 }
103
Tao Baob15fd222015-09-24 11:10:51 -0700104 if (!android::base::ParseUint(pieces[i+2].c_str(), &rs.pos[i+1],
105 static_cast<size_t>(INT_MAX))) {
Shrinivas Sahukara6153df2015-08-19 13:01:45 +0530106 goto err;
107 }
108
Tao Bao0940fe12015-08-27 16:41:21 -0700109 if (rs.pos[i] >= rs.pos[i+1]) {
Shrinivas Sahukara6153df2015-08-19 13:01:45 +0530110 goto err; // empty or negative range
111 }
112
Tao Bao0940fe12015-08-27 16:41:21 -0700113 size_t sz = rs.pos[i+1] - rs.pos[i];
114 if (rs.size > SIZE_MAX - sz) {
Shrinivas Sahukara6153df2015-08-19 13:01:45 +0530115 goto err; // overflow
116 }
117
Tao Bao0940fe12015-08-27 16:41:21 -0700118 rs.size += sz;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700119 }
120
Tao Bao0940fe12015-08-27 16:41:21 -0700121 return;
Sami Tolvanenf2bac042015-05-12 12:48:46 +0100122
123err:
Tao Bao039f2da2016-11-22 16:29:50 -0800124 LOG(ERROR) << "failed to parse range '" << range_text << "'";
Sami Tolvanenf2bac042015-05-12 12:48:46 +0100125 exit(1);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700126}
127
Tao Baoe6aa3322015-08-05 15:20:27 -0700128static bool range_overlaps(const RangeSet& r1, const RangeSet& r2) {
Shrinivas Sahukara6153df2015-08-19 13:01:45 +0530129 for (size_t i = 0; i < r1.count; ++i) {
130 size_t r1_0 = r1.pos[i * 2];
131 size_t r1_1 = r1.pos[i * 2 + 1];
Sami Tolvanen90221202014-12-09 16:39:47 +0000132
Shrinivas Sahukara6153df2015-08-19 13:01:45 +0530133 for (size_t j = 0; j < r2.count; ++j) {
134 size_t r2_0 = r2.pos[j * 2];
135 size_t r2_1 = r2.pos[j * 2 + 1];
Sami Tolvanen90221202014-12-09 16:39:47 +0000136
Tao Baoc0f56ad2015-06-25 14:00:31 -0700137 if (!(r2_0 >= r1_1 || r1_0 >= r2_1)) {
Tao Baoe6aa3322015-08-05 15:20:27 -0700138 return true;
Sami Tolvanen90221202014-12-09 16:39:47 +0000139 }
140 }
141 }
142
Tao Baoe6aa3322015-08-05 15:20:27 -0700143 return false;
Sami Tolvanen90221202014-12-09 16:39:47 +0000144}
145
146static int read_all(int fd, uint8_t* data, size_t size) {
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700147 size_t so_far = 0;
148 while (so_far < size) {
Jed Estepa7b9a462015-12-15 16:04:53 -0800149 ssize_t r = TEMP_FAILURE_RETRY(ota_read(fd, data+so_far, size-so_far));
Elliott Hughes7bad7c42015-04-28 17:24:24 -0700150 if (r == -1) {
Tianjie Xu16255832016-04-30 11:49:59 -0700151 failure_type = kFreadFailure;
Tao Bao039f2da2016-11-22 16:29:50 -0800152 PLOG(ERROR) << "read failed";
Sami Tolvanen90221202014-12-09 16:39:47 +0000153 return -1;
Tianjie Xu71e182b2016-08-31 18:06:33 -0700154 } else if (r == 0) {
155 failure_type = kFreadFailure;
Tao Bao039f2da2016-11-22 16:29:50 -0800156 LOG(ERROR) << "read reached unexpected EOF.";
Tianjie Xu71e182b2016-08-31 18:06:33 -0700157 return -1;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700158 }
Elliott Hughes7bad7c42015-04-28 17:24:24 -0700159 so_far += r;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700160 }
Sami Tolvanen90221202014-12-09 16:39:47 +0000161 return 0;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700162}
163
Tao Bao612336d2015-08-27 16:41:21 -0700164static int read_all(int fd, std::vector<uint8_t>& buffer, size_t size) {
165 return read_all(fd, buffer.data(), size);
166}
167
Sami Tolvanen90221202014-12-09 16:39:47 +0000168static int write_all(int fd, const uint8_t* data, size_t size) {
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700169 size_t written = 0;
170 while (written < size) {
Jed Estepa7b9a462015-12-15 16:04:53 -0800171 ssize_t w = TEMP_FAILURE_RETRY(ota_write(fd, data+written, size-written));
Elliott Hughes7bad7c42015-04-28 17:24:24 -0700172 if (w == -1) {
Tianjie Xu16255832016-04-30 11:49:59 -0700173 failure_type = kFwriteFailure;
Tao Bao039f2da2016-11-22 16:29:50 -0800174 PLOG(ERROR) << "write failed";
Sami Tolvanen90221202014-12-09 16:39:47 +0000175 return -1;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700176 }
Elliott Hughes7bad7c42015-04-28 17:24:24 -0700177 written += w;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700178 }
Sami Tolvanen90221202014-12-09 16:39:47 +0000179
Sami Tolvanen90221202014-12-09 16:39:47 +0000180 return 0;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700181}
182
Tao Bao612336d2015-08-27 16:41:21 -0700183static int write_all(int fd, const std::vector<uint8_t>& buffer, size_t size) {
184 return write_all(fd, buffer.data(), size);
185}
186
Tianjie Xu7ce287d2016-05-31 09:29:49 -0700187static bool discard_blocks(int fd, off64_t offset, uint64_t size) {
188 // Don't discard blocks unless the update is a retry run.
189 if (!is_retry) {
190 return true;
191 }
192
193 uint64_t args[2] = {static_cast<uint64_t>(offset), size};
194 int status = ioctl(fd, BLKDISCARD, &args);
195 if (status == -1) {
Tao Bao039f2da2016-11-22 16:29:50 -0800196 PLOG(ERROR) << "BLKDISCARD ioctl failed";
Tianjie Xu7ce287d2016-05-31 09:29:49 -0700197 return false;
198 }
199 return true;
200}
201
Elliott Hughes7bad7c42015-04-28 17:24:24 -0700202static bool check_lseek(int fd, off64_t offset, int whence) {
203 off64_t rc = TEMP_FAILURE_RETRY(lseek64(fd, offset, whence));
204 if (rc == -1) {
Tianjie Xu16255832016-04-30 11:49:59 -0700205 failure_type = kLseekFailure;
Tao Bao039f2da2016-11-22 16:29:50 -0800206 PLOG(ERROR) << "lseek64 failed";
Elliott Hughes7bad7c42015-04-28 17:24:24 -0700207 return false;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700208 }
Elliott Hughes7bad7c42015-04-28 17:24:24 -0700209 return true;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700210}
211
Tao Bao612336d2015-08-27 16:41:21 -0700212static void allocate(size_t size, std::vector<uint8_t>& buffer) {
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700213 // if the buffer's big enough, reuse it.
Tao Bao612336d2015-08-27 16:41:21 -0700214 if (size <= buffer.size()) return;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700215
Tao Bao612336d2015-08-27 16:41:21 -0700216 buffer.resize(size);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700217}
218
Tao Bao0940fe12015-08-27 16:41:21 -0700219struct RangeSinkState {
Chih-Hung Hsieh49c5c792016-04-29 14:16:35 -0700220 explicit RangeSinkState(RangeSet& rs) : tgt(rs) { };
Tao Bao0940fe12015-08-27 16:41:21 -0700221
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700222 int fd;
Tao Bao0940fe12015-08-27 16:41:21 -0700223 const RangeSet& tgt;
Shrinivas Sahukara6153df2015-08-19 13:01:45 +0530224 size_t p_block;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700225 size_t p_remain;
Tao Bao0940fe12015-08-27 16:41:21 -0700226};
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700227
228static ssize_t RangeSinkWrite(const uint8_t* data, ssize_t size, void* token) {
Tao Bao0940fe12015-08-27 16:41:21 -0700229 RangeSinkState* rss = reinterpret_cast<RangeSinkState*>(token);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700230
Tao Bao0940fe12015-08-27 16:41:21 -0700231 if (rss->p_remain == 0) {
Tao Bao039f2da2016-11-22 16:29:50 -0800232 LOG(ERROR) << "range sink write overrun";
Sami Tolvanen90221202014-12-09 16:39:47 +0000233 return 0;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700234 }
235
236 ssize_t written = 0;
237 while (size > 0) {
238 size_t write_now = size;
Sami Tolvanen90221202014-12-09 16:39:47 +0000239
240 if (rss->p_remain < write_now) {
241 write_now = rss->p_remain;
242 }
243
244 if (write_all(rss->fd, data, write_now) == -1) {
245 break;
246 }
247
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700248 data += write_now;
249 size -= write_now;
250
251 rss->p_remain -= write_now;
252 written += write_now;
253
254 if (rss->p_remain == 0) {
255 // move to the next block
256 ++rss->p_block;
Tao Bao0940fe12015-08-27 16:41:21 -0700257 if (rss->p_block < rss->tgt.count) {
258 rss->p_remain = (rss->tgt.pos[rss->p_block * 2 + 1] -
259 rss->tgt.pos[rss->p_block * 2]) * BLOCKSIZE;
Sami Tolvanen90221202014-12-09 16:39:47 +0000260
Tianjie Xu7ce287d2016-05-31 09:29:49 -0700261 off64_t offset = static_cast<off64_t>(rss->tgt.pos[rss->p_block*2]) * BLOCKSIZE;
262 if (!discard_blocks(rss->fd, offset, rss->p_remain)) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000263 break;
264 }
Tianjie Xu7ce287d2016-05-31 09:29:49 -0700265
266 if (!check_lseek(rss->fd, offset, SEEK_SET)) {
267 break;
268 }
269
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700270 } else {
271 // we can't write any more; return how many bytes have
272 // been written so far.
Sami Tolvanen90221202014-12-09 16:39:47 +0000273 break;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700274 }
275 }
276 }
277
278 return written;
279}
280
281// All of the data for all the 'new' transfers is contained in one
282// file in the update package, concatenated together in the order in
283// which transfers.list will need it. We want to stream it out of the
284// archive (it's compressed) without writing it to a temp file, but we
285// can't write each section until it's that transfer's turn to go.
286//
287// To achieve this, we expand the new data from the archive in a
288// background thread, and block that threads 'receive uncompressed
289// data' function until the main thread has reached a point where we
290// want some new data to be written. We signal the background thread
291// with the destination for the data and block the main thread,
292// waiting for the background thread to complete writing that section.
293// Then it signals the main thread to wake up and goes back to
294// blocking waiting for a transfer.
295//
296// NewThreadInfo is the struct used to pass information back and forth
297// between the two threads. When the main thread wants some data
298// written, it sets rss to the destination location and signals the
299// condition. When the background thread is done writing, it clears
300// rss and signals the condition again.
301
Tao Bao0940fe12015-08-27 16:41:21 -0700302struct NewThreadInfo {
Tianjie Xu8cf5c8f2016-09-08 20:10:11 -0700303 ZipArchiveHandle za;
304 ZipEntry entry;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700305
306 RangeSinkState* rss;
307
308 pthread_mutex_t mu;
309 pthread_cond_t cv;
Tao Bao0940fe12015-08-27 16:41:21 -0700310};
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700311
Tianjie Xu8cf5c8f2016-09-08 20:10:11 -0700312static bool receive_new_data(const uint8_t* data, size_t size, void* cookie) {
Tao Bao0940fe12015-08-27 16:41:21 -0700313 NewThreadInfo* nti = reinterpret_cast<NewThreadInfo*>(cookie);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700314
315 while (size > 0) {
Tao Bao0940fe12015-08-27 16:41:21 -0700316 // Wait for nti->rss to be non-null, indicating some of this
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700317 // data is wanted.
318 pthread_mutex_lock(&nti->mu);
Tao Bao0940fe12015-08-27 16:41:21 -0700319 while (nti->rss == nullptr) {
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700320 pthread_cond_wait(&nti->cv, &nti->mu);
321 }
322 pthread_mutex_unlock(&nti->mu);
323
324 // At this point nti->rss is set, and we own it. The main
325 // thread is waiting for it to disappear from nti.
326 ssize_t written = RangeSinkWrite(data, size, nti->rss);
327 data += written;
328 size -= written;
329
Tao Bao0940fe12015-08-27 16:41:21 -0700330 if (nti->rss->p_block == nti->rss->tgt.count) {
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700331 // we have written all the bytes desired by this rss.
332
333 pthread_mutex_lock(&nti->mu);
Tao Bao0940fe12015-08-27 16:41:21 -0700334 nti->rss = nullptr;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700335 pthread_cond_broadcast(&nti->cv);
336 pthread_mutex_unlock(&nti->mu);
337 }
338 }
339
340 return true;
341}
342
343static void* unzip_new_data(void* cookie) {
344 NewThreadInfo* nti = (NewThreadInfo*) cookie;
Tianjie Xu8cf5c8f2016-09-08 20:10:11 -0700345 ProcessZipEntryContents(nti->za, &nti->entry, receive_new_data, nti);
Tao Bao0940fe12015-08-27 16:41:21 -0700346 return nullptr;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700347}
348
Tao Bao612336d2015-08-27 16:41:21 -0700349static int ReadBlocks(const RangeSet& src, std::vector<uint8_t>& buffer, int fd) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000350 size_t p = 0;
Tao Bao612336d2015-08-27 16:41:21 -0700351 uint8_t* data = buffer.data();
Sami Tolvanen90221202014-12-09 16:39:47 +0000352
Tao Bao0940fe12015-08-27 16:41:21 -0700353 for (size_t i = 0; i < src.count; ++i) {
354 if (!check_lseek(fd, (off64_t) src.pos[i * 2] * BLOCKSIZE, SEEK_SET)) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000355 return -1;
356 }
357
Tao Bao0940fe12015-08-27 16:41:21 -0700358 size_t size = (src.pos[i * 2 + 1] - src.pos[i * 2]) * BLOCKSIZE;
Sami Tolvanen90221202014-12-09 16:39:47 +0000359
Tao Bao612336d2015-08-27 16:41:21 -0700360 if (read_all(fd, data + p, size) == -1) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000361 return -1;
362 }
363
364 p += size;
365 }
366
367 return 0;
368}
369
Tao Bao612336d2015-08-27 16:41:21 -0700370static int WriteBlocks(const RangeSet& tgt, const std::vector<uint8_t>& buffer, int fd) {
371 const uint8_t* data = buffer.data();
Sami Tolvanen90221202014-12-09 16:39:47 +0000372
Tao Bao0940fe12015-08-27 16:41:21 -0700373 size_t p = 0;
374 for (size_t i = 0; i < tgt.count; ++i) {
Tianjie Xu7ce287d2016-05-31 09:29:49 -0700375 off64_t offset = static_cast<off64_t>(tgt.pos[i * 2]) * BLOCKSIZE;
376 size_t size = (tgt.pos[i * 2 + 1] - tgt.pos[i * 2]) * BLOCKSIZE;
377 if (!discard_blocks(fd, offset, size)) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000378 return -1;
379 }
380
Tianjie Xu7ce287d2016-05-31 09:29:49 -0700381 if (!check_lseek(fd, offset, SEEK_SET)) {
382 return -1;
383 }
Sami Tolvanen90221202014-12-09 16:39:47 +0000384
Tao Bao612336d2015-08-27 16:41:21 -0700385 if (write_all(fd, data + p, size) == -1) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000386 return -1;
387 }
388
389 p += size;
390 }
391
392 return 0;
393}
394
Tao Baobaad2d42015-12-06 16:56:27 -0800395// Parameters for transfer list command functions
396struct CommandParameters {
397 std::vector<std::string> tokens;
398 size_t cpos;
399 const char* cmdname;
400 const char* cmdline;
401 std::string freestash;
402 std::string stashbase;
403 bool canwrite;
404 int createdstash;
Elliott Hughesbcabd092016-03-22 20:19:22 -0700405 android::base::unique_fd fd;
Tao Baobaad2d42015-12-06 16:56:27 -0800406 bool foundwrites;
407 bool isunresumable;
408 int version;
409 size_t written;
Tianjie Xudd874b12016-05-13 12:13:15 -0700410 size_t stashed;
Tao Baobaad2d42015-12-06 16:56:27 -0800411 NewThreadInfo nti;
412 pthread_t thread;
413 std::vector<uint8_t> buffer;
414 uint8_t* patch_start;
415};
416
Doug Zongker52ae67d2014-09-08 12:22:09 -0700417// Do a source/target load for move/bsdiff/imgdiff in version 1.
Tao Baobaad2d42015-12-06 16:56:27 -0800418// We expect to parse the remainder of the parameter tokens as:
Doug Zongker52ae67d2014-09-08 12:22:09 -0700419//
420// <src_range> <tgt_range>
421//
422// The source range is loaded into the provided buffer, reallocating
Tao Bao34847b22015-09-08 11:05:49 -0700423// it to make it larger if necessary.
Doug Zongker52ae67d2014-09-08 12:22:09 -0700424
Tao Baobaad2d42015-12-06 16:56:27 -0800425static int LoadSrcTgtVersion1(CommandParameters& params, RangeSet& tgt, size_t& src_blocks,
Tao Bao612336d2015-08-27 16:41:21 -0700426 std::vector<uint8_t>& buffer, int fd) {
Tao Baobaad2d42015-12-06 16:56:27 -0800427
428 if (params.cpos + 1 >= params.tokens.size()) {
Tao Bao039f2da2016-11-22 16:29:50 -0800429 LOG(ERROR) << "invalid parameters";
Tao Baobaad2d42015-12-06 16:56:27 -0800430 return -1;
431 }
432
Tao Bao612336d2015-08-27 16:41:21 -0700433 // <src_range>
Tao Bao0940fe12015-08-27 16:41:21 -0700434 RangeSet src;
Tao Baobaad2d42015-12-06 16:56:27 -0800435 parse_range(params.tokens[params.cpos++], src);
Doug Zongker52ae67d2014-09-08 12:22:09 -0700436
Tao Bao612336d2015-08-27 16:41:21 -0700437 // <tgt_range>
Tao Baobaad2d42015-12-06 16:56:27 -0800438 parse_range(params.tokens[params.cpos++], tgt);
Doug Zongker52ae67d2014-09-08 12:22:09 -0700439
Tao Bao612336d2015-08-27 16:41:21 -0700440 allocate(src.size * BLOCKSIZE, buffer);
441 int rc = ReadBlocks(src, buffer, fd);
Tao Bao0940fe12015-08-27 16:41:21 -0700442 src_blocks = src.size;
Sami Tolvanen90221202014-12-09 16:39:47 +0000443
Sami Tolvanen90221202014-12-09 16:39:47 +0000444 return rc;
445}
446
Tao Bao612336d2015-08-27 16:41:21 -0700447static int VerifyBlocks(const std::string& expected, const std::vector<uint8_t>& buffer,
Tao Bao0940fe12015-08-27 16:41:21 -0700448 const size_t blocks, bool printerror) {
Sen Jiangc48cb5e2016-02-04 16:23:21 +0800449 uint8_t digest[SHA_DIGEST_LENGTH];
Tao Bao612336d2015-08-27 16:41:21 -0700450 const uint8_t* data = buffer.data();
Sami Tolvanen90221202014-12-09 16:39:47 +0000451
Sen Jiangc48cb5e2016-02-04 16:23:21 +0800452 SHA1(data, blocks * BLOCKSIZE, digest);
Sami Tolvanen90221202014-12-09 16:39:47 +0000453
Tao Baoe6aa3322015-08-05 15:20:27 -0700454 std::string hexdigest = print_sha1(digest);
Sami Tolvanen90221202014-12-09 16:39:47 +0000455
Tao Bao0940fe12015-08-27 16:41:21 -0700456 if (hexdigest != expected) {
457 if (printerror) {
Tao Bao039f2da2016-11-22 16:29:50 -0800458 LOG(ERROR) << "failed to verify blocks (expected " << expected << ", read "
459 << hexdigest << ")";
Tao Bao0940fe12015-08-27 16:41:21 -0700460 }
461 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000462 }
463
Tao Bao0940fe12015-08-27 16:41:21 -0700464 return 0;
Sami Tolvanen90221202014-12-09 16:39:47 +0000465}
466
Tao Bao0940fe12015-08-27 16:41:21 -0700467static std::string GetStashFileName(const std::string& base, const std::string& id,
468 const std::string& postfix) {
Tao Baoe6aa3322015-08-05 15:20:27 -0700469 if (base.empty()) {
470 return "";
Sami Tolvanen90221202014-12-09 16:39:47 +0000471 }
472
Tao Baoe6aa3322015-08-05 15:20:27 -0700473 std::string fn(STASH_DIRECTORY_BASE);
474 fn += "/" + base + "/" + id + postfix;
Sami Tolvanen90221202014-12-09 16:39:47 +0000475
476 return fn;
477}
478
Tao Baoe6aa3322015-08-05 15:20:27 -0700479typedef void (*StashCallback)(const std::string&, void*);
Sami Tolvanen90221202014-12-09 16:39:47 +0000480
481// Does a best effort enumeration of stash files. Ignores possible non-file
482// items in the stash directory and continues despite of errors. Calls the
483// 'callback' function for each file and passes 'data' to the function as a
484// parameter.
485
Tao Baoe6aa3322015-08-05 15:20:27 -0700486static void EnumerateStash(const std::string& dirname, StashCallback callback, void* data) {
Tao Bao0940fe12015-08-27 16:41:21 -0700487 if (dirname.empty() || callback == nullptr) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000488 return;
489 }
490
Tao Baoe6aa3322015-08-05 15:20:27 -0700491 std::unique_ptr<DIR, int(*)(DIR*)> directory(opendir(dirname.c_str()), closedir);
Sami Tolvanen90221202014-12-09 16:39:47 +0000492
Tao Bao0940fe12015-08-27 16:41:21 -0700493 if (directory == nullptr) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000494 if (errno != ENOENT) {
Tao Bao039f2da2016-11-22 16:29:50 -0800495 PLOG(ERROR) << "opendir \"" << dirname << "\" failed";
Sami Tolvanen90221202014-12-09 16:39:47 +0000496 }
497 return;
498 }
499
Tao Baoe6aa3322015-08-05 15:20:27 -0700500 struct dirent* item;
Tao Bao0940fe12015-08-27 16:41:21 -0700501 while ((item = readdir(directory.get())) != nullptr) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000502 if (item->d_type != DT_REG) {
503 continue;
504 }
505
Tao Baoe6aa3322015-08-05 15:20:27 -0700506 std::string fn = dirname + "/" + std::string(item->d_name);
Sami Tolvanen90221202014-12-09 16:39:47 +0000507 callback(fn, data);
Sami Tolvanen90221202014-12-09 16:39:47 +0000508 }
509}
510
Tao Baoe6aa3322015-08-05 15:20:27 -0700511static void UpdateFileSize(const std::string& fn, void* data) {
512 if (fn.empty() || !data) {
513 return;
514 }
515
Tao Bao0940fe12015-08-27 16:41:21 -0700516 struct stat sb;
517 if (stat(fn.c_str(), &sb) == -1) {
Tao Bao039f2da2016-11-22 16:29:50 -0800518 PLOG(ERROR) << "stat \"" << fn << "\" failed";
Sami Tolvanen90221202014-12-09 16:39:47 +0000519 return;
520 }
521
Tao Baoe6aa3322015-08-05 15:20:27 -0700522 int* size = reinterpret_cast<int*>(data);
Tao Bao0940fe12015-08-27 16:41:21 -0700523 *size += sb.st_size;
Sami Tolvanen90221202014-12-09 16:39:47 +0000524}
525
526// Deletes the stash directory and all files in it. Assumes that it only
527// contains files. There is nothing we can do about unlikely, but possible
528// errors, so they are merely logged.
529
Tao Bao0940fe12015-08-27 16:41:21 -0700530static void DeleteFile(const std::string& fn, void* /* data */) {
Tao Baoe6aa3322015-08-05 15:20:27 -0700531 if (!fn.empty()) {
Tao Bao039f2da2016-11-22 16:29:50 -0800532 LOG(INFO) << "deleting " << fn;
Sami Tolvanen90221202014-12-09 16:39:47 +0000533
Tao Baoe6aa3322015-08-05 15:20:27 -0700534 if (unlink(fn.c_str()) == -1 && errno != ENOENT) {
Tao Bao039f2da2016-11-22 16:29:50 -0800535 PLOG(ERROR) << "unlink \"" << fn << "\" failed";
Sami Tolvanen90221202014-12-09 16:39:47 +0000536 }
537 }
538}
539
Tao Baoe6aa3322015-08-05 15:20:27 -0700540static void DeletePartial(const std::string& fn, void* data) {
541 if (android::base::EndsWith(fn, ".partial")) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000542 DeleteFile(fn, data);
543 }
544}
545
Tao Baoe6aa3322015-08-05 15:20:27 -0700546static void DeleteStash(const std::string& base) {
547 if (base.empty()) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000548 return;
549 }
550
Tao Bao039f2da2016-11-22 16:29:50 -0800551 LOG(INFO) << "deleting stash " << base;
Sami Tolvanen90221202014-12-09 16:39:47 +0000552
Tao Baoe6aa3322015-08-05 15:20:27 -0700553 std::string dirname = GetStashFileName(base, "", "");
Tao Bao0940fe12015-08-27 16:41:21 -0700554 EnumerateStash(dirname, DeleteFile, nullptr);
Sami Tolvanen90221202014-12-09 16:39:47 +0000555
Tao Baoe6aa3322015-08-05 15:20:27 -0700556 if (rmdir(dirname.c_str()) == -1) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000557 if (errno != ENOENT && errno != ENOTDIR) {
Tao Bao039f2da2016-11-22 16:29:50 -0800558 PLOG(ERROR) << "rmdir \"" << dirname << "\" failed";
Sami Tolvanen90221202014-12-09 16:39:47 +0000559 }
560 }
Sami Tolvanen90221202014-12-09 16:39:47 +0000561}
562
Tianjie Xu7eca97e2016-03-22 18:08:12 -0700563static int LoadStash(CommandParameters& params, const std::string& base, const std::string& id,
564 bool verify, size_t* blocks, std::vector<uint8_t>& buffer, bool printnoent) {
565 // In verify mode, if source range_set was saved for the given hash,
566 // check contents in the source blocks first. If the check fails,
567 // search for the stashed files on /cache as usual.
568 if (!params.canwrite) {
569 if (stash_map.find(id) != stash_map.end()) {
570 const RangeSet& src = stash_map[id];
571 allocate(src.size * BLOCKSIZE, buffer);
572
573 if (ReadBlocks(src, buffer, params.fd) == -1) {
Tao Bao039f2da2016-11-22 16:29:50 -0800574 LOG(ERROR) << "failed to read source blocks in stash map.";
Tianjie Xu7eca97e2016-03-22 18:08:12 -0700575 return -1;
576 }
577 if (VerifyBlocks(id, buffer, src.size, true) != 0) {
Tao Bao039f2da2016-11-22 16:29:50 -0800578 LOG(ERROR) << "failed to verify loaded source blocks in stash map.";
Tianjie Xu7eca97e2016-03-22 18:08:12 -0700579 return -1;
580 }
581 return 0;
582 }
583 }
584
Tao Bao612336d2015-08-27 16:41:21 -0700585 if (base.empty()) {
Tao Bao0940fe12015-08-27 16:41:21 -0700586 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000587 }
588
Tao Bao0940fe12015-08-27 16:41:21 -0700589 size_t blockcount = 0;
590
Sami Tolvanen90221202014-12-09 16:39:47 +0000591 if (!blocks) {
592 blocks = &blockcount;
593 }
594
Tao Bao0940fe12015-08-27 16:41:21 -0700595 std::string fn = GetStashFileName(base, id, "");
Sami Tolvanen90221202014-12-09 16:39:47 +0000596
Tao Bao0940fe12015-08-27 16:41:21 -0700597 struct stat sb;
598 int res = stat(fn.c_str(), &sb);
Sami Tolvanen90221202014-12-09 16:39:47 +0000599
600 if (res == -1) {
601 if (errno != ENOENT || printnoent) {
Tao Bao039f2da2016-11-22 16:29:50 -0800602 PLOG(ERROR) << "stat \"" << fn << "\" failed";
Sami Tolvanen90221202014-12-09 16:39:47 +0000603 }
Tao Bao0940fe12015-08-27 16:41:21 -0700604 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000605 }
606
Tao Bao039f2da2016-11-22 16:29:50 -0800607 LOG(INFO) << " loading " << fn;
Sami Tolvanen90221202014-12-09 16:39:47 +0000608
Tao Bao0940fe12015-08-27 16:41:21 -0700609 if ((sb.st_size % BLOCKSIZE) != 0) {
Tao Bao039f2da2016-11-22 16:29:50 -0800610 LOG(ERROR) << fn << " size " << sb.st_size << " not multiple of block size " << BLOCKSIZE;
Tao Bao0940fe12015-08-27 16:41:21 -0700611 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000612 }
613
Elliott Hughesbcabd092016-03-22 20:19:22 -0700614 android::base::unique_fd fd(TEMP_FAILURE_RETRY(ota_open(fn.c_str(), O_RDONLY)));
Sami Tolvanen90221202014-12-09 16:39:47 +0000615 if (fd == -1) {
Tao Bao039f2da2016-11-22 16:29:50 -0800616 PLOG(ERROR) << "open \"" << fn << "\" failed";
Tao Bao0940fe12015-08-27 16:41:21 -0700617 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000618 }
619
Tao Bao612336d2015-08-27 16:41:21 -0700620 allocate(sb.st_size, buffer);
Sami Tolvanen90221202014-12-09 16:39:47 +0000621
Tao Bao612336d2015-08-27 16:41:21 -0700622 if (read_all(fd, buffer, sb.st_size) == -1) {
Tao Bao0940fe12015-08-27 16:41:21 -0700623 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000624 }
625
Tao Bao0940fe12015-08-27 16:41:21 -0700626 *blocks = sb.st_size / BLOCKSIZE;
Sami Tolvanen90221202014-12-09 16:39:47 +0000627
Tao Bao612336d2015-08-27 16:41:21 -0700628 if (verify && VerifyBlocks(id, buffer, *blocks, true) != 0) {
Tao Bao039f2da2016-11-22 16:29:50 -0800629 LOG(ERROR) << "unexpected contents in " << fn;
Tao Bao0940fe12015-08-27 16:41:21 -0700630 DeleteFile(fn, nullptr);
631 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000632 }
633
Tao Bao0940fe12015-08-27 16:41:21 -0700634 return 0;
Sami Tolvanen90221202014-12-09 16:39:47 +0000635}
636
Tao Bao612336d2015-08-27 16:41:21 -0700637static int WriteStash(const std::string& base, const std::string& id, int blocks,
638 std::vector<uint8_t>& buffer, bool checkspace, bool *exists) {
639 if (base.empty()) {
Tao Bao0940fe12015-08-27 16:41:21 -0700640 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000641 }
642
643 if (checkspace && CacheSizeCheck(blocks * BLOCKSIZE) != 0) {
Tao Bao039f2da2016-11-22 16:29:50 -0800644 LOG(ERROR) << "not enough space to write stash";
Tao Bao0940fe12015-08-27 16:41:21 -0700645 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000646 }
647
Tao Bao0940fe12015-08-27 16:41:21 -0700648 std::string fn = GetStashFileName(base, id, ".partial");
649 std::string cn = GetStashFileName(base, id, "");
Sami Tolvanen90221202014-12-09 16:39:47 +0000650
Sami Tolvanen43b748f2015-04-17 12:50:31 +0100651 if (exists) {
Tao Bao0940fe12015-08-27 16:41:21 -0700652 struct stat sb;
653 int res = stat(cn.c_str(), &sb);
Sami Tolvanen43b748f2015-04-17 12:50:31 +0100654
655 if (res == 0) {
656 // The file already exists and since the name is the hash of the contents,
657 // it's safe to assume the contents are identical (accidental hash collisions
658 // are unlikely)
Tao Bao039f2da2016-11-22 16:29:50 -0800659 LOG(INFO) << " skipping " << blocks << " existing blocks in " << cn;
Tao Bao0940fe12015-08-27 16:41:21 -0700660 *exists = true;
661 return 0;
Sami Tolvanen43b748f2015-04-17 12:50:31 +0100662 }
663
Tao Bao0940fe12015-08-27 16:41:21 -0700664 *exists = false;
Sami Tolvanen43b748f2015-04-17 12:50:31 +0100665 }
666
Tao Bao039f2da2016-11-22 16:29:50 -0800667 LOG(INFO) << " writing " << blocks << " blocks to " << cn;
Sami Tolvanen90221202014-12-09 16:39:47 +0000668
Tao Bao039f2da2016-11-22 16:29:50 -0800669 android::base::unique_fd fd(
670 TEMP_FAILURE_RETRY(ota_open(fn.c_str(), O_WRONLY | O_CREAT | O_TRUNC, STASH_FILE_MODE)));
Sami Tolvanen90221202014-12-09 16:39:47 +0000671 if (fd == -1) {
Tao Bao039f2da2016-11-22 16:29:50 -0800672 PLOG(ERROR) << "failed to create \"" << fn << "\"";
Tao Bao0940fe12015-08-27 16:41:21 -0700673 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000674 }
675
676 if (write_all(fd, buffer, blocks * BLOCKSIZE) == -1) {
Tao Bao0940fe12015-08-27 16:41:21 -0700677 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000678 }
679
Jed Estepa7b9a462015-12-15 16:04:53 -0800680 if (ota_fsync(fd) == -1) {
Tianjie Xu16255832016-04-30 11:49:59 -0700681 failure_type = kFsyncFailure;
Tao Bao039f2da2016-11-22 16:29:50 -0800682 PLOG(ERROR) << "fsync \"" << fn << "\" failed";
Tao Bao0940fe12015-08-27 16:41:21 -0700683 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000684 }
685
Tao Baoe6aa3322015-08-05 15:20:27 -0700686 if (rename(fn.c_str(), cn.c_str()) == -1) {
Tao Bao039f2da2016-11-22 16:29:50 -0800687 PLOG(ERROR) << "rename(\"" << fn << "\", \"" << cn << "\") failed";
Tao Bao0940fe12015-08-27 16:41:21 -0700688 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000689 }
690
Tao Bao0940fe12015-08-27 16:41:21 -0700691 std::string dname = GetStashFileName(base, "", "");
Elliott Hughesbcabd092016-03-22 20:19:22 -0700692 android::base::unique_fd dfd(TEMP_FAILURE_RETRY(ota_open(dname.c_str(),
693 O_RDONLY | O_DIRECTORY)));
Tao Baodc392262015-07-31 15:56:44 -0700694 if (dfd == -1) {
Tianjie Xu16255832016-04-30 11:49:59 -0700695 failure_type = kFileOpenFailure;
Tao Bao039f2da2016-11-22 16:29:50 -0800696 PLOG(ERROR) << "failed to open \"" << dname << "\" failed";
Tao Bao0940fe12015-08-27 16:41:21 -0700697 return -1;
Tao Baodc392262015-07-31 15:56:44 -0700698 }
699
Jed Estepa7b9a462015-12-15 16:04:53 -0800700 if (ota_fsync(dfd) == -1) {
Tianjie Xu16255832016-04-30 11:49:59 -0700701 failure_type = kFsyncFailure;
Tao Bao039f2da2016-11-22 16:29:50 -0800702 PLOG(ERROR) << "fsync \"" << dname << "\" failed";
Tao Bao0940fe12015-08-27 16:41:21 -0700703 return -1;
Tao Baodc392262015-07-31 15:56:44 -0700704 }
705
Tao Bao0940fe12015-08-27 16:41:21 -0700706 return 0;
Sami Tolvanen90221202014-12-09 16:39:47 +0000707}
708
709// Creates a directory for storing stash files and checks if the /cache partition
710// hash enough space for the expected amount of blocks we need to store. Returns
711// >0 if we created the directory, zero if it existed already, and <0 of failure.
712
Tao Bao0940fe12015-08-27 16:41:21 -0700713static int CreateStash(State* state, int maxblocks, const char* blockdev, std::string& base) {
714 if (blockdev == nullptr) {
Tao Baoe6aa3322015-08-05 15:20:27 -0700715 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000716 }
717
718 // Stash directory should be different for each partition to avoid conflicts
719 // when updating multiple partitions at the same time, so we use the hash of
720 // the block device name as the base directory
Sen Jiangc48cb5e2016-02-04 16:23:21 +0800721 uint8_t digest[SHA_DIGEST_LENGTH];
722 SHA1(reinterpret_cast<const uint8_t*>(blockdev), strlen(blockdev), digest);
Tao Baoe6aa3322015-08-05 15:20:27 -0700723 base = print_sha1(digest);
Sami Tolvanen90221202014-12-09 16:39:47 +0000724
Tao Baoe6aa3322015-08-05 15:20:27 -0700725 std::string dirname = GetStashFileName(base, "", "");
Tao Bao0940fe12015-08-27 16:41:21 -0700726 struct stat sb;
727 int res = stat(dirname.c_str(), &sb);
Sami Tolvanen90221202014-12-09 16:39:47 +0000728
729 if (res == -1 && errno != ENOENT) {
Tianjie Xu16255832016-04-30 11:49:59 -0700730 ErrorAbort(state, kStashCreationFailure, "stat \"%s\" failed: %s\n",
731 dirname.c_str(), strerror(errno));
Tao Baoe6aa3322015-08-05 15:20:27 -0700732 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000733 } else if (res != 0) {
Tao Bao039f2da2016-11-22 16:29:50 -0800734 LOG(INFO) << "creating stash " << dirname;
Tao Baoe6aa3322015-08-05 15:20:27 -0700735 res = mkdir(dirname.c_str(), STASH_DIRECTORY_MODE);
Sami Tolvanen90221202014-12-09 16:39:47 +0000736
737 if (res != 0) {
Tianjie Xu16255832016-04-30 11:49:59 -0700738 ErrorAbort(state, kStashCreationFailure, "mkdir \"%s\" failed: %s\n",
739 dirname.c_str(), strerror(errno));
Tao Baoe6aa3322015-08-05 15:20:27 -0700740 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000741 }
742
743 if (CacheSizeCheck(maxblocks * BLOCKSIZE) != 0) {
Tianjie Xu16255832016-04-30 11:49:59 -0700744 ErrorAbort(state, kStashCreationFailure, "not enough space for stash\n");
Tao Baoe6aa3322015-08-05 15:20:27 -0700745 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000746 }
747
Tao Baoe6aa3322015-08-05 15:20:27 -0700748 return 1; // Created directory
Sami Tolvanen90221202014-12-09 16:39:47 +0000749 }
750
Tao Bao039f2da2016-11-22 16:29:50 -0800751 LOG(INFO) << "using existing stash " << dirname;
Sami Tolvanen90221202014-12-09 16:39:47 +0000752
753 // If the directory already exists, calculate the space already allocated to
754 // stash files and check if there's enough for all required blocks. Delete any
755 // partially completed stash files first.
756
Tao Bao0940fe12015-08-27 16:41:21 -0700757 EnumerateStash(dirname, DeletePartial, nullptr);
Tao Baoe6aa3322015-08-05 15:20:27 -0700758 int size = 0;
Sami Tolvanen90221202014-12-09 16:39:47 +0000759 EnumerateStash(dirname, UpdateFileSize, &size);
760
Tao Bao0940fe12015-08-27 16:41:21 -0700761 size = maxblocks * BLOCKSIZE - size;
Sami Tolvanen90221202014-12-09 16:39:47 +0000762
763 if (size > 0 && CacheSizeCheck(size) != 0) {
Tianjie Xu16255832016-04-30 11:49:59 -0700764 ErrorAbort(state, kStashCreationFailure, "not enough space for stash (%d more needed)\n",
765 size);
Tao Baoe6aa3322015-08-05 15:20:27 -0700766 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000767 }
768
Tao Baoe6aa3322015-08-05 15:20:27 -0700769 return 0; // Using existing directory
Sami Tolvanen90221202014-12-09 16:39:47 +0000770}
771
Tao Baobaad2d42015-12-06 16:56:27 -0800772static int SaveStash(CommandParameters& params, const std::string& base,
773 std::vector<uint8_t>& buffer, int fd, bool usehash) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000774
Tao Baobaad2d42015-12-06 16:56:27 -0800775 // <stash_id> <src_range>
776 if (params.cpos + 1 >= params.tokens.size()) {
Tao Bao039f2da2016-11-22 16:29:50 -0800777 LOG(ERROR) << "missing id and/or src range fields in stash command";
Sami Tolvanen90221202014-12-09 16:39:47 +0000778 return -1;
779 }
Tao Baobaad2d42015-12-06 16:56:27 -0800780 const std::string& id = params.tokens[params.cpos++];
Sami Tolvanen90221202014-12-09 16:39:47 +0000781
Tao Bao0940fe12015-08-27 16:41:21 -0700782 size_t blocks = 0;
Tianjie Xu7eca97e2016-03-22 18:08:12 -0700783 if (usehash && LoadStash(params, base, id, true, &blocks, buffer, false) == 0) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000784 // Stash file already exists and has expected contents. Do not
785 // read from source again, as the source may have been already
786 // overwritten during a previous attempt.
787 return 0;
788 }
789
Tao Bao34847b22015-09-08 11:05:49 -0700790 RangeSet src;
Tao Baobaad2d42015-12-06 16:56:27 -0800791 parse_range(params.tokens[params.cpos++], src);
Tao Bao34847b22015-09-08 11:05:49 -0700792
Tao Bao612336d2015-08-27 16:41:21 -0700793 allocate(src.size * BLOCKSIZE, buffer);
794 if (ReadBlocks(src, buffer, fd) == -1) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000795 return -1;
796 }
Tao Bao34847b22015-09-08 11:05:49 -0700797 blocks = src.size;
Sami Tolvanen90221202014-12-09 16:39:47 +0000798
Tao Bao612336d2015-08-27 16:41:21 -0700799 if (usehash && VerifyBlocks(id, buffer, blocks, true) != 0) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000800 // Source blocks have unexpected contents. If we actually need this
801 // data later, this is an unrecoverable error. However, the command
802 // that uses the data may have already completed previously, so the
803 // possible failure will occur during source block verification.
Tao Bao039f2da2016-11-22 16:29:50 -0800804 LOG(ERROR) << "failed to load source blocks for stash " << id;
Sami Tolvanen90221202014-12-09 16:39:47 +0000805 return 0;
806 }
807
Tianjie Xu7eca97e2016-03-22 18:08:12 -0700808 // In verify mode, save source range_set instead of stashing blocks.
809 if (!params.canwrite && usehash) {
810 stash_map[id] = src;
811 return 0;
812 }
813
Tao Bao039f2da2016-11-22 16:29:50 -0800814 LOG(INFO) << "stashing " << blocks << " blocks to " << id;
Tianjie Xudd874b12016-05-13 12:13:15 -0700815 params.stashed += blocks;
Tao Bao612336d2015-08-27 16:41:21 -0700816 return WriteStash(base, id, blocks, buffer, false, nullptr);
Sami Tolvanen90221202014-12-09 16:39:47 +0000817}
818
Tao Baobaad2d42015-12-06 16:56:27 -0800819static int FreeStash(const std::string& base, const std::string& id) {
820 if (base.empty() || id.empty()) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000821 return -1;
822 }
823
Tao Baobaad2d42015-12-06 16:56:27 -0800824 std::string fn = GetStashFileName(base, id, "");
Tao Bao0940fe12015-08-27 16:41:21 -0700825 DeleteFile(fn, nullptr);
Sami Tolvanen90221202014-12-09 16:39:47 +0000826
827 return 0;
Doug Zongker52ae67d2014-09-08 12:22:09 -0700828}
829
Tao Bao612336d2015-08-27 16:41:21 -0700830static void MoveRange(std::vector<uint8_t>& dest, const RangeSet& locs,
831 const std::vector<uint8_t>& source) {
Doug Zongker52ae67d2014-09-08 12:22:09 -0700832 // source contains packed data, which we want to move to the
Tao Bao612336d2015-08-27 16:41:21 -0700833 // locations given in locs in the dest buffer. source and dest
Doug Zongker52ae67d2014-09-08 12:22:09 -0700834 // may be the same buffer.
835
Tao Bao612336d2015-08-27 16:41:21 -0700836 const uint8_t* from = source.data();
837 uint8_t* to = dest.data();
Tao Bao0940fe12015-08-27 16:41:21 -0700838 size_t start = locs.size;
839 for (int i = locs.count-1; i >= 0; --i) {
840 size_t blocks = locs.pos[i*2+1] - locs.pos[i*2];
Doug Zongker52ae67d2014-09-08 12:22:09 -0700841 start -= blocks;
Tao Bao612336d2015-08-27 16:41:21 -0700842 memmove(to + (locs.pos[i*2] * BLOCKSIZE), from + (start * BLOCKSIZE),
Doug Zongker52ae67d2014-09-08 12:22:09 -0700843 blocks * BLOCKSIZE);
844 }
845}
846
847// Do a source/target load for move/bsdiff/imgdiff in version 2.
Tao Baobaad2d42015-12-06 16:56:27 -0800848// We expect to parse the remainder of the parameter tokens as one of:
Doug Zongker52ae67d2014-09-08 12:22:09 -0700849//
850// <tgt_range> <src_block_count> <src_range>
851// (loads data from source image only)
852//
853// <tgt_range> <src_block_count> - <[stash_id:stash_range] ...>
854// (loads data from stashes only)
855//
856// <tgt_range> <src_block_count> <src_range> <src_loc> <[stash_id:stash_range] ...>
857// (loads data from both source image and stashes)
858//
859// On return, buffer is filled with the loaded source data (rearranged
860// and combined with stashed data as necessary). buffer may be
861// reallocated if needed to accommodate the source data. *tgt is the
Sami Tolvanen90221202014-12-09 16:39:47 +0000862// target RangeSet. Any stashes required are loaded using LoadStash.
Doug Zongker52ae67d2014-09-08 12:22:09 -0700863
Tao Baobaad2d42015-12-06 16:56:27 -0800864static int LoadSrcTgtVersion2(CommandParameters& params, RangeSet& tgt, size_t& src_blocks,
Tao Bao612336d2015-08-27 16:41:21 -0700865 std::vector<uint8_t>& buffer, int fd, const std::string& stashbase, bool* overlap) {
Tao Baobaad2d42015-12-06 16:56:27 -0800866
867 // At least it needs to provide three parameters: <tgt_range>,
868 // <src_block_count> and "-"/<src_range>.
869 if (params.cpos + 2 >= params.tokens.size()) {
Tao Bao039f2da2016-11-22 16:29:50 -0800870 LOG(ERROR) << "invalid parameters";
Tao Baobaad2d42015-12-06 16:56:27 -0800871 return -1;
872 }
873
Tao Bao612336d2015-08-27 16:41:21 -0700874 // <tgt_range>
Tao Baobaad2d42015-12-06 16:56:27 -0800875 parse_range(params.tokens[params.cpos++], tgt);
Doug Zongker52ae67d2014-09-08 12:22:09 -0700876
Tao Bao612336d2015-08-27 16:41:21 -0700877 // <src_block_count>
Tao Baobaad2d42015-12-06 16:56:27 -0800878 const std::string& token = params.tokens[params.cpos++];
879 if (!android::base::ParseUint(token.c_str(), &src_blocks)) {
Tao Bao039f2da2016-11-22 16:29:50 -0800880 LOG(ERROR) << "invalid src_block_count \"" << token << "\"";
Tao Baobaad2d42015-12-06 16:56:27 -0800881 return -1;
882 }
Doug Zongker52ae67d2014-09-08 12:22:09 -0700883
Tao Bao612336d2015-08-27 16:41:21 -0700884 allocate(src_blocks * BLOCKSIZE, buffer);
Doug Zongker52ae67d2014-09-08 12:22:09 -0700885
Tao Bao612336d2015-08-27 16:41:21 -0700886 // "-" or <src_range> [<src_loc>]
Tao Baobaad2d42015-12-06 16:56:27 -0800887 if (params.tokens[params.cpos] == "-") {
Doug Zongker52ae67d2014-09-08 12:22:09 -0700888 // no source ranges, only stashes
Tao Baobaad2d42015-12-06 16:56:27 -0800889 params.cpos++;
Doug Zongker52ae67d2014-09-08 12:22:09 -0700890 } else {
Tao Bao0940fe12015-08-27 16:41:21 -0700891 RangeSet src;
Tao Baobaad2d42015-12-06 16:56:27 -0800892 parse_range(params.tokens[params.cpos++], src);
Tao Bao612336d2015-08-27 16:41:21 -0700893 int res = ReadBlocks(src, buffer, fd);
Doug Zongker52ae67d2014-09-08 12:22:09 -0700894
Tao Bao34847b22015-09-08 11:05:49 -0700895 if (overlap) {
896 *overlap = range_overlaps(src, tgt);
Doug Zongker52ae67d2014-09-08 12:22:09 -0700897 }
Sami Tolvanen90221202014-12-09 16:39:47 +0000898
Sami Tolvanen90221202014-12-09 16:39:47 +0000899 if (res == -1) {
900 return -1;
Doug Zongker52ae67d2014-09-08 12:22:09 -0700901 }
902
Tao Baobaad2d42015-12-06 16:56:27 -0800903 if (params.cpos >= params.tokens.size()) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000904 // no stashes, only source range
905 return 0;
906 }
907
Tao Bao612336d2015-08-27 16:41:21 -0700908 RangeSet locs;
Tao Baobaad2d42015-12-06 16:56:27 -0800909 parse_range(params.tokens[params.cpos++], locs);
Tao Bao612336d2015-08-27 16:41:21 -0700910 MoveRange(buffer, locs, buffer);
Doug Zongker52ae67d2014-09-08 12:22:09 -0700911 }
912
Tao Baobaad2d42015-12-06 16:56:27 -0800913 // <[stash_id:stash_range]>
914 while (params.cpos < params.tokens.size()) {
Doug Zongker52ae67d2014-09-08 12:22:09 -0700915 // Each word is a an index into the stash table, a colon, and
916 // then a rangeset describing where in the source block that
917 // stashed data should go.
Tao Baobaad2d42015-12-06 16:56:27 -0800918 std::vector<std::string> tokens = android::base::Split(params.tokens[params.cpos++], ":");
919 if (tokens.size() != 2) {
Tao Bao039f2da2016-11-22 16:29:50 -0800920 LOG(ERROR) << "invalid parameter";
Tao Baobaad2d42015-12-06 16:56:27 -0800921 return -1;
922 }
Sami Tolvanen90221202014-12-09 16:39:47 +0000923
Tao Bao612336d2015-08-27 16:41:21 -0700924 std::vector<uint8_t> stash;
Tianjie Xu7eca97e2016-03-22 18:08:12 -0700925 int res = LoadStash(params, stashbase, tokens[0], false, nullptr, stash, true);
Sami Tolvanen90221202014-12-09 16:39:47 +0000926
927 if (res == -1) {
928 // These source blocks will fail verification if used later, but we
929 // will let the caller decide if this is a fatal failure
Tao Bao039f2da2016-11-22 16:29:50 -0800930 LOG(ERROR) << "failed to load stash " << tokens[0];
Sami Tolvanen90221202014-12-09 16:39:47 +0000931 continue;
932 }
933
Tao Bao612336d2015-08-27 16:41:21 -0700934 RangeSet locs;
Tao Baobaad2d42015-12-06 16:56:27 -0800935 parse_range(tokens[1], locs);
Sami Tolvanen90221202014-12-09 16:39:47 +0000936
Tao Bao612336d2015-08-27 16:41:21 -0700937 MoveRange(buffer, locs, stash);
Sami Tolvanen90221202014-12-09 16:39:47 +0000938 }
939
940 return 0;
941}
942
Sami Tolvanen90221202014-12-09 16:39:47 +0000943// Do a source/target load for move/bsdiff/imgdiff in version 3.
944//
945// Parameters are the same as for LoadSrcTgtVersion2, except for 'onehash', which
946// tells the function whether to expect separate source and targe block hashes, or
947// if they are both the same and only one hash should be expected, and
948// 'isunresumable', which receives a non-zero value if block verification fails in
949// a way that the update cannot be resumed anymore.
950//
951// If the function is unable to load the necessary blocks or their contents don't
952// match the hashes, the return value is -1 and the command should be aborted.
953//
954// If the return value is 1, the command has already been completed according to
955// the contents of the target blocks, and should not be performed again.
956//
957// If the return value is 0, source blocks have expected content and the command
958// can be performed.
959
Tao Bao34847b22015-09-08 11:05:49 -0700960static int LoadSrcTgtVersion3(CommandParameters& params, RangeSet& tgt, size_t& src_blocks,
Tao Bao0940fe12015-08-27 16:41:21 -0700961 bool onehash, bool& overlap) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000962
Tao Baobaad2d42015-12-06 16:56:27 -0800963 if (params.cpos >= params.tokens.size()) {
Tao Bao039f2da2016-11-22 16:29:50 -0800964 LOG(ERROR) << "missing source hash";
Tao Bao0940fe12015-08-27 16:41:21 -0700965 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000966 }
967
Tao Baobaad2d42015-12-06 16:56:27 -0800968 std::string srchash = params.tokens[params.cpos++];
969 std::string tgthash;
970
Sami Tolvanen90221202014-12-09 16:39:47 +0000971 if (onehash) {
972 tgthash = srchash;
973 } else {
Tao Baobaad2d42015-12-06 16:56:27 -0800974 if (params.cpos >= params.tokens.size()) {
Tao Bao039f2da2016-11-22 16:29:50 -0800975 LOG(ERROR) << "missing target hash";
Tao Bao0940fe12015-08-27 16:41:21 -0700976 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000977 }
Tao Baobaad2d42015-12-06 16:56:27 -0800978 tgthash = params.tokens[params.cpos++];
Sami Tolvanen90221202014-12-09 16:39:47 +0000979 }
980
Elliott Hughesbcabd092016-03-22 20:19:22 -0700981 if (LoadSrcTgtVersion2(params, tgt, src_blocks, params.buffer, params.fd,
982 params.stashbase, &overlap) == -1) {
Tao Bao0940fe12015-08-27 16:41:21 -0700983 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000984 }
985
Tao Bao34847b22015-09-08 11:05:49 -0700986 std::vector<uint8_t> tgtbuffer(tgt.size * BLOCKSIZE);
Sami Tolvanen90221202014-12-09 16:39:47 +0000987
Tao Bao612336d2015-08-27 16:41:21 -0700988 if (ReadBlocks(tgt, tgtbuffer, params.fd) == -1) {
Tao Bao0940fe12015-08-27 16:41:21 -0700989 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000990 }
991
Tao Bao612336d2015-08-27 16:41:21 -0700992 if (VerifyBlocks(tgthash, tgtbuffer, tgt.size, false) == 0) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000993 // Target blocks already have expected content, command should be skipped
Tao Bao0940fe12015-08-27 16:41:21 -0700994 return 1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000995 }
996
Tao Bao0940fe12015-08-27 16:41:21 -0700997 if (VerifyBlocks(srchash, params.buffer, src_blocks, true) == 0) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000998 // If source and target blocks overlap, stash the source blocks so we can
Tianjie Xu7eca97e2016-03-22 18:08:12 -0700999 // resume from possible write errors. In verify mode, we can skip stashing
1000 // because the source blocks won't be overwritten.
1001 if (overlap && params.canwrite) {
Tao Bao039f2da2016-11-22 16:29:50 -08001002 LOG(INFO) << "stashing " << src_blocks << " overlapping blocks to " << srchash;
Sami Tolvanen90221202014-12-09 16:39:47 +00001003
Tao Bao0940fe12015-08-27 16:41:21 -07001004 bool stash_exists = false;
Tao Bao612336d2015-08-27 16:41:21 -07001005 if (WriteStash(params.stashbase, srchash, src_blocks, params.buffer, true,
Tao Bao0940fe12015-08-27 16:41:21 -07001006 &stash_exists) != 0) {
Tao Bao039f2da2016-11-22 16:29:50 -08001007 LOG(ERROR) << "failed to stash overlapping source blocks";
Tao Bao0940fe12015-08-27 16:41:21 -07001008 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001009 }
1010
Tianjie Xudd874b12016-05-13 12:13:15 -07001011 params.stashed += src_blocks;
Sami Tolvanen90221202014-12-09 16:39:47 +00001012 // Can be deleted when the write has completed
Sami Tolvanen43b748f2015-04-17 12:50:31 +01001013 if (!stash_exists) {
Tao Bao0940fe12015-08-27 16:41:21 -07001014 params.freestash = srchash;
Sami Tolvanen43b748f2015-04-17 12:50:31 +01001015 }
Sami Tolvanen90221202014-12-09 16:39:47 +00001016 }
1017
1018 // Source blocks have expected content, command can proceed
Tao Bao0940fe12015-08-27 16:41:21 -07001019 return 0;
Sami Tolvanen90221202014-12-09 16:39:47 +00001020 }
1021
Tianjie Xu7eca97e2016-03-22 18:08:12 -07001022 if (overlap && LoadStash(params, params.stashbase, srchash, true, nullptr, params.buffer,
1023 true) == 0) {
Sami Tolvanen43b748f2015-04-17 12:50:31 +01001024 // Overlapping source blocks were previously stashed, command can proceed.
1025 // We are recovering from an interrupted command, so we don't know if the
1026 // stash can safely be deleted after this command.
Tao Bao0940fe12015-08-27 16:41:21 -07001027 return 0;
Sami Tolvanen90221202014-12-09 16:39:47 +00001028 }
1029
1030 // Valid source data not available, update cannot be resumed
Tao Bao039f2da2016-11-22 16:29:50 -08001031 LOG(ERROR) << "partition has unexpected contents";
Tao Bao0940fe12015-08-27 16:41:21 -07001032 params.isunresumable = true;
Sami Tolvanen90221202014-12-09 16:39:47 +00001033
Tao Bao0940fe12015-08-27 16:41:21 -07001034 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001035}
1036
Tao Bao0940fe12015-08-27 16:41:21 -07001037static int PerformCommandMove(CommandParameters& params) {
1038 size_t blocks = 0;
Tao Baoe6aa3322015-08-05 15:20:27 -07001039 bool overlap = false;
Sami Tolvanen90221202014-12-09 16:39:47 +00001040 int status = 0;
Tao Bao0940fe12015-08-27 16:41:21 -07001041 RangeSet tgt;
Sami Tolvanen90221202014-12-09 16:39:47 +00001042
Tao Bao0940fe12015-08-27 16:41:21 -07001043 if (params.version == 1) {
Tao Baobaad2d42015-12-06 16:56:27 -08001044 status = LoadSrcTgtVersion1(params, tgt, blocks, params.buffer, params.fd);
Tao Bao0940fe12015-08-27 16:41:21 -07001045 } else if (params.version == 2) {
Tao Baobaad2d42015-12-06 16:56:27 -08001046 status = LoadSrcTgtVersion2(params, tgt, blocks, params.buffer, params.fd,
Tao Bao612336d2015-08-27 16:41:21 -07001047 params.stashbase, nullptr);
Tao Bao0940fe12015-08-27 16:41:21 -07001048 } else if (params.version >= 3) {
Tao Bao34847b22015-09-08 11:05:49 -07001049 status = LoadSrcTgtVersion3(params, tgt, blocks, true, overlap);
Sami Tolvanen90221202014-12-09 16:39:47 +00001050 }
1051
1052 if (status == -1) {
Tao Bao039f2da2016-11-22 16:29:50 -08001053 LOG(ERROR) << "failed to read blocks for move";
Tao Bao0940fe12015-08-27 16:41:21 -07001054 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001055 }
1056
1057 if (status == 0) {
Tao Bao0940fe12015-08-27 16:41:21 -07001058 params.foundwrites = true;
1059 } else if (params.foundwrites) {
Tao Bao039f2da2016-11-22 16:29:50 -08001060 LOG(WARNING) << "warning: commands executed out of order [" << params.cmdname << "]";
Sami Tolvanen90221202014-12-09 16:39:47 +00001061 }
1062
Tao Bao0940fe12015-08-27 16:41:21 -07001063 if (params.canwrite) {
Sami Tolvanen90221202014-12-09 16:39:47 +00001064 if (status == 0) {
Tao Bao039f2da2016-11-22 16:29:50 -08001065 LOG(INFO) << " moving " << blocks << " blocks";
Sami Tolvanen90221202014-12-09 16:39:47 +00001066
Tao Bao0940fe12015-08-27 16:41:21 -07001067 if (WriteBlocks(tgt, params.buffer, params.fd) == -1) {
1068 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001069 }
1070 } else {
Tao Bao039f2da2016-11-22 16:29:50 -08001071 LOG(INFO) << "skipping " << blocks << " already moved blocks";
Sami Tolvanen90221202014-12-09 16:39:47 +00001072 }
1073
1074 }
1075
Tao Baobaad2d42015-12-06 16:56:27 -08001076 if (!params.freestash.empty()) {
Tao Bao0940fe12015-08-27 16:41:21 -07001077 FreeStash(params.stashbase, params.freestash);
Tao Baobaad2d42015-12-06 16:56:27 -08001078 params.freestash.clear();
Sami Tolvanen90221202014-12-09 16:39:47 +00001079 }
1080
Tao Bao0940fe12015-08-27 16:41:21 -07001081 params.written += tgt.size;
Sami Tolvanen90221202014-12-09 16:39:47 +00001082
Tao Bao0940fe12015-08-27 16:41:21 -07001083 return 0;
Sami Tolvanen90221202014-12-09 16:39:47 +00001084}
1085
Tao Bao0940fe12015-08-27 16:41:21 -07001086static int PerformCommandStash(CommandParameters& params) {
Tao Baobaad2d42015-12-06 16:56:27 -08001087 return SaveStash(params, params.stashbase, params.buffer, params.fd,
Tao Bao612336d2015-08-27 16:41:21 -07001088 (params.version >= 3));
Sami Tolvanen90221202014-12-09 16:39:47 +00001089}
1090
Tao Bao0940fe12015-08-27 16:41:21 -07001091static int PerformCommandFree(CommandParameters& params) {
Tao Baobaad2d42015-12-06 16:56:27 -08001092 // <stash_id>
1093 if (params.cpos >= params.tokens.size()) {
Tao Bao039f2da2016-11-22 16:29:50 -08001094 LOG(ERROR) << "missing stash id in free command";
Tao Baobaad2d42015-12-06 16:56:27 -08001095 return -1;
1096 }
1097
Tianjie Xu7eca97e2016-03-22 18:08:12 -07001098 const std::string& id = params.tokens[params.cpos++];
1099
1100 if (!params.canwrite && stash_map.find(id) != stash_map.end()) {
1101 stash_map.erase(id);
1102 return 0;
1103 }
1104
Tao Bao0940fe12015-08-27 16:41:21 -07001105 if (params.createdstash || params.canwrite) {
Tianjie Xu7eca97e2016-03-22 18:08:12 -07001106 return FreeStash(params.stashbase, id);
Sami Tolvanen90221202014-12-09 16:39:47 +00001107 }
1108
1109 return 0;
1110}
1111
Tao Bao0940fe12015-08-27 16:41:21 -07001112static int PerformCommandZero(CommandParameters& params) {
Sami Tolvanen90221202014-12-09 16:39:47 +00001113
Tao Baobaad2d42015-12-06 16:56:27 -08001114 if (params.cpos >= params.tokens.size()) {
Tao Bao039f2da2016-11-22 16:29:50 -08001115 LOG(ERROR) << "missing target blocks for zero";
Tao Bao0940fe12015-08-27 16:41:21 -07001116 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001117 }
1118
Tao Bao0940fe12015-08-27 16:41:21 -07001119 RangeSet tgt;
Tao Baobaad2d42015-12-06 16:56:27 -08001120 parse_range(params.tokens[params.cpos++], tgt);
Sami Tolvanen90221202014-12-09 16:39:47 +00001121
Tao Bao039f2da2016-11-22 16:29:50 -08001122 LOG(INFO) << " zeroing " << tgt.size << " blocks";
Sami Tolvanen90221202014-12-09 16:39:47 +00001123
Tao Bao612336d2015-08-27 16:41:21 -07001124 allocate(BLOCKSIZE, params.buffer);
1125 memset(params.buffer.data(), 0, BLOCKSIZE);
Sami Tolvanen90221202014-12-09 16:39:47 +00001126
Tao Bao0940fe12015-08-27 16:41:21 -07001127 if (params.canwrite) {
1128 for (size_t i = 0; i < tgt.count; ++i) {
Tianjie Xu7ce287d2016-05-31 09:29:49 -07001129 off64_t offset = static_cast<off64_t>(tgt.pos[i * 2]) * BLOCKSIZE;
1130 size_t size = (tgt.pos[i * 2 + 1] - tgt.pos[i * 2]) * BLOCKSIZE;
1131 if (!discard_blocks(params.fd, offset, size)) {
1132 return -1;
1133 }
1134
1135 if (!check_lseek(params.fd, offset, SEEK_SET)) {
Tao Bao0940fe12015-08-27 16:41:21 -07001136 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001137 }
1138
Tao Bao0940fe12015-08-27 16:41:21 -07001139 for (size_t j = tgt.pos[i * 2]; j < tgt.pos[i * 2 + 1]; ++j) {
1140 if (write_all(params.fd, params.buffer, BLOCKSIZE) == -1) {
1141 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001142 }
1143 }
1144 }
1145 }
1146
Tao Bao0940fe12015-08-27 16:41:21 -07001147 if (params.cmdname[0] == 'z') {
Sami Tolvanene82fa182015-06-10 15:58:12 +00001148 // Update only for the zero command, as the erase command will call
1149 // this if DEBUG_ERASE is defined.
Tao Bao0940fe12015-08-27 16:41:21 -07001150 params.written += tgt.size;
Sami Tolvanen90221202014-12-09 16:39:47 +00001151 }
1152
Tao Bao0940fe12015-08-27 16:41:21 -07001153 return 0;
Sami Tolvanen90221202014-12-09 16:39:47 +00001154}
1155
Tao Bao0940fe12015-08-27 16:41:21 -07001156static int PerformCommandNew(CommandParameters& params) {
Sami Tolvanen90221202014-12-09 16:39:47 +00001157
Tao Baobaad2d42015-12-06 16:56:27 -08001158 if (params.cpos >= params.tokens.size()) {
Tao Bao039f2da2016-11-22 16:29:50 -08001159 LOG(ERROR) << "missing target blocks for new";
Tao Bao0940fe12015-08-27 16:41:21 -07001160 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001161 }
1162
Tao Bao0940fe12015-08-27 16:41:21 -07001163 RangeSet tgt;
Tao Baobaad2d42015-12-06 16:56:27 -08001164 parse_range(params.tokens[params.cpos++], tgt);
Sami Tolvanen90221202014-12-09 16:39:47 +00001165
Tao Bao0940fe12015-08-27 16:41:21 -07001166 if (params.canwrite) {
Tao Bao039f2da2016-11-22 16:29:50 -08001167 LOG(INFO) << " writing " << tgt.size << " blocks of new data";
Sami Tolvanen90221202014-12-09 16:39:47 +00001168
Tao Bao0940fe12015-08-27 16:41:21 -07001169 RangeSinkState rss(tgt);
1170 rss.fd = params.fd;
Sami Tolvanen90221202014-12-09 16:39:47 +00001171 rss.p_block = 0;
Tao Bao0940fe12015-08-27 16:41:21 -07001172 rss.p_remain = (tgt.pos[1] - tgt.pos[0]) * BLOCKSIZE;
Sami Tolvanen90221202014-12-09 16:39:47 +00001173
Tianjie Xu7ce287d2016-05-31 09:29:49 -07001174 off64_t offset = static_cast<off64_t>(tgt.pos[0]) * BLOCKSIZE;
1175 if (!discard_blocks(params.fd, offset, tgt.size * BLOCKSIZE)) {
1176 return -1;
1177 }
1178
1179 if (!check_lseek(params.fd, offset, SEEK_SET)) {
Tao Bao0940fe12015-08-27 16:41:21 -07001180 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001181 }
1182
Tao Bao0940fe12015-08-27 16:41:21 -07001183 pthread_mutex_lock(&params.nti.mu);
1184 params.nti.rss = &rss;
1185 pthread_cond_broadcast(&params.nti.cv);
Sami Tolvanen90221202014-12-09 16:39:47 +00001186
Tao Bao0940fe12015-08-27 16:41:21 -07001187 while (params.nti.rss) {
1188 pthread_cond_wait(&params.nti.cv, &params.nti.mu);
Sami Tolvanen90221202014-12-09 16:39:47 +00001189 }
1190
Tao Bao0940fe12015-08-27 16:41:21 -07001191 pthread_mutex_unlock(&params.nti.mu);
Sami Tolvanen90221202014-12-09 16:39:47 +00001192 }
1193
Tao Bao0940fe12015-08-27 16:41:21 -07001194 params.written += tgt.size;
Sami Tolvanen90221202014-12-09 16:39:47 +00001195
Tao Bao0940fe12015-08-27 16:41:21 -07001196 return 0;
Sami Tolvanen90221202014-12-09 16:39:47 +00001197}
1198
Tao Bao0940fe12015-08-27 16:41:21 -07001199static int PerformCommandDiff(CommandParameters& params) {
Tao Bao0940fe12015-08-27 16:41:21 -07001200
Tao Baobaad2d42015-12-06 16:56:27 -08001201 // <offset> <length>
1202 if (params.cpos + 1 >= params.tokens.size()) {
Tao Bao039f2da2016-11-22 16:29:50 -08001203 LOG(ERROR) << "missing patch offset or length for " << params.cmdname;
Tao Bao0940fe12015-08-27 16:41:21 -07001204 return -1;
1205 }
1206
Tao Baobaad2d42015-12-06 16:56:27 -08001207 size_t offset;
1208 if (!android::base::ParseUint(params.tokens[params.cpos++].c_str(), &offset)) {
Tao Bao039f2da2016-11-22 16:29:50 -08001209 LOG(ERROR) << "invalid patch offset";
Tao Bao0940fe12015-08-27 16:41:21 -07001210 return -1;
1211 }
1212
Tao Baobaad2d42015-12-06 16:56:27 -08001213 size_t len;
1214 if (!android::base::ParseUint(params.tokens[params.cpos++].c_str(), &len)) {
Tao Bao039f2da2016-11-22 16:29:50 -08001215 LOG(ERROR) << "invalid patch len";
Tao Baobaad2d42015-12-06 16:56:27 -08001216 return -1;
1217 }
Tao Bao0940fe12015-08-27 16:41:21 -07001218
Tao Bao612336d2015-08-27 16:41:21 -07001219 RangeSet tgt;
Tao Bao0940fe12015-08-27 16:41:21 -07001220 size_t blocks = 0;
Tao Bao612336d2015-08-27 16:41:21 -07001221 bool overlap = false;
Sami Tolvanen90221202014-12-09 16:39:47 +00001222 int status = 0;
Tao Bao0940fe12015-08-27 16:41:21 -07001223 if (params.version == 1) {
Tao Baobaad2d42015-12-06 16:56:27 -08001224 status = LoadSrcTgtVersion1(params, tgt, blocks, params.buffer, params.fd);
Tao Bao0940fe12015-08-27 16:41:21 -07001225 } else if (params.version == 2) {
Tao Baobaad2d42015-12-06 16:56:27 -08001226 status = LoadSrcTgtVersion2(params, tgt, blocks, params.buffer, params.fd,
Tao Bao612336d2015-08-27 16:41:21 -07001227 params.stashbase, nullptr);
Tao Bao0940fe12015-08-27 16:41:21 -07001228 } else if (params.version >= 3) {
Tao Bao34847b22015-09-08 11:05:49 -07001229 status = LoadSrcTgtVersion3(params, tgt, blocks, false, overlap);
Sami Tolvanen90221202014-12-09 16:39:47 +00001230 }
1231
1232 if (status == -1) {
Tao Bao039f2da2016-11-22 16:29:50 -08001233 LOG(ERROR) << "failed to read blocks for diff";
Tao Bao0940fe12015-08-27 16:41:21 -07001234 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001235 }
1236
1237 if (status == 0) {
Tao Bao0940fe12015-08-27 16:41:21 -07001238 params.foundwrites = true;
1239 } else if (params.foundwrites) {
Tao Bao039f2da2016-11-22 16:29:50 -08001240 LOG(WARNING) << "warning: commands executed out of order [" << params.cmdname << "]";
Sami Tolvanen90221202014-12-09 16:39:47 +00001241 }
1242
Tao Bao0940fe12015-08-27 16:41:21 -07001243 if (params.canwrite) {
Sami Tolvanen90221202014-12-09 16:39:47 +00001244 if (status == 0) {
Tao Bao039f2da2016-11-22 16:29:50 -08001245 LOG(INFO) << "patching " << blocks << " blocks to " << tgt.size;
Sami Tolvanen90221202014-12-09 16:39:47 +00001246
Tianjie Xuaced5d92016-10-12 10:55:04 -07001247 Value patch_value(VAL_BLOB,
1248 std::string(reinterpret_cast<const char*>(params.patch_start + offset), len));
Sami Tolvanen90221202014-12-09 16:39:47 +00001249
Tao Bao0940fe12015-08-27 16:41:21 -07001250 RangeSinkState rss(tgt);
1251 rss.fd = params.fd;
Sami Tolvanen90221202014-12-09 16:39:47 +00001252 rss.p_block = 0;
Tao Bao0940fe12015-08-27 16:41:21 -07001253 rss.p_remain = (tgt.pos[1] - tgt.pos[0]) * BLOCKSIZE;
Sami Tolvanen90221202014-12-09 16:39:47 +00001254
Tianjie Xu7ce287d2016-05-31 09:29:49 -07001255 off64_t offset = static_cast<off64_t>(tgt.pos[0]) * BLOCKSIZE;
1256 if (!discard_blocks(params.fd, offset, rss.p_remain)) {
1257 return -1;
1258 }
1259
1260 if (!check_lseek(params.fd, offset, SEEK_SET)) {
Tao Bao0940fe12015-08-27 16:41:21 -07001261 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001262 }
1263
Tao Bao0940fe12015-08-27 16:41:21 -07001264 if (params.cmdname[0] == 'i') { // imgdiff
Tianjie Xu31f8cc82016-06-15 11:56:42 -07001265 if (ApplyImagePatch(params.buffer.data(), blocks * BLOCKSIZE, &patch_value,
1266 &RangeSinkWrite, &rss, nullptr, nullptr) != 0) {
Tao Bao039f2da2016-11-22 16:29:50 -08001267 LOG(ERROR) << "Failed to apply image patch.";
Tianjie Xu31f8cc82016-06-15 11:56:42 -07001268 return -1;
1269 }
Sami Tolvanen90221202014-12-09 16:39:47 +00001270 } else {
Tianjie Xu31f8cc82016-06-15 11:56:42 -07001271 if (ApplyBSDiffPatch(params.buffer.data(), blocks * BLOCKSIZE, &patch_value,
1272 0, &RangeSinkWrite, &rss, nullptr) != 0) {
Tao Bao039f2da2016-11-22 16:29:50 -08001273 LOG(ERROR) << "Failed to apply bsdiff patch.";
Tianjie Xu31f8cc82016-06-15 11:56:42 -07001274 return -1;
1275 }
Sami Tolvanen90221202014-12-09 16:39:47 +00001276 }
1277
1278 // We expect the output of the patcher to fill the tgt ranges exactly.
Tao Bao0940fe12015-08-27 16:41:21 -07001279 if (rss.p_block != tgt.count || rss.p_remain != 0) {
Tao Bao039f2da2016-11-22 16:29:50 -08001280 LOG(ERROR) << "range sink underrun?";
Sami Tolvanen90221202014-12-09 16:39:47 +00001281 }
1282 } else {
Tao Bao039f2da2016-11-22 16:29:50 -08001283 LOG(INFO) << "skipping " << blocks << " blocks already patched to " << tgt.size
1284 << " [" << params.cmdline << "]";
Sami Tolvanen90221202014-12-09 16:39:47 +00001285 }
1286 }
1287
Tao Baobaad2d42015-12-06 16:56:27 -08001288 if (!params.freestash.empty()) {
Tao Bao0940fe12015-08-27 16:41:21 -07001289 FreeStash(params.stashbase, params.freestash);
Tao Baobaad2d42015-12-06 16:56:27 -08001290 params.freestash.clear();
Sami Tolvanen90221202014-12-09 16:39:47 +00001291 }
1292
Tao Bao0940fe12015-08-27 16:41:21 -07001293 params.written += tgt.size;
Sami Tolvanen90221202014-12-09 16:39:47 +00001294
Tao Bao0940fe12015-08-27 16:41:21 -07001295 return 0;
Sami Tolvanen90221202014-12-09 16:39:47 +00001296}
1297
Tao Bao0940fe12015-08-27 16:41:21 -07001298static int PerformCommandErase(CommandParameters& params) {
Sami Tolvanene82fa182015-06-10 15:58:12 +00001299 if (DEBUG_ERASE) {
1300 return PerformCommandZero(params);
Sami Tolvanen90221202014-12-09 16:39:47 +00001301 }
1302
Tao Bao0940fe12015-08-27 16:41:21 -07001303 struct stat sb;
1304 if (fstat(params.fd, &sb) == -1) {
Tao Bao039f2da2016-11-22 16:29:50 -08001305 PLOG(ERROR) << "failed to fstat device to erase";
Tao Bao0940fe12015-08-27 16:41:21 -07001306 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001307 }
1308
Tao Bao0940fe12015-08-27 16:41:21 -07001309 if (!S_ISBLK(sb.st_mode)) {
Tao Bao039f2da2016-11-22 16:29:50 -08001310 LOG(ERROR) << "not a block device; skipping erase";
Tao Bao0940fe12015-08-27 16:41:21 -07001311 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001312 }
1313
Tao Baobaad2d42015-12-06 16:56:27 -08001314 if (params.cpos >= params.tokens.size()) {
Tao Bao039f2da2016-11-22 16:29:50 -08001315 LOG(ERROR) << "missing target blocks for erase";
Tao Bao0940fe12015-08-27 16:41:21 -07001316 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001317 }
1318
Tao Bao0940fe12015-08-27 16:41:21 -07001319 RangeSet tgt;
Tao Baobaad2d42015-12-06 16:56:27 -08001320 parse_range(params.tokens[params.cpos++], tgt);
Sami Tolvanen90221202014-12-09 16:39:47 +00001321
Tao Bao0940fe12015-08-27 16:41:21 -07001322 if (params.canwrite) {
Tao Bao039f2da2016-11-22 16:29:50 -08001323 LOG(INFO) << " erasing " << tgt.size << " blocks";
Sami Tolvanen90221202014-12-09 16:39:47 +00001324
Tao Bao0940fe12015-08-27 16:41:21 -07001325 for (size_t i = 0; i < tgt.count; ++i) {
1326 uint64_t blocks[2];
Sami Tolvanen90221202014-12-09 16:39:47 +00001327 // offset in bytes
Tao Bao0940fe12015-08-27 16:41:21 -07001328 blocks[0] = tgt.pos[i * 2] * (uint64_t) BLOCKSIZE;
Sami Tolvanen90221202014-12-09 16:39:47 +00001329 // length in bytes
Tao Bao0940fe12015-08-27 16:41:21 -07001330 blocks[1] = (tgt.pos[i * 2 + 1] - tgt.pos[i * 2]) * (uint64_t) BLOCKSIZE;
Sami Tolvanen90221202014-12-09 16:39:47 +00001331
Tao Bao0940fe12015-08-27 16:41:21 -07001332 if (ioctl(params.fd, BLKDISCARD, &blocks) == -1) {
Tao Bao039f2da2016-11-22 16:29:50 -08001333 PLOG(ERROR) << "BLKDISCARD ioctl failed";
Tao Bao0940fe12015-08-27 16:41:21 -07001334 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001335 }
1336 }
1337 }
1338
Tao Bao0940fe12015-08-27 16:41:21 -07001339 return 0;
Sami Tolvanen90221202014-12-09 16:39:47 +00001340}
1341
1342// Definitions for transfer list command functions
Tao Bao0940fe12015-08-27 16:41:21 -07001343typedef int (*CommandFunction)(CommandParameters&);
Sami Tolvanen90221202014-12-09 16:39:47 +00001344
Tao Bao612336d2015-08-27 16:41:21 -07001345struct Command {
Sami Tolvanen90221202014-12-09 16:39:47 +00001346 const char* name;
1347 CommandFunction f;
Tao Bao612336d2015-08-27 16:41:21 -07001348};
Sami Tolvanen90221202014-12-09 16:39:47 +00001349
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001350// args:
1351// - block device (or file) to modify in-place
1352// - transfer list (blob)
1353// - new data stream (filename within package.zip)
1354// - patch stream (filename within package.zip, must be uncompressed)
1355
Tao Bao0940fe12015-08-27 16:41:21 -07001356static Value* PerformBlockImageUpdate(const char* name, State* state, int /* argc */, Expr* argv[],
1357 const Command* commands, size_t cmdcount, bool dryrun) {
Tao Bao73064612016-04-26 17:14:32 -07001358 CommandParameters params = {};
Sami Tolvanen90221202014-12-09 16:39:47 +00001359 params.canwrite = !dryrun;
1360
Tao Bao5354f602016-12-14 11:31:18 -08001361 LOG(INFO) << "performing " << (dryrun ? "verification" : "update");
Tianjie Xu7ce287d2016-05-31 09:29:49 -07001362 if (state->is_retry) {
1363 is_retry = true;
Tao Bao039f2da2016-11-22 16:29:50 -08001364 LOG(INFO) << "This update is a retry.";
Tianjie Xu7ce287d2016-05-31 09:29:49 -07001365 }
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001366
Tianjie Xu5fe280a2016-10-17 18:15:20 -07001367 std::vector<std::unique_ptr<Value>> args;
1368 if (!ReadValueArgs(state, 4, argv, &args)) {
1369 return nullptr;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001370 }
Tianjie Xu5fe280a2016-10-17 18:15:20 -07001371
1372 const Value* blockdev_filename = args[0].get();
1373 const Value* transfer_list_value = args[1].get();
1374 const Value* new_data_fn = args[2].get();
1375 const Value* patch_data_fn = args[3].get();
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001376
1377 if (blockdev_filename->type != VAL_STRING) {
Tianjie Xu16255832016-04-30 11:49:59 -07001378 ErrorAbort(state, kArgsParsingFailure, "blockdev_filename argument to %s must be string",
1379 name);
Tianjie Xuaced5d92016-10-12 10:55:04 -07001380 return StringValue("");
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001381 }
Doug Zongker1d5d6092014-08-21 10:47:24 -07001382 if (transfer_list_value->type != VAL_BLOB) {
Tianjie Xu16255832016-04-30 11:49:59 -07001383 ErrorAbort(state, kArgsParsingFailure, "transfer_list argument to %s must be blob", name);
Tianjie Xuaced5d92016-10-12 10:55:04 -07001384 return StringValue("");
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001385 }
1386 if (new_data_fn->type != VAL_STRING) {
Tianjie Xu16255832016-04-30 11:49:59 -07001387 ErrorAbort(state, kArgsParsingFailure, "new_data_fn argument to %s must be string", name);
Tianjie Xuaced5d92016-10-12 10:55:04 -07001388 return StringValue("");
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001389 }
1390 if (patch_data_fn->type != VAL_STRING) {
Tianjie Xu16255832016-04-30 11:49:59 -07001391 ErrorAbort(state, kArgsParsingFailure, "patch_data_fn argument to %s must be string",
1392 name);
Tianjie Xuaced5d92016-10-12 10:55:04 -07001393 return StringValue("");
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001394 }
1395
Tao Bao612336d2015-08-27 16:41:21 -07001396 UpdaterInfo* ui = reinterpret_cast<UpdaterInfo*>(state->cookie);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001397
Tao Bao0940fe12015-08-27 16:41:21 -07001398 if (ui == nullptr) {
Tianjie Xuaced5d92016-10-12 10:55:04 -07001399 return StringValue("");
Sami Tolvanen90221202014-12-09 16:39:47 +00001400 }
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001401
Tao Bao612336d2015-08-27 16:41:21 -07001402 FILE* cmd_pipe = ui->cmd_pipe;
Tianjie Xu8cf5c8f2016-09-08 20:10:11 -07001403 ZipArchiveHandle za = ui->package_zip;
Sami Tolvanen90221202014-12-09 16:39:47 +00001404
Tao Bao0940fe12015-08-27 16:41:21 -07001405 if (cmd_pipe == nullptr || za == nullptr) {
Tianjie Xuaced5d92016-10-12 10:55:04 -07001406 return StringValue("");
Sami Tolvanen90221202014-12-09 16:39:47 +00001407 }
1408
Tianjie Xu8cf5c8f2016-09-08 20:10:11 -07001409 ZipString path_data(patch_data_fn->data.c_str());
1410 ZipEntry patch_entry;
1411 if (FindEntry(za, path_data, &patch_entry) != 0) {
Tao Bao039f2da2016-11-22 16:29:50 -08001412 LOG(ERROR) << name << "(): no file \"" << patch_data_fn->data << "\" in package";
Tianjie Xuaced5d92016-10-12 10:55:04 -07001413 return StringValue("");
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001414 }
1415
Tianjie Xu8cf5c8f2016-09-08 20:10:11 -07001416 params.patch_start = ui->package_zip_addr + patch_entry.offset;
1417 ZipString new_data(new_data_fn->data.c_str());
1418 ZipEntry new_entry;
1419 if (FindEntry(za, new_data, &new_entry) != 0) {
Tao Bao039f2da2016-11-22 16:29:50 -08001420 LOG(ERROR) << name << "(): no file \"" << new_data_fn->data << "\" in package";
Tianjie Xuaced5d92016-10-12 10:55:04 -07001421 return StringValue("");
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001422 }
1423
Tianjie Xuaced5d92016-10-12 10:55:04 -07001424 params.fd.reset(TEMP_FAILURE_RETRY(ota_open(blockdev_filename->data.c_str(), O_RDWR)));
Sami Tolvanen90221202014-12-09 16:39:47 +00001425 if (params.fd == -1) {
Tao Bao039f2da2016-11-22 16:29:50 -08001426 PLOG(ERROR) << "open \"" << blockdev_filename->data << "\" failed";
Tianjie Xuaced5d92016-10-12 10:55:04 -07001427 return StringValue("");
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001428 }
1429
Sami Tolvanen90221202014-12-09 16:39:47 +00001430 if (params.canwrite) {
1431 params.nti.za = za;
1432 params.nti.entry = new_entry;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001433
Tao Bao0940fe12015-08-27 16:41:21 -07001434 pthread_mutex_init(&params.nti.mu, nullptr);
1435 pthread_cond_init(&params.nti.cv, nullptr);
Tao Bao612336d2015-08-27 16:41:21 -07001436 pthread_attr_t attr;
Sami Tolvanen90221202014-12-09 16:39:47 +00001437 pthread_attr_init(&attr);
1438 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
1439
Elliott Hughes1fdd4522015-03-23 13:33:57 -07001440 int error = pthread_create(&params.thread, &attr, unzip_new_data, &params.nti);
1441 if (error != 0) {
Tao Bao039f2da2016-11-22 16:29:50 -08001442 PLOG(ERROR) << "pthread_create failed";
Tianjie Xuaced5d92016-10-12 10:55:04 -07001443 return StringValue("");
Sami Tolvanen90221202014-12-09 16:39:47 +00001444 }
1445 }
1446
Tianjie Xuaced5d92016-10-12 10:55:04 -07001447 std::vector<std::string> lines = android::base::Split(transfer_list_value->data, "\n");
Tao Baobaad2d42015-12-06 16:56:27 -08001448 if (lines.size() < 2) {
Tianjie Xu16255832016-04-30 11:49:59 -07001449 ErrorAbort(state, kArgsParsingFailure, "too few lines in the transfer list [%zd]\n",
1450 lines.size());
Tianjie Xuaced5d92016-10-12 10:55:04 -07001451 return StringValue("");
Tao Baobaad2d42015-12-06 16:56:27 -08001452 }
Doug Zongker1d5d6092014-08-21 10:47:24 -07001453
Sami Tolvanen90221202014-12-09 16:39:47 +00001454 // First line in transfer list is the version number
Tao Bao1fdec862015-10-21 14:57:44 -07001455 if (!android::base::ParseInt(lines[0].c_str(), &params.version, 1, 4)) {
Tao Bao039f2da2016-11-22 16:29:50 -08001456 LOG(ERROR) << "unexpected transfer list version [" << lines[0] << "]";
Tianjie Xuaced5d92016-10-12 10:55:04 -07001457 return StringValue("");
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001458 }
1459
Tao Bao039f2da2016-11-22 16:29:50 -08001460 LOG(INFO) << "blockimg version is " << params.version;
Sami Tolvanen90221202014-12-09 16:39:47 +00001461
1462 // Second line in transfer list is the total number of blocks we expect to write
Tao Baob15fd222015-09-24 11:10:51 -07001463 int total_blocks;
1464 if (!android::base::ParseInt(lines[1].c_str(), &total_blocks, 0)) {
Tianjie Xu16255832016-04-30 11:49:59 -07001465 ErrorAbort(state, kArgsParsingFailure, "unexpected block count [%s]\n", lines[1].c_str());
Tianjie Xuaced5d92016-10-12 10:55:04 -07001466 return StringValue("");
Tao Baob15fd222015-09-24 11:10:51 -07001467 }
1468
1469 if (total_blocks == 0) {
Tianjie Xuaced5d92016-10-12 10:55:04 -07001470 return StringValue("t");
Sami Tolvanen90221202014-12-09 16:39:47 +00001471 }
1472
Tao Bao612336d2015-08-27 16:41:21 -07001473 size_t start = 2;
Sami Tolvanen90221202014-12-09 16:39:47 +00001474 if (params.version >= 2) {
Tao Baobaad2d42015-12-06 16:56:27 -08001475 if (lines.size() < 4) {
Tianjie Xu16255832016-04-30 11:49:59 -07001476 ErrorAbort(state, kArgsParsingFailure, "too few lines in the transfer list [%zu]\n",
1477 lines.size());
Tianjie Xuaced5d92016-10-12 10:55:04 -07001478 return StringValue("");
Tao Baobaad2d42015-12-06 16:56:27 -08001479 }
1480
Sami Tolvanen90221202014-12-09 16:39:47 +00001481 // Third line is how many stash entries are needed simultaneously
Tao Bao039f2da2016-11-22 16:29:50 -08001482 LOG(INFO) << "maximum stash entries " << lines[2];
Doug Zongker52ae67d2014-09-08 12:22:09 -07001483
Sami Tolvanen90221202014-12-09 16:39:47 +00001484 // Fourth line is the maximum number of blocks that will be stashed simultaneously
Tao Baob15fd222015-09-24 11:10:51 -07001485 int stash_max_blocks;
1486 if (!android::base::ParseInt(lines[3].c_str(), &stash_max_blocks, 0)) {
Tianjie Xu16255832016-04-30 11:49:59 -07001487 ErrorAbort(state, kArgsParsingFailure, "unexpected maximum stash blocks [%s]\n",
1488 lines[3].c_str());
Tianjie Xuaced5d92016-10-12 10:55:04 -07001489 return StringValue("");
Doug Zongker52ae67d2014-09-08 12:22:09 -07001490 }
1491
Tianjie Xuaced5d92016-10-12 10:55:04 -07001492 int res = CreateStash(state, stash_max_blocks, blockdev_filename->data.c_str(), params.stashbase);
Tao Baob15fd222015-09-24 11:10:51 -07001493 if (res == -1) {
Tianjie Xuaced5d92016-10-12 10:55:04 -07001494 return StringValue("");
Sami Tolvanen90221202014-12-09 16:39:47 +00001495 }
Tao Bao612336d2015-08-27 16:41:21 -07001496
Tao Baob15fd222015-09-24 11:10:51 -07001497 params.createdstash = res;
1498
Tao Bao612336d2015-08-27 16:41:21 -07001499 start += 2;
Doug Zongker52ae67d2014-09-08 12:22:09 -07001500 }
1501
Tianjie Xu8cf5c8f2016-09-08 20:10:11 -07001502 // Build a map of the available commands
1503 std::unordered_map<std::string, const Command*> cmd_map;
Tao Bao0940fe12015-08-27 16:41:21 -07001504 for (size_t i = 0; i < cmdcount; ++i) {
Tianjie Xu8cf5c8f2016-09-08 20:10:11 -07001505 if (cmd_map.find(commands[i].name) != cmd_map.end()) {
Tao Bao039f2da2016-11-22 16:29:50 -08001506 LOG(ERROR) << "Error: command [" << commands[i].name
1507 << "] already exists in the cmd map.";
Tianjie Xu8cf5c8f2016-09-08 20:10:11 -07001508 return StringValue(strdup(""));
1509 }
1510 cmd_map[commands[i].name] = &commands[i];
Sami Tolvanen90221202014-12-09 16:39:47 +00001511 }
1512
Tao Bao612336d2015-08-27 16:41:21 -07001513 int rc = -1;
Doug Zongker52ae67d2014-09-08 12:22:09 -07001514
Tao Bao612336d2015-08-27 16:41:21 -07001515 // Subsequent lines are all individual transfer commands
1516 for (auto it = lines.cbegin() + start; it != lines.cend(); it++) {
1517 const std::string& line_str(*it);
Tao Bao6a47dff2015-09-25 17:12:28 -07001518 if (line_str.empty()) {
1519 continue;
1520 }
1521
Tao Baobaad2d42015-12-06 16:56:27 -08001522 params.tokens = android::base::Split(line_str, " ");
1523 params.cpos = 0;
1524 params.cmdname = params.tokens[params.cpos++].c_str();
1525 params.cmdline = line_str.c_str();
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001526
Tianjie Xu8cf5c8f2016-09-08 20:10:11 -07001527 if (cmd_map.find(params.cmdname) == cmd_map.end()) {
Tao Bao039f2da2016-11-22 16:29:50 -08001528 LOG(ERROR) << "unexpected command [" << params.cmdname << "]";
Sami Tolvanen90221202014-12-09 16:39:47 +00001529 goto pbiudone;
1530 }
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001531
Tianjie Xu8cf5c8f2016-09-08 20:10:11 -07001532 const Command* cmd = cmd_map[params.cmdname];
1533
Tao Bao0940fe12015-08-27 16:41:21 -07001534 if (cmd->f != nullptr && cmd->f(params) == -1) {
Tao Bao039f2da2016-11-22 16:29:50 -08001535 LOG(ERROR) << "failed to execute command [" << line_str << "]";
Sami Tolvanen90221202014-12-09 16:39:47 +00001536 goto pbiudone;
1537 }
1538
Sami Tolvanen90221202014-12-09 16:39:47 +00001539 if (params.canwrite) {
Jed Estepa7b9a462015-12-15 16:04:53 -08001540 if (ota_fsync(params.fd) == -1) {
Tianjie Xu16255832016-04-30 11:49:59 -07001541 failure_type = kFsyncFailure;
Tao Bao039f2da2016-11-22 16:29:50 -08001542 PLOG(ERROR) << "fsync failed";
Tao Bao187efff2015-07-27 14:07:08 -07001543 goto pbiudone;
1544 }
Sami Tolvanen90221202014-12-09 16:39:47 +00001545 fprintf(cmd_pipe, "set_progress %.4f\n", (double) params.written / total_blocks);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001546 fflush(cmd_pipe);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001547 }
1548 }
1549
Sami Tolvanen90221202014-12-09 16:39:47 +00001550 if (params.canwrite) {
Tao Bao0940fe12015-08-27 16:41:21 -07001551 pthread_join(params.thread, nullptr);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001552
Tao Bao039f2da2016-11-22 16:29:50 -08001553 LOG(INFO) << "wrote " << params.written << " blocks; expected " << total_blocks;
1554 LOG(INFO) << "stashed " << params.stashed << " blocks";
1555 LOG(INFO) << "max alloc needed was " << params.buffer.size();
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001556
Tianjie Xuaced5d92016-10-12 10:55:04 -07001557 const char* partition = strrchr(blockdev_filename->data.c_str(), '/');
Tianjie Xudd874b12016-05-13 12:13:15 -07001558 if (partition != nullptr && *(partition+1) != 0) {
1559 fprintf(cmd_pipe, "log bytes_written_%s: %zu\n", partition + 1,
1560 params.written * BLOCKSIZE);
1561 fprintf(cmd_pipe, "log bytes_stashed_%s: %zu\n", partition + 1,
1562 params.stashed * BLOCKSIZE);
1563 fflush(cmd_pipe);
1564 }
Sami Tolvanen90221202014-12-09 16:39:47 +00001565 // Delete stash only after successfully completing the update, as it
1566 // may contain blocks needed to complete the update later.
1567 DeleteStash(params.stashbase);
1568 } else {
Tao Bao039f2da2016-11-22 16:29:50 -08001569 LOG(INFO) << "verified partition contents; update may be resumed";
Sami Tolvanen90221202014-12-09 16:39:47 +00001570 }
1571
1572 rc = 0;
1573
1574pbiudone:
Jed Estepa7b9a462015-12-15 16:04:53 -08001575 if (ota_fsync(params.fd) == -1) {
Tianjie Xu16255832016-04-30 11:49:59 -07001576 failure_type = kFsyncFailure;
Tao Bao039f2da2016-11-22 16:29:50 -08001577 PLOG(ERROR) << "fsync failed";
Sami Tolvanen90221202014-12-09 16:39:47 +00001578 }
Elliott Hughesbcabd092016-03-22 20:19:22 -07001579 // params.fd will be automatically closed because it's a unique_fd.
Sami Tolvanen90221202014-12-09 16:39:47 +00001580
Sami Tolvanen90221202014-12-09 16:39:47 +00001581 // Only delete the stash if the update cannot be resumed, or it's
1582 // a verification run and we created the stash.
1583 if (params.isunresumable || (!params.canwrite && params.createdstash)) {
1584 DeleteStash(params.stashbase);
1585 }
1586
Tianjie Xu16255832016-04-30 11:49:59 -07001587 if (failure_type != kNoCause && state->cause_code == kNoCause) {
1588 state->cause_code = failure_type;
1589 }
1590
Tianjie Xuaced5d92016-10-12 10:55:04 -07001591 return StringValue(rc == 0 ? "t" : "");
Sami Tolvanen90221202014-12-09 16:39:47 +00001592}
1593
1594// The transfer list is a text file containing commands to
1595// transfer data from one place to another on the target
1596// partition. We parse it and execute the commands in order:
1597//
1598// zero [rangeset]
1599// - fill the indicated blocks with zeros
1600//
1601// new [rangeset]
1602// - fill the blocks with data read from the new_data file
1603//
1604// erase [rangeset]
1605// - mark the given blocks as empty
1606//
1607// move <...>
1608// bsdiff <patchstart> <patchlen> <...>
1609// imgdiff <patchstart> <patchlen> <...>
1610// - read the source blocks, apply a patch (or not in the
1611// case of move), write result to target blocks. bsdiff or
1612// imgdiff specifies the type of patch; move means no patch
1613// at all.
1614//
1615// The format of <...> differs between versions 1 and 2;
1616// see the LoadSrcTgtVersion{1,2}() functions for a
1617// description of what's expected.
1618//
1619// stash <stash_id> <src_range>
1620// - (version 2+ only) load the given source range and stash
1621// the data in the given slot of the stash table.
1622//
Tao Baobaad2d42015-12-06 16:56:27 -08001623// free <stash_id>
1624// - (version 3+ only) free the given stash data.
1625//
Sami Tolvanen90221202014-12-09 16:39:47 +00001626// The creator of the transfer list will guarantee that no block
1627// is read (ie, used as the source for a patch or move) after it
1628// has been written.
1629//
1630// In version 2, the creator will guarantee that a given stash is
1631// loaded (with a stash command) before it's used in a
1632// move/bsdiff/imgdiff command.
1633//
1634// Within one command the source and target ranges may overlap so
1635// in general we need to read the entire source into memory before
1636// writing anything to the target blocks.
1637//
1638// All the patch data is concatenated into one patch_data file in
1639// the update package. It must be stored uncompressed because we
1640// memory-map it in directly from the archive. (Since patches are
1641// already compressed, we lose very little by not compressing
1642// their concatenation.)
1643//
1644// In version 3, commands that read data from the partition (i.e.
1645// move/bsdiff/imgdiff/stash) have one or more additional hashes
1646// before the range parameters, which are used to check if the
1647// command has already been completed and verify the integrity of
1648// the source data.
1649
1650Value* BlockImageVerifyFn(const char* name, State* state, int argc, Expr* argv[]) {
Tao Bao0940fe12015-08-27 16:41:21 -07001651 // Commands which are not tested are set to nullptr to skip them completely
Sami Tolvanen90221202014-12-09 16:39:47 +00001652 const Command commands[] = {
1653 { "bsdiff", PerformCommandDiff },
Tao Bao0940fe12015-08-27 16:41:21 -07001654 { "erase", nullptr },
Sami Tolvanen90221202014-12-09 16:39:47 +00001655 { "free", PerformCommandFree },
1656 { "imgdiff", PerformCommandDiff },
1657 { "move", PerformCommandMove },
Tao Bao0940fe12015-08-27 16:41:21 -07001658 { "new", nullptr },
Sami Tolvanen90221202014-12-09 16:39:47 +00001659 { "stash", PerformCommandStash },
Tao Bao0940fe12015-08-27 16:41:21 -07001660 { "zero", nullptr }
Sami Tolvanen90221202014-12-09 16:39:47 +00001661 };
1662
1663 // Perform a dry run without writing to test if an update can proceed
1664 return PerformBlockImageUpdate(name, state, argc, argv, commands,
Tao Baoe6aa3322015-08-05 15:20:27 -07001665 sizeof(commands) / sizeof(commands[0]), true);
Sami Tolvanen90221202014-12-09 16:39:47 +00001666}
1667
1668Value* BlockImageUpdateFn(const char* name, State* state, int argc, Expr* argv[]) {
1669 const Command commands[] = {
1670 { "bsdiff", PerformCommandDiff },
1671 { "erase", PerformCommandErase },
1672 { "free", PerformCommandFree },
1673 { "imgdiff", PerformCommandDiff },
1674 { "move", PerformCommandMove },
1675 { "new", PerformCommandNew },
1676 { "stash", PerformCommandStash },
1677 { "zero", PerformCommandZero }
1678 };
1679
1680 return PerformBlockImageUpdate(name, state, argc, argv, commands,
Tao Baoe6aa3322015-08-05 15:20:27 -07001681 sizeof(commands) / sizeof(commands[0]), false);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001682}
1683
Tao Bao0940fe12015-08-27 16:41:21 -07001684Value* RangeSha1Fn(const char* name, State* state, int /* argc */, Expr* argv[]) {
Tianjie Xu5fe280a2016-10-17 18:15:20 -07001685 std::vector<std::unique_ptr<Value>> args;
1686 if (!ReadValueArgs(state, 2, argv, &args)) {
1687 return nullptr;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001688 }
Tianjie Xu5fe280a2016-10-17 18:15:20 -07001689
1690 const Value* blockdev_filename = args[0].get();
1691 const Value* ranges = args[1].get();
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001692
1693 if (blockdev_filename->type != VAL_STRING) {
Tianjie Xu16255832016-04-30 11:49:59 -07001694 ErrorAbort(state, kArgsParsingFailure, "blockdev_filename argument to %s must be string",
1695 name);
Tianjie Xuaced5d92016-10-12 10:55:04 -07001696 return StringValue("");
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001697 }
1698 if (ranges->type != VAL_STRING) {
Tianjie Xu16255832016-04-30 11:49:59 -07001699 ErrorAbort(state, kArgsParsingFailure, "ranges argument to %s must be string", name);
Tianjie Xuaced5d92016-10-12 10:55:04 -07001700 return StringValue("");
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001701 }
1702
Tianjie Xuaced5d92016-10-12 10:55:04 -07001703 android::base::unique_fd fd(ota_open(blockdev_filename->data.c_str(), O_RDWR));
Elliott Hughesbcabd092016-03-22 20:19:22 -07001704 if (fd == -1) {
Tianjie Xuaced5d92016-10-12 10:55:04 -07001705 ErrorAbort(state, kFileOpenFailure, "open \"%s\" failed: %s",
1706 blockdev_filename->data.c_str(), strerror(errno));
1707 return StringValue("");
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001708 }
1709
Tao Bao612336d2015-08-27 16:41:21 -07001710 RangeSet rs;
Tao Bao0940fe12015-08-27 16:41:21 -07001711 parse_range(ranges->data, rs);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001712
1713 SHA_CTX ctx;
Sen Jiangc48cb5e2016-02-04 16:23:21 +08001714 SHA1_Init(&ctx);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001715
Tao Bao612336d2015-08-27 16:41:21 -07001716 std::vector<uint8_t> buffer(BLOCKSIZE);
Tao Bao0940fe12015-08-27 16:41:21 -07001717 for (size_t i = 0; i < rs.count; ++i) {
1718 if (!check_lseek(fd, (off64_t)rs.pos[i*2] * BLOCKSIZE, SEEK_SET)) {
Tianjie Xuaced5d92016-10-12 10:55:04 -07001719 ErrorAbort(state, kLseekFailure, "failed to seek %s: %s",
1720 blockdev_filename->data.c_str(), strerror(errno));
1721 return StringValue("");
Sami Tolvanen90221202014-12-09 16:39:47 +00001722 }
1723
Tao Bao0940fe12015-08-27 16:41:21 -07001724 for (size_t j = rs.pos[i*2]; j < rs.pos[i*2+1]; ++j) {
Sami Tolvanen90221202014-12-09 16:39:47 +00001725 if (read_all(fd, buffer, BLOCKSIZE) == -1) {
Tianjie Xuaced5d92016-10-12 10:55:04 -07001726 ErrorAbort(state, kFreadFailure, "failed to read %s: %s",
1727 blockdev_filename->data.c_str(), strerror(errno));
1728 return StringValue("");
Sami Tolvanen90221202014-12-09 16:39:47 +00001729 }
1730
Sen Jiangc48cb5e2016-02-04 16:23:21 +08001731 SHA1_Update(&ctx, buffer.data(), BLOCKSIZE);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001732 }
1733 }
Sen Jiangc48cb5e2016-02-04 16:23:21 +08001734 uint8_t digest[SHA_DIGEST_LENGTH];
1735 SHA1_Final(digest, &ctx);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001736
Tianjie Xuaced5d92016-10-12 10:55:04 -07001737 return StringValue(print_sha1(digest));
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001738}
1739
Tianjie Xu57bed6d2015-12-15 11:47:30 -08001740// This function checks if a device has been remounted R/W prior to an incremental
1741// OTA update. This is an common cause of update abortion. The function reads the
1742// 1st block of each partition and check for mounting time/count. It return string "t"
1743// if executes successfully and an empty string otherwise.
1744
1745Value* CheckFirstBlockFn(const char* name, State* state, int argc, Expr* argv[]) {
Tianjie Xu5fe280a2016-10-17 18:15:20 -07001746 std::vector<std::unique_ptr<Value>> args;
1747 if (!ReadValueArgs(state, 1, argv, &args)) {
Tianjie Xu57bed6d2015-12-15 11:47:30 -08001748 return nullptr;
1749 }
Tianjie Xu57bed6d2015-12-15 11:47:30 -08001750
Tianjie Xu5fe280a2016-10-17 18:15:20 -07001751 const Value* arg_filename = args[0].get();
1752
1753 if (arg_filename->type != VAL_STRING) {
Tianjie Xu16255832016-04-30 11:49:59 -07001754 ErrorAbort(state, kArgsParsingFailure, "filename argument to %s must be string", name);
Tianjie Xuaced5d92016-10-12 10:55:04 -07001755 return StringValue("");
Tianjie Xu57bed6d2015-12-15 11:47:30 -08001756 }
1757
Tianjie Xuaced5d92016-10-12 10:55:04 -07001758 android::base::unique_fd fd(ota_open(arg_filename->data.c_str(), O_RDONLY));
Tianjie Xu57bed6d2015-12-15 11:47:30 -08001759 if (fd == -1) {
Tianjie Xuaced5d92016-10-12 10:55:04 -07001760 ErrorAbort(state, kFileOpenFailure, "open \"%s\" failed: %s", arg_filename->data.c_str(),
Tianjie Xu16255832016-04-30 11:49:59 -07001761 strerror(errno));
Tianjie Xuaced5d92016-10-12 10:55:04 -07001762 return StringValue("");
Tianjie Xu57bed6d2015-12-15 11:47:30 -08001763 }
1764
1765 RangeSet blk0 {1 /*count*/, 1/*size*/, std::vector<size_t> {0, 1}/*position*/};
1766 std::vector<uint8_t> block0_buffer(BLOCKSIZE);
1767
1768 if (ReadBlocks(blk0, block0_buffer, fd) == -1) {
Tianjie Xuaced5d92016-10-12 10:55:04 -07001769 ErrorAbort(state, kFreadFailure, "failed to read %s: %s", arg_filename->data.c_str(),
Tianjie Xu30bf4762015-12-15 11:47:30 -08001770 strerror(errno));
Tianjie Xuaced5d92016-10-12 10:55:04 -07001771 return StringValue("");
Tianjie Xu57bed6d2015-12-15 11:47:30 -08001772 }
1773
1774 // https://ext4.wiki.kernel.org/index.php/Ext4_Disk_Layout
1775 // Super block starts from block 0, offset 0x400
1776 // 0x2C: len32 Mount time
1777 // 0x30: len32 Write time
1778 // 0x34: len16 Number of mounts since the last fsck
1779 // 0x38: len16 Magic signature 0xEF53
1780
1781 time_t mount_time = *reinterpret_cast<uint32_t*>(&block0_buffer[0x400+0x2C]);
1782 uint16_t mount_count = *reinterpret_cast<uint16_t*>(&block0_buffer[0x400+0x34]);
1783
1784 if (mount_count > 0) {
1785 uiPrintf(state, "Device was remounted R/W %d times\n", mount_count);
1786 uiPrintf(state, "Last remount happened on %s", ctime(&mount_time));
1787 }
1788
Tianjie Xuaced5d92016-10-12 10:55:04 -07001789 return StringValue("t");
Tianjie Xu57bed6d2015-12-15 11:47:30 -08001790}
1791
1792
Sami Tolvanen0a7b4732015-06-25 10:25:36 +01001793Value* BlockImageRecoverFn(const char* name, State* state, int argc, Expr* argv[]) {
Tianjie Xu5fe280a2016-10-17 18:15:20 -07001794 std::vector<std::unique_ptr<Value>> args;
1795 if (!ReadValueArgs(state, 2, argv, &args)) {
1796 return nullptr;
Sami Tolvanen0a7b4732015-06-25 10:25:36 +01001797 }
1798
Tianjie Xu5fe280a2016-10-17 18:15:20 -07001799 const Value* filename = args[0].get();
1800 const Value* ranges = args[1].get();
Sami Tolvanen0a7b4732015-06-25 10:25:36 +01001801
1802 if (filename->type != VAL_STRING) {
Tianjie Xu16255832016-04-30 11:49:59 -07001803 ErrorAbort(state, kArgsParsingFailure, "filename argument to %s must be string", name);
Tianjie Xuaced5d92016-10-12 10:55:04 -07001804 return StringValue("");
Sami Tolvanen0a7b4732015-06-25 10:25:36 +01001805 }
1806 if (ranges->type != VAL_STRING) {
Tianjie Xu16255832016-04-30 11:49:59 -07001807 ErrorAbort(state, kArgsParsingFailure, "ranges argument to %s must be string", name);
Tianjie Xuaced5d92016-10-12 10:55:04 -07001808 return StringValue("");
Sami Tolvanen0a7b4732015-06-25 10:25:36 +01001809 }
1810
Tianjie Xu3b010bc2015-12-09 15:29:45 -08001811 // Output notice to log when recover is attempted
Tao Bao039f2da2016-11-22 16:29:50 -08001812 LOG(INFO) << filename->data << " image corrupted, attempting to recover...";
Tianjie Xu3b010bc2015-12-09 15:29:45 -08001813
Sami Tolvanen0a7b4732015-06-25 10:25:36 +01001814 // When opened with O_RDWR, libfec rewrites corrupted blocks when they are read
Tianjie Xuaced5d92016-10-12 10:55:04 -07001815 fec::io fh(filename->data.c_str(), O_RDWR);
Sami Tolvanen0a7b4732015-06-25 10:25:36 +01001816
1817 if (!fh) {
Tianjie Xuaced5d92016-10-12 10:55:04 -07001818 ErrorAbort(state, kLibfecFailure, "fec_open \"%s\" failed: %s", filename->data.c_str(),
Tianjie Xu16255832016-04-30 11:49:59 -07001819 strerror(errno));
Tianjie Xuaced5d92016-10-12 10:55:04 -07001820 return StringValue("");
Sami Tolvanen0a7b4732015-06-25 10:25:36 +01001821 }
1822
1823 if (!fh.has_ecc() || !fh.has_verity()) {
Tianjie Xu16255832016-04-30 11:49:59 -07001824 ErrorAbort(state, kLibfecFailure, "unable to use metadata to correct errors");
Tianjie Xuaced5d92016-10-12 10:55:04 -07001825 return StringValue("");
Sami Tolvanen0a7b4732015-06-25 10:25:36 +01001826 }
1827
1828 fec_status status;
1829
1830 if (!fh.get_status(status)) {
Tianjie Xu16255832016-04-30 11:49:59 -07001831 ErrorAbort(state, kLibfecFailure, "failed to read FEC status");
Tianjie Xuaced5d92016-10-12 10:55:04 -07001832 return StringValue("");
Sami Tolvanen0a7b4732015-06-25 10:25:36 +01001833 }
1834
1835 RangeSet rs;
1836 parse_range(ranges->data, rs);
1837
1838 uint8_t buffer[BLOCKSIZE];
1839
1840 for (size_t i = 0; i < rs.count; ++i) {
1841 for (size_t j = rs.pos[i * 2]; j < rs.pos[i * 2 + 1]; ++j) {
1842 // Stay within the data area, libfec validates and corrects metadata
1843 if (status.data_size <= (uint64_t)j * BLOCKSIZE) {
1844 continue;
1845 }
1846
1847 if (fh.pread(buffer, BLOCKSIZE, (off64_t)j * BLOCKSIZE) != BLOCKSIZE) {
Tianjie Xu16255832016-04-30 11:49:59 -07001848 ErrorAbort(state, kLibfecFailure, "failed to recover %s (block %zu): %s",
Tianjie Xuaced5d92016-10-12 10:55:04 -07001849 filename->data.c_str(), j, strerror(errno));
1850 return StringValue("");
Sami Tolvanen0a7b4732015-06-25 10:25:36 +01001851 }
1852
1853 // If we want to be able to recover from a situation where rewriting a corrected
1854 // block doesn't guarantee the same data will be returned when re-read later, we
1855 // can save a copy of corrected blocks to /cache. Note:
1856 //
1857 // 1. Maximum space required from /cache is the same as the maximum number of
1858 // corrupted blocks we can correct. For RS(255, 253) and a 2 GiB partition,
1859 // this would be ~16 MiB, for example.
1860 //
1861 // 2. To find out if this block was corrupted, call fec_get_status after each
1862 // read and check if the errors field value has increased.
1863 }
1864 }
Tao Bao039f2da2016-11-22 16:29:50 -08001865 LOG(INFO) << "..." << filename->data << " image recovered successfully.";
Tianjie Xuaced5d92016-10-12 10:55:04 -07001866 return StringValue("t");
Sami Tolvanen0a7b4732015-06-25 10:25:36 +01001867}
1868
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001869void RegisterBlockImageFunctions() {
Sami Tolvanen90221202014-12-09 16:39:47 +00001870 RegisterFunction("block_image_verify", BlockImageVerifyFn);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001871 RegisterFunction("block_image_update", BlockImageUpdateFn);
Sami Tolvanen0a7b4732015-06-25 10:25:36 +01001872 RegisterFunction("block_image_recover", BlockImageRecoverFn);
Tianjie Xu57bed6d2015-12-15 11:47:30 -08001873 RegisterFunction("check_first_block", CheckFirstBlockFn);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001874 RegisterFunction("range_sha1", RangeSha1Fn);
1875}