blob: 44de4e03114396bdef0cb370a4eda19643c8ee7a [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>
21#include <inttypes.h>
Tao Baoba9a42a2015-06-23 23:23:33 -070022#include <linux/fs.h>
Doug Zongkerbc7ffed2014-08-15 14:31:52 -070023#include <pthread.h>
24#include <stdarg.h>
25#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
Sami Tolvanen90221202014-12-09 16:39:47 +000028#include <sys/stat.h>
Doug Zongkerbc7ffed2014-08-15 14:31:52 -070029#include <sys/types.h>
30#include <sys/wait.h>
31#include <sys/ioctl.h>
32#include <time.h>
33#include <unistd.h>
Sami Tolvanen0a7b4732015-06-25 10:25:36 +010034#include <fec/io.h>
Doug Zongkerbc7ffed2014-08-15 14:31:52 -070035
Tao Baoe6aa3322015-08-05 15:20:27 -070036#include <memory>
37#include <string>
Tao Bao0940fe12015-08-27 16:41:21 -070038#include <vector>
Tao Baoe6aa3322015-08-05 15:20:27 -070039
Elliott Hughes4b166f02015-12-04 15:30:20 -080040#include <android-base/parseint.h>
41#include <android-base/strings.h>
Tao Baoe6aa3322015-08-05 15:20:27 -070042
Doug Zongkerbc7ffed2014-08-15 14:31:52 -070043#include "applypatch/applypatch.h"
44#include "edify/expr.h"
Tianjie Xu57bed6d2015-12-15 11:47:30 -080045#include "install.h"
Sen Jiangc48cb5e2016-02-04 16:23:21 +080046#include "openssl/sha.h"
Sami Tolvanen90221202014-12-09 16:39:47 +000047#include "minzip/Hash.h"
Jed Estepa7b9a462015-12-15 16:04:53 -080048#include "otafault/ota_io.h"
Tao Baoe6aa3322015-08-05 15:20:27 -070049#include "print_sha1.h"
Tao Bao0940fe12015-08-27 16:41:21 -070050#include "unique_fd.h"
51#include "updater.h"
Doug Zongkerbc7ffed2014-08-15 14:31:52 -070052
53#define BLOCKSIZE 4096
54
Sami Tolvanene82fa182015-06-10 15:58:12 +000055// Set this to 0 to interpret 'erase' transfers to mean do a
56// BLKDISCARD ioctl (the normal behavior). Set to 1 to interpret
57// erase to mean fill the region with zeroes.
58#define DEBUG_ERASE 0
59
Sami Tolvanen90221202014-12-09 16:39:47 +000060#define STASH_DIRECTORY_BASE "/cache/recovery"
61#define STASH_DIRECTORY_MODE 0700
62#define STASH_FILE_MODE 0600
63
Tao Bao0940fe12015-08-27 16:41:21 -070064struct RangeSet {
65 size_t count; // Limit is INT_MAX.
Shrinivas Sahukara6153df2015-08-19 13:01:45 +053066 size_t size;
Tao Bao0940fe12015-08-27 16:41:21 -070067 std::vector<size_t> pos; // Actual limit is INT_MAX.
68};
Doug Zongkerbc7ffed2014-08-15 14:31:52 -070069
Tao Baobaad2d42015-12-06 16:56:27 -080070static void parse_range(const std::string& range_text, RangeSet& rs) {
Sami Tolvanenf2bac042015-05-12 12:48:46 +010071
Tao Baobaad2d42015-12-06 16:56:27 -080072 std::vector<std::string> pieces = android::base::Split(range_text, ",");
Tao Bao0940fe12015-08-27 16:41:21 -070073 if (pieces.size() < 3) {
Sami Tolvanenf2bac042015-05-12 12:48:46 +010074 goto err;
75 }
76
Tao Baob15fd222015-09-24 11:10:51 -070077 size_t num;
78 if (!android::base::ParseUint(pieces[0].c_str(), &num, static_cast<size_t>(INT_MAX))) {
Sami Tolvanenf2bac042015-05-12 12:48:46 +010079 goto err;
80 }
81
Tao Baob15fd222015-09-24 11:10:51 -070082 if (num == 0 || num % 2) {
83 goto err; // must be even
84 } else if (num != pieces.size() - 1) {
85 goto err;
86 }
Sami Tolvanenf2bac042015-05-12 12:48:46 +010087
Tao Bao0940fe12015-08-27 16:41:21 -070088 rs.pos.resize(num);
89 rs.count = num / 2;
90 rs.size = 0;
Sami Tolvanenf2bac042015-05-12 12:48:46 +010091
Tao Bao0940fe12015-08-27 16:41:21 -070092 for (size_t i = 0; i < num; i += 2) {
Tao Baob15fd222015-09-24 11:10:51 -070093 if (!android::base::ParseUint(pieces[i+1].c_str(), &rs.pos[i],
94 static_cast<size_t>(INT_MAX))) {
Sami Tolvanenf2bac042015-05-12 12:48:46 +010095 goto err;
96 }
97
Tao Baob15fd222015-09-24 11:10:51 -070098 if (!android::base::ParseUint(pieces[i+2].c_str(), &rs.pos[i+1],
99 static_cast<size_t>(INT_MAX))) {
Shrinivas Sahukara6153df2015-08-19 13:01:45 +0530100 goto err;
101 }
102
Tao Bao0940fe12015-08-27 16:41:21 -0700103 if (rs.pos[i] >= rs.pos[i+1]) {
Shrinivas Sahukara6153df2015-08-19 13:01:45 +0530104 goto err; // empty or negative range
105 }
106
Tao Bao0940fe12015-08-27 16:41:21 -0700107 size_t sz = rs.pos[i+1] - rs.pos[i];
108 if (rs.size > SIZE_MAX - sz) {
Shrinivas Sahukara6153df2015-08-19 13:01:45 +0530109 goto err; // overflow
110 }
111
Tao Bao0940fe12015-08-27 16:41:21 -0700112 rs.size += sz;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700113 }
114
Tao Bao0940fe12015-08-27 16:41:21 -0700115 return;
Sami Tolvanenf2bac042015-05-12 12:48:46 +0100116
117err:
Tao Baobaad2d42015-12-06 16:56:27 -0800118 fprintf(stderr, "failed to parse range '%s'\n", range_text.c_str());
Sami Tolvanenf2bac042015-05-12 12:48:46 +0100119 exit(1);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700120}
121
Tao Baoe6aa3322015-08-05 15:20:27 -0700122static bool range_overlaps(const RangeSet& r1, const RangeSet& r2) {
Shrinivas Sahukara6153df2015-08-19 13:01:45 +0530123 for (size_t i = 0; i < r1.count; ++i) {
124 size_t r1_0 = r1.pos[i * 2];
125 size_t r1_1 = r1.pos[i * 2 + 1];
Sami Tolvanen90221202014-12-09 16:39:47 +0000126
Shrinivas Sahukara6153df2015-08-19 13:01:45 +0530127 for (size_t j = 0; j < r2.count; ++j) {
128 size_t r2_0 = r2.pos[j * 2];
129 size_t r2_1 = r2.pos[j * 2 + 1];
Sami Tolvanen90221202014-12-09 16:39:47 +0000130
Tao Baoc0f56ad2015-06-25 14:00:31 -0700131 if (!(r2_0 >= r1_1 || r1_0 >= r2_1)) {
Tao Baoe6aa3322015-08-05 15:20:27 -0700132 return true;
Sami Tolvanen90221202014-12-09 16:39:47 +0000133 }
134 }
135 }
136
Tao Baoe6aa3322015-08-05 15:20:27 -0700137 return false;
Sami Tolvanen90221202014-12-09 16:39:47 +0000138}
139
140static int read_all(int fd, uint8_t* data, size_t size) {
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700141 size_t so_far = 0;
142 while (so_far < size) {
Jed Estepa7b9a462015-12-15 16:04:53 -0800143 ssize_t r = TEMP_FAILURE_RETRY(ota_read(fd, data+so_far, size-so_far));
Elliott Hughes7bad7c42015-04-28 17:24:24 -0700144 if (r == -1) {
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700145 fprintf(stderr, "read failed: %s\n", strerror(errno));
Sami Tolvanen90221202014-12-09 16:39:47 +0000146 return -1;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700147 }
Elliott Hughes7bad7c42015-04-28 17:24:24 -0700148 so_far += r;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700149 }
Sami Tolvanen90221202014-12-09 16:39:47 +0000150 return 0;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700151}
152
Tao Bao612336d2015-08-27 16:41:21 -0700153static int read_all(int fd, std::vector<uint8_t>& buffer, size_t size) {
154 return read_all(fd, buffer.data(), size);
155}
156
Sami Tolvanen90221202014-12-09 16:39:47 +0000157static int write_all(int fd, const uint8_t* data, size_t size) {
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700158 size_t written = 0;
159 while (written < size) {
Jed Estepa7b9a462015-12-15 16:04:53 -0800160 ssize_t w = TEMP_FAILURE_RETRY(ota_write(fd, data+written, size-written));
Elliott Hughes7bad7c42015-04-28 17:24:24 -0700161 if (w == -1) {
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700162 fprintf(stderr, "write failed: %s\n", strerror(errno));
Sami Tolvanen90221202014-12-09 16:39:47 +0000163 return -1;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700164 }
Elliott Hughes7bad7c42015-04-28 17:24:24 -0700165 written += w;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700166 }
Sami Tolvanen90221202014-12-09 16:39:47 +0000167
Sami Tolvanen90221202014-12-09 16:39:47 +0000168 return 0;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700169}
170
Tao Bao612336d2015-08-27 16:41:21 -0700171static int write_all(int fd, const std::vector<uint8_t>& buffer, size_t size) {
172 return write_all(fd, buffer.data(), size);
173}
174
Elliott Hughes7bad7c42015-04-28 17:24:24 -0700175static bool check_lseek(int fd, off64_t offset, int whence) {
176 off64_t rc = TEMP_FAILURE_RETRY(lseek64(fd, offset, whence));
177 if (rc == -1) {
178 fprintf(stderr, "lseek64 failed: %s\n", strerror(errno));
179 return false;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700180 }
Elliott Hughes7bad7c42015-04-28 17:24:24 -0700181 return true;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700182}
183
Tao Bao612336d2015-08-27 16:41:21 -0700184static void allocate(size_t size, std::vector<uint8_t>& buffer) {
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700185 // if the buffer's big enough, reuse it.
Tao Bao612336d2015-08-27 16:41:21 -0700186 if (size <= buffer.size()) return;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700187
Tao Bao612336d2015-08-27 16:41:21 -0700188 buffer.resize(size);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700189}
190
Tao Bao0940fe12015-08-27 16:41:21 -0700191struct RangeSinkState {
192 RangeSinkState(RangeSet& rs) : tgt(rs) { };
193
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700194 int fd;
Tao Bao0940fe12015-08-27 16:41:21 -0700195 const RangeSet& tgt;
Shrinivas Sahukara6153df2015-08-19 13:01:45 +0530196 size_t p_block;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700197 size_t p_remain;
Tao Bao0940fe12015-08-27 16:41:21 -0700198};
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700199
200static ssize_t RangeSinkWrite(const uint8_t* data, ssize_t size, void* token) {
Tao Bao0940fe12015-08-27 16:41:21 -0700201 RangeSinkState* rss = reinterpret_cast<RangeSinkState*>(token);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700202
Tao Bao0940fe12015-08-27 16:41:21 -0700203 if (rss->p_remain == 0) {
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700204 fprintf(stderr, "range sink write overrun");
Sami Tolvanen90221202014-12-09 16:39:47 +0000205 return 0;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700206 }
207
208 ssize_t written = 0;
209 while (size > 0) {
210 size_t write_now = size;
Sami Tolvanen90221202014-12-09 16:39:47 +0000211
212 if (rss->p_remain < write_now) {
213 write_now = rss->p_remain;
214 }
215
216 if (write_all(rss->fd, data, write_now) == -1) {
217 break;
218 }
219
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700220 data += write_now;
221 size -= write_now;
222
223 rss->p_remain -= write_now;
224 written += write_now;
225
226 if (rss->p_remain == 0) {
227 // move to the next block
228 ++rss->p_block;
Tao Bao0940fe12015-08-27 16:41:21 -0700229 if (rss->p_block < rss->tgt.count) {
230 rss->p_remain = (rss->tgt.pos[rss->p_block * 2 + 1] -
231 rss->tgt.pos[rss->p_block * 2]) * BLOCKSIZE;
Sami Tolvanen90221202014-12-09 16:39:47 +0000232
Tao Bao0940fe12015-08-27 16:41:21 -0700233 if (!check_lseek(rss->fd, (off64_t)rss->tgt.pos[rss->p_block*2] * BLOCKSIZE,
Elliott Hughes7bad7c42015-04-28 17:24:24 -0700234 SEEK_SET)) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000235 break;
236 }
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700237 } else {
238 // we can't write any more; return how many bytes have
239 // been written so far.
Sami Tolvanen90221202014-12-09 16:39:47 +0000240 break;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700241 }
242 }
243 }
244
245 return written;
246}
247
248// All of the data for all the 'new' transfers is contained in one
249// file in the update package, concatenated together in the order in
250// which transfers.list will need it. We want to stream it out of the
251// archive (it's compressed) without writing it to a temp file, but we
252// can't write each section until it's that transfer's turn to go.
253//
254// To achieve this, we expand the new data from the archive in a
255// background thread, and block that threads 'receive uncompressed
256// data' function until the main thread has reached a point where we
257// want some new data to be written. We signal the background thread
258// with the destination for the data and block the main thread,
259// waiting for the background thread to complete writing that section.
260// Then it signals the main thread to wake up and goes back to
261// blocking waiting for a transfer.
262//
263// NewThreadInfo is the struct used to pass information back and forth
264// between the two threads. When the main thread wants some data
265// written, it sets rss to the destination location and signals the
266// condition. When the background thread is done writing, it clears
267// rss and signals the condition again.
268
Tao Bao0940fe12015-08-27 16:41:21 -0700269struct NewThreadInfo {
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700270 ZipArchive* za;
271 const ZipEntry* entry;
272
273 RangeSinkState* rss;
274
275 pthread_mutex_t mu;
276 pthread_cond_t cv;
Tao Bao0940fe12015-08-27 16:41:21 -0700277};
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700278
279static bool receive_new_data(const unsigned char* data, int size, void* cookie) {
Tao Bao0940fe12015-08-27 16:41:21 -0700280 NewThreadInfo* nti = reinterpret_cast<NewThreadInfo*>(cookie);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700281
282 while (size > 0) {
Tao Bao0940fe12015-08-27 16:41:21 -0700283 // Wait for nti->rss to be non-null, indicating some of this
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700284 // data is wanted.
285 pthread_mutex_lock(&nti->mu);
Tao Bao0940fe12015-08-27 16:41:21 -0700286 while (nti->rss == nullptr) {
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700287 pthread_cond_wait(&nti->cv, &nti->mu);
288 }
289 pthread_mutex_unlock(&nti->mu);
290
291 // At this point nti->rss is set, and we own it. The main
292 // thread is waiting for it to disappear from nti.
293 ssize_t written = RangeSinkWrite(data, size, nti->rss);
294 data += written;
295 size -= written;
296
Tao Bao0940fe12015-08-27 16:41:21 -0700297 if (nti->rss->p_block == nti->rss->tgt.count) {
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700298 // we have written all the bytes desired by this rss.
299
300 pthread_mutex_lock(&nti->mu);
Tao Bao0940fe12015-08-27 16:41:21 -0700301 nti->rss = nullptr;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700302 pthread_cond_broadcast(&nti->cv);
303 pthread_mutex_unlock(&nti->mu);
304 }
305 }
306
307 return true;
308}
309
310static void* unzip_new_data(void* cookie) {
311 NewThreadInfo* nti = (NewThreadInfo*) cookie;
312 mzProcessZipEntryContents(nti->za, nti->entry, receive_new_data, nti);
Tao Bao0940fe12015-08-27 16:41:21 -0700313 return nullptr;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -0700314}
315
Tao Bao612336d2015-08-27 16:41:21 -0700316static int ReadBlocks(const RangeSet& src, std::vector<uint8_t>& buffer, int fd) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000317 size_t p = 0;
Tao Bao612336d2015-08-27 16:41:21 -0700318 uint8_t* data = buffer.data();
Sami Tolvanen90221202014-12-09 16:39:47 +0000319
Tao Bao0940fe12015-08-27 16:41:21 -0700320 for (size_t i = 0; i < src.count; ++i) {
321 if (!check_lseek(fd, (off64_t) src.pos[i * 2] * BLOCKSIZE, SEEK_SET)) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000322 return -1;
323 }
324
Tao Bao0940fe12015-08-27 16:41:21 -0700325 size_t size = (src.pos[i * 2 + 1] - src.pos[i * 2]) * BLOCKSIZE;
Sami Tolvanen90221202014-12-09 16:39:47 +0000326
Tao Bao612336d2015-08-27 16:41:21 -0700327 if (read_all(fd, data + p, size) == -1) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000328 return -1;
329 }
330
331 p += size;
332 }
333
334 return 0;
335}
336
Tao Bao612336d2015-08-27 16:41:21 -0700337static int WriteBlocks(const RangeSet& tgt, const std::vector<uint8_t>& buffer, int fd) {
338 const uint8_t* data = buffer.data();
Sami Tolvanen90221202014-12-09 16:39:47 +0000339
Tao Bao0940fe12015-08-27 16:41:21 -0700340 size_t p = 0;
341 for (size_t i = 0; i < tgt.count; ++i) {
342 if (!check_lseek(fd, (off64_t) tgt.pos[i * 2] * BLOCKSIZE, SEEK_SET)) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000343 return -1;
344 }
345
Tao Bao0940fe12015-08-27 16:41:21 -0700346 size_t size = (tgt.pos[i * 2 + 1] - tgt.pos[i * 2]) * BLOCKSIZE;
Sami Tolvanen90221202014-12-09 16:39:47 +0000347
Tao Bao612336d2015-08-27 16:41:21 -0700348 if (write_all(fd, data + p, size) == -1) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000349 return -1;
350 }
351
352 p += size;
353 }
354
355 return 0;
356}
357
Tao Baobaad2d42015-12-06 16:56:27 -0800358// Parameters for transfer list command functions
359struct CommandParameters {
360 std::vector<std::string> tokens;
361 size_t cpos;
362 const char* cmdname;
363 const char* cmdline;
364 std::string freestash;
365 std::string stashbase;
366 bool canwrite;
367 int createdstash;
368 int fd;
369 bool foundwrites;
370 bool isunresumable;
371 int version;
372 size_t written;
373 NewThreadInfo nti;
374 pthread_t thread;
375 std::vector<uint8_t> buffer;
376 uint8_t* patch_start;
377};
378
Doug Zongker52ae67d2014-09-08 12:22:09 -0700379// Do a source/target load for move/bsdiff/imgdiff in version 1.
Tao Baobaad2d42015-12-06 16:56:27 -0800380// We expect to parse the remainder of the parameter tokens as:
Doug Zongker52ae67d2014-09-08 12:22:09 -0700381//
382// <src_range> <tgt_range>
383//
384// The source range is loaded into the provided buffer, reallocating
Tao Bao34847b22015-09-08 11:05:49 -0700385// it to make it larger if necessary.
Doug Zongker52ae67d2014-09-08 12:22:09 -0700386
Tao Baobaad2d42015-12-06 16:56:27 -0800387static int LoadSrcTgtVersion1(CommandParameters& params, RangeSet& tgt, size_t& src_blocks,
Tao Bao612336d2015-08-27 16:41:21 -0700388 std::vector<uint8_t>& buffer, int fd) {
Tao Baobaad2d42015-12-06 16:56:27 -0800389
390 if (params.cpos + 1 >= params.tokens.size()) {
391 fprintf(stderr, "invalid parameters\n");
392 return -1;
393 }
394
Tao Bao612336d2015-08-27 16:41:21 -0700395 // <src_range>
Tao Bao0940fe12015-08-27 16:41:21 -0700396 RangeSet src;
Tao Baobaad2d42015-12-06 16:56:27 -0800397 parse_range(params.tokens[params.cpos++], src);
Doug Zongker52ae67d2014-09-08 12:22:09 -0700398
Tao Bao612336d2015-08-27 16:41:21 -0700399 // <tgt_range>
Tao Baobaad2d42015-12-06 16:56:27 -0800400 parse_range(params.tokens[params.cpos++], tgt);
Doug Zongker52ae67d2014-09-08 12:22:09 -0700401
Tao Bao612336d2015-08-27 16:41:21 -0700402 allocate(src.size * BLOCKSIZE, buffer);
403 int rc = ReadBlocks(src, buffer, fd);
Tao Bao0940fe12015-08-27 16:41:21 -0700404 src_blocks = src.size;
Sami Tolvanen90221202014-12-09 16:39:47 +0000405
Sami Tolvanen90221202014-12-09 16:39:47 +0000406 return rc;
407}
408
Tao Bao612336d2015-08-27 16:41:21 -0700409static int VerifyBlocks(const std::string& expected, const std::vector<uint8_t>& buffer,
Tao Bao0940fe12015-08-27 16:41:21 -0700410 const size_t blocks, bool printerror) {
Sen Jiangc48cb5e2016-02-04 16:23:21 +0800411 uint8_t digest[SHA_DIGEST_LENGTH];
Tao Bao612336d2015-08-27 16:41:21 -0700412 const uint8_t* data = buffer.data();
Sami Tolvanen90221202014-12-09 16:39:47 +0000413
Sen Jiangc48cb5e2016-02-04 16:23:21 +0800414 SHA1(data, blocks * BLOCKSIZE, digest);
Sami Tolvanen90221202014-12-09 16:39:47 +0000415
Tao Baoe6aa3322015-08-05 15:20:27 -0700416 std::string hexdigest = print_sha1(digest);
Sami Tolvanen90221202014-12-09 16:39:47 +0000417
Tao Bao0940fe12015-08-27 16:41:21 -0700418 if (hexdigest != expected) {
419 if (printerror) {
420 fprintf(stderr, "failed to verify blocks (expected %s, read %s)\n",
421 expected.c_str(), hexdigest.c_str());
422 }
423 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000424 }
425
Tao Bao0940fe12015-08-27 16:41:21 -0700426 return 0;
Sami Tolvanen90221202014-12-09 16:39:47 +0000427}
428
Tao Bao0940fe12015-08-27 16:41:21 -0700429static std::string GetStashFileName(const std::string& base, const std::string& id,
430 const std::string& postfix) {
Tao Baoe6aa3322015-08-05 15:20:27 -0700431 if (base.empty()) {
432 return "";
Sami Tolvanen90221202014-12-09 16:39:47 +0000433 }
434
Tao Baoe6aa3322015-08-05 15:20:27 -0700435 std::string fn(STASH_DIRECTORY_BASE);
436 fn += "/" + base + "/" + id + postfix;
Sami Tolvanen90221202014-12-09 16:39:47 +0000437
438 return fn;
439}
440
Tao Baoe6aa3322015-08-05 15:20:27 -0700441typedef void (*StashCallback)(const std::string&, void*);
Sami Tolvanen90221202014-12-09 16:39:47 +0000442
443// Does a best effort enumeration of stash files. Ignores possible non-file
444// items in the stash directory and continues despite of errors. Calls the
445// 'callback' function for each file and passes 'data' to the function as a
446// parameter.
447
Tao Baoe6aa3322015-08-05 15:20:27 -0700448static void EnumerateStash(const std::string& dirname, StashCallback callback, void* data) {
Tao Bao0940fe12015-08-27 16:41:21 -0700449 if (dirname.empty() || callback == nullptr) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000450 return;
451 }
452
Tao Baoe6aa3322015-08-05 15:20:27 -0700453 std::unique_ptr<DIR, int(*)(DIR*)> directory(opendir(dirname.c_str()), closedir);
Sami Tolvanen90221202014-12-09 16:39:47 +0000454
Tao Bao0940fe12015-08-27 16:41:21 -0700455 if (directory == nullptr) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000456 if (errno != ENOENT) {
Tao Baoe6aa3322015-08-05 15:20:27 -0700457 fprintf(stderr, "opendir \"%s\" failed: %s\n", dirname.c_str(), strerror(errno));
Sami Tolvanen90221202014-12-09 16:39:47 +0000458 }
459 return;
460 }
461
Tao Baoe6aa3322015-08-05 15:20:27 -0700462 struct dirent* item;
Tao Bao0940fe12015-08-27 16:41:21 -0700463 while ((item = readdir(directory.get())) != nullptr) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000464 if (item->d_type != DT_REG) {
465 continue;
466 }
467
Tao Baoe6aa3322015-08-05 15:20:27 -0700468 std::string fn = dirname + "/" + std::string(item->d_name);
Sami Tolvanen90221202014-12-09 16:39:47 +0000469 callback(fn, data);
Sami Tolvanen90221202014-12-09 16:39:47 +0000470 }
471}
472
Tao Baoe6aa3322015-08-05 15:20:27 -0700473static void UpdateFileSize(const std::string& fn, void* data) {
474 if (fn.empty() || !data) {
475 return;
476 }
477
Tao Bao0940fe12015-08-27 16:41:21 -0700478 struct stat sb;
479 if (stat(fn.c_str(), &sb) == -1) {
Tao Baoe6aa3322015-08-05 15:20:27 -0700480 fprintf(stderr, "stat \"%s\" failed: %s\n", fn.c_str(), strerror(errno));
Sami Tolvanen90221202014-12-09 16:39:47 +0000481 return;
482 }
483
Tao Baoe6aa3322015-08-05 15:20:27 -0700484 int* size = reinterpret_cast<int*>(data);
Tao Bao0940fe12015-08-27 16:41:21 -0700485 *size += sb.st_size;
Sami Tolvanen90221202014-12-09 16:39:47 +0000486}
487
488// Deletes the stash directory and all files in it. Assumes that it only
489// contains files. There is nothing we can do about unlikely, but possible
490// errors, so they are merely logged.
491
Tao Bao0940fe12015-08-27 16:41:21 -0700492static void DeleteFile(const std::string& fn, void* /* data */) {
Tao Baoe6aa3322015-08-05 15:20:27 -0700493 if (!fn.empty()) {
494 fprintf(stderr, "deleting %s\n", fn.c_str());
Sami Tolvanen90221202014-12-09 16:39:47 +0000495
Tao Baoe6aa3322015-08-05 15:20:27 -0700496 if (unlink(fn.c_str()) == -1 && errno != ENOENT) {
497 fprintf(stderr, "unlink \"%s\" failed: %s\n", fn.c_str(), strerror(errno));
Sami Tolvanen90221202014-12-09 16:39:47 +0000498 }
499 }
500}
501
Tao Baoe6aa3322015-08-05 15:20:27 -0700502static void DeletePartial(const std::string& fn, void* data) {
503 if (android::base::EndsWith(fn, ".partial")) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000504 DeleteFile(fn, data);
505 }
506}
507
Tao Baoe6aa3322015-08-05 15:20:27 -0700508static void DeleteStash(const std::string& base) {
509 if (base.empty()) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000510 return;
511 }
512
Tao Baoe6aa3322015-08-05 15:20:27 -0700513 fprintf(stderr, "deleting stash %s\n", base.c_str());
Sami Tolvanen90221202014-12-09 16:39:47 +0000514
Tao Baoe6aa3322015-08-05 15:20:27 -0700515 std::string dirname = GetStashFileName(base, "", "");
Tao Bao0940fe12015-08-27 16:41:21 -0700516 EnumerateStash(dirname, DeleteFile, nullptr);
Sami Tolvanen90221202014-12-09 16:39:47 +0000517
Tao Baoe6aa3322015-08-05 15:20:27 -0700518 if (rmdir(dirname.c_str()) == -1) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000519 if (errno != ENOENT && errno != ENOTDIR) {
Tao Baoe6aa3322015-08-05 15:20:27 -0700520 fprintf(stderr, "rmdir \"%s\" failed: %s\n", dirname.c_str(), strerror(errno));
Sami Tolvanen90221202014-12-09 16:39:47 +0000521 }
522 }
Sami Tolvanen90221202014-12-09 16:39:47 +0000523}
524
Tao Bao0940fe12015-08-27 16:41:21 -0700525static int LoadStash(const std::string& base, const std::string& id, bool verify, size_t* blocks,
Tao Bao612336d2015-08-27 16:41:21 -0700526 std::vector<uint8_t>& buffer, bool printnoent) {
527 if (base.empty()) {
Tao Bao0940fe12015-08-27 16:41:21 -0700528 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000529 }
530
Tao Bao0940fe12015-08-27 16:41:21 -0700531 size_t blockcount = 0;
532
Sami Tolvanen90221202014-12-09 16:39:47 +0000533 if (!blocks) {
534 blocks = &blockcount;
535 }
536
Tao Bao0940fe12015-08-27 16:41:21 -0700537 std::string fn = GetStashFileName(base, id, "");
Sami Tolvanen90221202014-12-09 16:39:47 +0000538
Tao Bao0940fe12015-08-27 16:41:21 -0700539 struct stat sb;
540 int res = stat(fn.c_str(), &sb);
Sami Tolvanen90221202014-12-09 16:39:47 +0000541
542 if (res == -1) {
543 if (errno != ENOENT || printnoent) {
Tao Baoe6aa3322015-08-05 15:20:27 -0700544 fprintf(stderr, "stat \"%s\" failed: %s\n", fn.c_str(), strerror(errno));
Sami Tolvanen90221202014-12-09 16:39:47 +0000545 }
Tao Bao0940fe12015-08-27 16:41:21 -0700546 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000547 }
548
Tao Baoe6aa3322015-08-05 15:20:27 -0700549 fprintf(stderr, " loading %s\n", fn.c_str());
Sami Tolvanen90221202014-12-09 16:39:47 +0000550
Tao Bao0940fe12015-08-27 16:41:21 -0700551 if ((sb.st_size % BLOCKSIZE) != 0) {
Tao Baoba9a42a2015-06-23 23:23:33 -0700552 fprintf(stderr, "%s size %" PRId64 " not multiple of block size %d",
Tao Bao0940fe12015-08-27 16:41:21 -0700553 fn.c_str(), static_cast<int64_t>(sb.st_size), BLOCKSIZE);
554 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000555 }
556
Jed Estepa7b9a462015-12-15 16:04:53 -0800557 int fd = TEMP_FAILURE_RETRY(ota_open(fn.c_str(), O_RDONLY));
Tao Bao0940fe12015-08-27 16:41:21 -0700558 unique_fd fd_holder(fd);
Sami Tolvanen90221202014-12-09 16:39:47 +0000559
560 if (fd == -1) {
Tao Baoe6aa3322015-08-05 15:20:27 -0700561 fprintf(stderr, "open \"%s\" failed: %s\n", fn.c_str(), strerror(errno));
Tao Bao0940fe12015-08-27 16:41:21 -0700562 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000563 }
564
Tao Bao612336d2015-08-27 16:41:21 -0700565 allocate(sb.st_size, buffer);
Sami Tolvanen90221202014-12-09 16:39:47 +0000566
Tao Bao612336d2015-08-27 16:41:21 -0700567 if (read_all(fd, buffer, sb.st_size) == -1) {
Tao Bao0940fe12015-08-27 16:41:21 -0700568 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000569 }
570
Tao Bao0940fe12015-08-27 16:41:21 -0700571 *blocks = sb.st_size / BLOCKSIZE;
Sami Tolvanen90221202014-12-09 16:39:47 +0000572
Tao Bao612336d2015-08-27 16:41:21 -0700573 if (verify && VerifyBlocks(id, buffer, *blocks, true) != 0) {
Tao Baoe6aa3322015-08-05 15:20:27 -0700574 fprintf(stderr, "unexpected contents in %s\n", fn.c_str());
Tao Bao0940fe12015-08-27 16:41:21 -0700575 DeleteFile(fn, nullptr);
576 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000577 }
578
Tao Bao0940fe12015-08-27 16:41:21 -0700579 return 0;
Sami Tolvanen90221202014-12-09 16:39:47 +0000580}
581
Tao Bao612336d2015-08-27 16:41:21 -0700582static int WriteStash(const std::string& base, const std::string& id, int blocks,
583 std::vector<uint8_t>& buffer, bool checkspace, bool *exists) {
584 if (base.empty()) {
Tao Bao0940fe12015-08-27 16:41:21 -0700585 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000586 }
587
588 if (checkspace && CacheSizeCheck(blocks * BLOCKSIZE) != 0) {
589 fprintf(stderr, "not enough space to write stash\n");
Tao Bao0940fe12015-08-27 16:41:21 -0700590 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000591 }
592
Tao Bao0940fe12015-08-27 16:41:21 -0700593 std::string fn = GetStashFileName(base, id, ".partial");
594 std::string cn = GetStashFileName(base, id, "");
Sami Tolvanen90221202014-12-09 16:39:47 +0000595
Sami Tolvanen43b748f2015-04-17 12:50:31 +0100596 if (exists) {
Tao Bao0940fe12015-08-27 16:41:21 -0700597 struct stat sb;
598 int res = stat(cn.c_str(), &sb);
Sami Tolvanen43b748f2015-04-17 12:50:31 +0100599
600 if (res == 0) {
601 // The file already exists and since the name is the hash of the contents,
602 // it's safe to assume the contents are identical (accidental hash collisions
603 // are unlikely)
Tao Baoe6aa3322015-08-05 15:20:27 -0700604 fprintf(stderr, " skipping %d existing blocks in %s\n", blocks, cn.c_str());
Tao Bao0940fe12015-08-27 16:41:21 -0700605 *exists = true;
606 return 0;
Sami Tolvanen43b748f2015-04-17 12:50:31 +0100607 }
608
Tao Bao0940fe12015-08-27 16:41:21 -0700609 *exists = false;
Sami Tolvanen43b748f2015-04-17 12:50:31 +0100610 }
611
Tao Baoe6aa3322015-08-05 15:20:27 -0700612 fprintf(stderr, " writing %d blocks to %s\n", blocks, cn.c_str());
Sami Tolvanen90221202014-12-09 16:39:47 +0000613
Jed Estepa7b9a462015-12-15 16:04:53 -0800614 int fd = TEMP_FAILURE_RETRY(ota_open(fn.c_str(), O_WRONLY | O_CREAT | O_TRUNC, STASH_FILE_MODE));
Tao Bao0940fe12015-08-27 16:41:21 -0700615 unique_fd fd_holder(fd);
Sami Tolvanen90221202014-12-09 16:39:47 +0000616
617 if (fd == -1) {
Tao Baoe6aa3322015-08-05 15:20:27 -0700618 fprintf(stderr, "failed to create \"%s\": %s\n", fn.c_str(), strerror(errno));
Tao Bao0940fe12015-08-27 16:41:21 -0700619 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000620 }
621
622 if (write_all(fd, buffer, blocks * BLOCKSIZE) == -1) {
Tao Bao0940fe12015-08-27 16:41:21 -0700623 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000624 }
625
Jed Estepa7b9a462015-12-15 16:04:53 -0800626 if (ota_fsync(fd) == -1) {
Tao Baoe6aa3322015-08-05 15:20:27 -0700627 fprintf(stderr, "fsync \"%s\" failed: %s\n", fn.c_str(), strerror(errno));
Tao Bao0940fe12015-08-27 16:41:21 -0700628 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000629 }
630
Tao Baoe6aa3322015-08-05 15:20:27 -0700631 if (rename(fn.c_str(), cn.c_str()) == -1) {
632 fprintf(stderr, "rename(\"%s\", \"%s\") failed: %s\n", fn.c_str(), cn.c_str(),
633 strerror(errno));
Tao Bao0940fe12015-08-27 16:41:21 -0700634 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000635 }
636
Tao Bao0940fe12015-08-27 16:41:21 -0700637 std::string dname = GetStashFileName(base, "", "");
Jed Estepa7b9a462015-12-15 16:04:53 -0800638 int dfd = TEMP_FAILURE_RETRY(ota_open(dname.c_str(), O_RDONLY | O_DIRECTORY));
Tao Bao0940fe12015-08-27 16:41:21 -0700639 unique_fd dfd_holder(dfd);
Tao Baodc392262015-07-31 15:56:44 -0700640
641 if (dfd == -1) {
Tao Baoe6aa3322015-08-05 15:20:27 -0700642 fprintf(stderr, "failed to open \"%s\" failed: %s\n", dname.c_str(), strerror(errno));
Tao Bao0940fe12015-08-27 16:41:21 -0700643 return -1;
Tao Baodc392262015-07-31 15:56:44 -0700644 }
645
Jed Estepa7b9a462015-12-15 16:04:53 -0800646 if (ota_fsync(dfd) == -1) {
Tao Baoe6aa3322015-08-05 15:20:27 -0700647 fprintf(stderr, "fsync \"%s\" failed: %s\n", dname.c_str(), strerror(errno));
Tao Bao0940fe12015-08-27 16:41:21 -0700648 return -1;
Tao Baodc392262015-07-31 15:56:44 -0700649 }
650
Tao Bao0940fe12015-08-27 16:41:21 -0700651 return 0;
Sami Tolvanen90221202014-12-09 16:39:47 +0000652}
653
654// Creates a directory for storing stash files and checks if the /cache partition
655// hash enough space for the expected amount of blocks we need to store. Returns
656// >0 if we created the directory, zero if it existed already, and <0 of failure.
657
Tao Bao0940fe12015-08-27 16:41:21 -0700658static int CreateStash(State* state, int maxblocks, const char* blockdev, std::string& base) {
659 if (blockdev == nullptr) {
Tao Baoe6aa3322015-08-05 15:20:27 -0700660 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000661 }
662
663 // Stash directory should be different for each partition to avoid conflicts
664 // when updating multiple partitions at the same time, so we use the hash of
665 // the block device name as the base directory
Sen Jiangc48cb5e2016-02-04 16:23:21 +0800666 uint8_t digest[SHA_DIGEST_LENGTH];
667 SHA1(reinterpret_cast<const uint8_t*>(blockdev), strlen(blockdev), digest);
Tao Baoe6aa3322015-08-05 15:20:27 -0700668 base = print_sha1(digest);
Sami Tolvanen90221202014-12-09 16:39:47 +0000669
Tao Baoe6aa3322015-08-05 15:20:27 -0700670 std::string dirname = GetStashFileName(base, "", "");
Tao Bao0940fe12015-08-27 16:41:21 -0700671 struct stat sb;
672 int res = stat(dirname.c_str(), &sb);
Sami Tolvanen90221202014-12-09 16:39:47 +0000673
674 if (res == -1 && errno != ENOENT) {
Tao Baoe6aa3322015-08-05 15:20:27 -0700675 ErrorAbort(state, "stat \"%s\" failed: %s\n", dirname.c_str(), strerror(errno));
676 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000677 } else if (res != 0) {
Tao Baoe6aa3322015-08-05 15:20:27 -0700678 fprintf(stderr, "creating stash %s\n", dirname.c_str());
679 res = mkdir(dirname.c_str(), STASH_DIRECTORY_MODE);
Sami Tolvanen90221202014-12-09 16:39:47 +0000680
681 if (res != 0) {
Tao Baoe6aa3322015-08-05 15:20:27 -0700682 ErrorAbort(state, "mkdir \"%s\" failed: %s\n", dirname.c_str(), strerror(errno));
683 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000684 }
685
686 if (CacheSizeCheck(maxblocks * BLOCKSIZE) != 0) {
687 ErrorAbort(state, "not enough space for stash\n");
Tao Baoe6aa3322015-08-05 15:20:27 -0700688 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000689 }
690
Tao Baoe6aa3322015-08-05 15:20:27 -0700691 return 1; // Created directory
Sami Tolvanen90221202014-12-09 16:39:47 +0000692 }
693
Tao Baoe6aa3322015-08-05 15:20:27 -0700694 fprintf(stderr, "using existing stash %s\n", dirname.c_str());
Sami Tolvanen90221202014-12-09 16:39:47 +0000695
696 // If the directory already exists, calculate the space already allocated to
697 // stash files and check if there's enough for all required blocks. Delete any
698 // partially completed stash files first.
699
Tao Bao0940fe12015-08-27 16:41:21 -0700700 EnumerateStash(dirname, DeletePartial, nullptr);
Tao Baoe6aa3322015-08-05 15:20:27 -0700701 int size = 0;
Sami Tolvanen90221202014-12-09 16:39:47 +0000702 EnumerateStash(dirname, UpdateFileSize, &size);
703
Tao Bao0940fe12015-08-27 16:41:21 -0700704 size = maxblocks * BLOCKSIZE - size;
Sami Tolvanen90221202014-12-09 16:39:47 +0000705
706 if (size > 0 && CacheSizeCheck(size) != 0) {
707 ErrorAbort(state, "not enough space for stash (%d more needed)\n", size);
Tao Baoe6aa3322015-08-05 15:20:27 -0700708 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000709 }
710
Tao Baoe6aa3322015-08-05 15:20:27 -0700711 return 0; // Using existing directory
Sami Tolvanen90221202014-12-09 16:39:47 +0000712}
713
Tao Baobaad2d42015-12-06 16:56:27 -0800714static int SaveStash(CommandParameters& params, const std::string& base,
715 std::vector<uint8_t>& buffer, int fd, bool usehash) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000716
Tao Baobaad2d42015-12-06 16:56:27 -0800717 // <stash_id> <src_range>
718 if (params.cpos + 1 >= params.tokens.size()) {
719 fprintf(stderr, "missing id and/or src range fields in stash command\n");
Sami Tolvanen90221202014-12-09 16:39:47 +0000720 return -1;
721 }
Tao Baobaad2d42015-12-06 16:56:27 -0800722 const std::string& id = params.tokens[params.cpos++];
Sami Tolvanen90221202014-12-09 16:39:47 +0000723
Tao Bao0940fe12015-08-27 16:41:21 -0700724 size_t blocks = 0;
Tao Bao612336d2015-08-27 16:41:21 -0700725 if (usehash && LoadStash(base, id, true, &blocks, buffer, false) == 0) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000726 // Stash file already exists and has expected contents. Do not
727 // read from source again, as the source may have been already
728 // overwritten during a previous attempt.
729 return 0;
730 }
731
Tao Bao34847b22015-09-08 11:05:49 -0700732 RangeSet src;
Tao Baobaad2d42015-12-06 16:56:27 -0800733 parse_range(params.tokens[params.cpos++], src);
Tao Bao34847b22015-09-08 11:05:49 -0700734
Tao Bao612336d2015-08-27 16:41:21 -0700735 allocate(src.size * BLOCKSIZE, buffer);
736 if (ReadBlocks(src, buffer, fd) == -1) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000737 return -1;
738 }
Tao Bao34847b22015-09-08 11:05:49 -0700739 blocks = src.size;
Sami Tolvanen90221202014-12-09 16:39:47 +0000740
Tao Bao612336d2015-08-27 16:41:21 -0700741 if (usehash && VerifyBlocks(id, buffer, blocks, true) != 0) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000742 // Source blocks have unexpected contents. If we actually need this
743 // data later, this is an unrecoverable error. However, the command
744 // that uses the data may have already completed previously, so the
745 // possible failure will occur during source block verification.
Tao Bao0940fe12015-08-27 16:41:21 -0700746 fprintf(stderr, "failed to load source blocks for stash %s\n", id.c_str());
Sami Tolvanen90221202014-12-09 16:39:47 +0000747 return 0;
748 }
749
Tao Bao0940fe12015-08-27 16:41:21 -0700750 fprintf(stderr, "stashing %zu blocks to %s\n", blocks, id.c_str());
Tao Bao612336d2015-08-27 16:41:21 -0700751 return WriteStash(base, id, blocks, buffer, false, nullptr);
Sami Tolvanen90221202014-12-09 16:39:47 +0000752}
753
Tao Baobaad2d42015-12-06 16:56:27 -0800754static int FreeStash(const std::string& base, const std::string& id) {
755 if (base.empty() || id.empty()) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000756 return -1;
757 }
758
Tao Baobaad2d42015-12-06 16:56:27 -0800759 std::string fn = GetStashFileName(base, id, "");
Tao Bao0940fe12015-08-27 16:41:21 -0700760 DeleteFile(fn, nullptr);
Sami Tolvanen90221202014-12-09 16:39:47 +0000761
762 return 0;
Doug Zongker52ae67d2014-09-08 12:22:09 -0700763}
764
Tao Bao612336d2015-08-27 16:41:21 -0700765static void MoveRange(std::vector<uint8_t>& dest, const RangeSet& locs,
766 const std::vector<uint8_t>& source) {
Doug Zongker52ae67d2014-09-08 12:22:09 -0700767 // source contains packed data, which we want to move to the
Tao Bao612336d2015-08-27 16:41:21 -0700768 // locations given in locs in the dest buffer. source and dest
Doug Zongker52ae67d2014-09-08 12:22:09 -0700769 // may be the same buffer.
770
Tao Bao612336d2015-08-27 16:41:21 -0700771 const uint8_t* from = source.data();
772 uint8_t* to = dest.data();
Tao Bao0940fe12015-08-27 16:41:21 -0700773 size_t start = locs.size;
774 for (int i = locs.count-1; i >= 0; --i) {
775 size_t blocks = locs.pos[i*2+1] - locs.pos[i*2];
Doug Zongker52ae67d2014-09-08 12:22:09 -0700776 start -= blocks;
Tao Bao612336d2015-08-27 16:41:21 -0700777 memmove(to + (locs.pos[i*2] * BLOCKSIZE), from + (start * BLOCKSIZE),
Doug Zongker52ae67d2014-09-08 12:22:09 -0700778 blocks * BLOCKSIZE);
779 }
780}
781
782// Do a source/target load for move/bsdiff/imgdiff in version 2.
Tao Baobaad2d42015-12-06 16:56:27 -0800783// We expect to parse the remainder of the parameter tokens as one of:
Doug Zongker52ae67d2014-09-08 12:22:09 -0700784//
785// <tgt_range> <src_block_count> <src_range>
786// (loads data from source image only)
787//
788// <tgt_range> <src_block_count> - <[stash_id:stash_range] ...>
789// (loads data from stashes only)
790//
791// <tgt_range> <src_block_count> <src_range> <src_loc> <[stash_id:stash_range] ...>
792// (loads data from both source image and stashes)
793//
794// On return, buffer is filled with the loaded source data (rearranged
795// and combined with stashed data as necessary). buffer may be
796// reallocated if needed to accommodate the source data. *tgt is the
Sami Tolvanen90221202014-12-09 16:39:47 +0000797// target RangeSet. Any stashes required are loaded using LoadStash.
Doug Zongker52ae67d2014-09-08 12:22:09 -0700798
Tao Baobaad2d42015-12-06 16:56:27 -0800799static int LoadSrcTgtVersion2(CommandParameters& params, RangeSet& tgt, size_t& src_blocks,
Tao Bao612336d2015-08-27 16:41:21 -0700800 std::vector<uint8_t>& buffer, int fd, const std::string& stashbase, bool* overlap) {
Tao Baobaad2d42015-12-06 16:56:27 -0800801
802 // At least it needs to provide three parameters: <tgt_range>,
803 // <src_block_count> and "-"/<src_range>.
804 if (params.cpos + 2 >= params.tokens.size()) {
805 fprintf(stderr, "invalid parameters\n");
806 return -1;
807 }
808
Tao Bao612336d2015-08-27 16:41:21 -0700809 // <tgt_range>
Tao Baobaad2d42015-12-06 16:56:27 -0800810 parse_range(params.tokens[params.cpos++], tgt);
Doug Zongker52ae67d2014-09-08 12:22:09 -0700811
Tao Bao612336d2015-08-27 16:41:21 -0700812 // <src_block_count>
Tao Baobaad2d42015-12-06 16:56:27 -0800813 const std::string& token = params.tokens[params.cpos++];
814 if (!android::base::ParseUint(token.c_str(), &src_blocks)) {
815 fprintf(stderr, "invalid src_block_count \"%s\"\n", token.c_str());
816 return -1;
817 }
Doug Zongker52ae67d2014-09-08 12:22:09 -0700818
Tao Bao612336d2015-08-27 16:41:21 -0700819 allocate(src_blocks * BLOCKSIZE, buffer);
Doug Zongker52ae67d2014-09-08 12:22:09 -0700820
Tao Bao612336d2015-08-27 16:41:21 -0700821 // "-" or <src_range> [<src_loc>]
Tao Baobaad2d42015-12-06 16:56:27 -0800822 if (params.tokens[params.cpos] == "-") {
Doug Zongker52ae67d2014-09-08 12:22:09 -0700823 // no source ranges, only stashes
Tao Baobaad2d42015-12-06 16:56:27 -0800824 params.cpos++;
Doug Zongker52ae67d2014-09-08 12:22:09 -0700825 } else {
Tao Bao0940fe12015-08-27 16:41:21 -0700826 RangeSet src;
Tao Baobaad2d42015-12-06 16:56:27 -0800827 parse_range(params.tokens[params.cpos++], src);
Tao Bao612336d2015-08-27 16:41:21 -0700828 int res = ReadBlocks(src, buffer, fd);
Doug Zongker52ae67d2014-09-08 12:22:09 -0700829
Tao Bao34847b22015-09-08 11:05:49 -0700830 if (overlap) {
831 *overlap = range_overlaps(src, tgt);
Doug Zongker52ae67d2014-09-08 12:22:09 -0700832 }
Sami Tolvanen90221202014-12-09 16:39:47 +0000833
Sami Tolvanen90221202014-12-09 16:39:47 +0000834 if (res == -1) {
835 return -1;
Doug Zongker52ae67d2014-09-08 12:22:09 -0700836 }
837
Tao Baobaad2d42015-12-06 16:56:27 -0800838 if (params.cpos >= params.tokens.size()) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000839 // no stashes, only source range
840 return 0;
841 }
842
Tao Bao612336d2015-08-27 16:41:21 -0700843 RangeSet locs;
Tao Baobaad2d42015-12-06 16:56:27 -0800844 parse_range(params.tokens[params.cpos++], locs);
Tao Bao612336d2015-08-27 16:41:21 -0700845 MoveRange(buffer, locs, buffer);
Doug Zongker52ae67d2014-09-08 12:22:09 -0700846 }
847
Tao Baobaad2d42015-12-06 16:56:27 -0800848 // <[stash_id:stash_range]>
849 while (params.cpos < params.tokens.size()) {
Doug Zongker52ae67d2014-09-08 12:22:09 -0700850 // Each word is a an index into the stash table, a colon, and
851 // then a rangeset describing where in the source block that
852 // stashed data should go.
Tao Baobaad2d42015-12-06 16:56:27 -0800853 std::vector<std::string> tokens = android::base::Split(params.tokens[params.cpos++], ":");
854 if (tokens.size() != 2) {
855 fprintf(stderr, "invalid parameter\n");
856 return -1;
857 }
Sami Tolvanen90221202014-12-09 16:39:47 +0000858
Tao Bao612336d2015-08-27 16:41:21 -0700859 std::vector<uint8_t> stash;
Tao Baobaad2d42015-12-06 16:56:27 -0800860 int res = LoadStash(stashbase, tokens[0], false, nullptr, stash, true);
Sami Tolvanen90221202014-12-09 16:39:47 +0000861
862 if (res == -1) {
863 // These source blocks will fail verification if used later, but we
864 // will let the caller decide if this is a fatal failure
Tao Baobaad2d42015-12-06 16:56:27 -0800865 fprintf(stderr, "failed to load stash %s\n", tokens[0].c_str());
Sami Tolvanen90221202014-12-09 16:39:47 +0000866 continue;
867 }
868
Tao Bao612336d2015-08-27 16:41:21 -0700869 RangeSet locs;
Tao Baobaad2d42015-12-06 16:56:27 -0800870 parse_range(tokens[1], locs);
Sami Tolvanen90221202014-12-09 16:39:47 +0000871
Tao Bao612336d2015-08-27 16:41:21 -0700872 MoveRange(buffer, locs, stash);
Sami Tolvanen90221202014-12-09 16:39:47 +0000873 }
874
875 return 0;
876}
877
Sami Tolvanen90221202014-12-09 16:39:47 +0000878// Do a source/target load for move/bsdiff/imgdiff in version 3.
879//
880// Parameters are the same as for LoadSrcTgtVersion2, except for 'onehash', which
881// tells the function whether to expect separate source and targe block hashes, or
882// if they are both the same and only one hash should be expected, and
883// 'isunresumable', which receives a non-zero value if block verification fails in
884// a way that the update cannot be resumed anymore.
885//
886// If the function is unable to load the necessary blocks or their contents don't
887// match the hashes, the return value is -1 and the command should be aborted.
888//
889// If the return value is 1, the command has already been completed according to
890// the contents of the target blocks, and should not be performed again.
891//
892// If the return value is 0, source blocks have expected content and the command
893// can be performed.
894
Tao Bao34847b22015-09-08 11:05:49 -0700895static int LoadSrcTgtVersion3(CommandParameters& params, RangeSet& tgt, size_t& src_blocks,
Tao Bao0940fe12015-08-27 16:41:21 -0700896 bool onehash, bool& overlap) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000897
Tao Baobaad2d42015-12-06 16:56:27 -0800898 if (params.cpos >= params.tokens.size()) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000899 fprintf(stderr, "missing source hash\n");
Tao Bao0940fe12015-08-27 16:41:21 -0700900 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000901 }
902
Tao Baobaad2d42015-12-06 16:56:27 -0800903 std::string srchash = params.tokens[params.cpos++];
904 std::string tgthash;
905
Sami Tolvanen90221202014-12-09 16:39:47 +0000906 if (onehash) {
907 tgthash = srchash;
908 } else {
Tao Baobaad2d42015-12-06 16:56:27 -0800909 if (params.cpos >= params.tokens.size()) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000910 fprintf(stderr, "missing target hash\n");
Tao Bao0940fe12015-08-27 16:41:21 -0700911 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000912 }
Tao Baobaad2d42015-12-06 16:56:27 -0800913 tgthash = params.tokens[params.cpos++];
Sami Tolvanen90221202014-12-09 16:39:47 +0000914 }
915
Tao Baobaad2d42015-12-06 16:56:27 -0800916 if (LoadSrcTgtVersion2(params, tgt, src_blocks, params.buffer, params.fd, params.stashbase,
917 &overlap) == -1) {
Tao Bao0940fe12015-08-27 16:41:21 -0700918 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000919 }
920
Tao Bao34847b22015-09-08 11:05:49 -0700921 std::vector<uint8_t> tgtbuffer(tgt.size * BLOCKSIZE);
Sami Tolvanen90221202014-12-09 16:39:47 +0000922
Tao Bao612336d2015-08-27 16:41:21 -0700923 if (ReadBlocks(tgt, tgtbuffer, params.fd) == -1) {
Tao Bao0940fe12015-08-27 16:41:21 -0700924 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000925 }
926
Tao Bao612336d2015-08-27 16:41:21 -0700927 if (VerifyBlocks(tgthash, tgtbuffer, tgt.size, false) == 0) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000928 // Target blocks already have expected content, command should be skipped
Tao Bao0940fe12015-08-27 16:41:21 -0700929 return 1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000930 }
931
Tao Bao0940fe12015-08-27 16:41:21 -0700932 if (VerifyBlocks(srchash, params.buffer, src_blocks, true) == 0) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000933 // If source and target blocks overlap, stash the source blocks so we can
934 // resume from possible write errors
Tao Bao0940fe12015-08-27 16:41:21 -0700935 if (overlap) {
Tao Baobaad2d42015-12-06 16:56:27 -0800936 fprintf(stderr, "stashing %zu overlapping blocks to %s\n", src_blocks,
937 srchash.c_str());
Sami Tolvanen90221202014-12-09 16:39:47 +0000938
Tao Bao0940fe12015-08-27 16:41:21 -0700939 bool stash_exists = false;
Tao Bao612336d2015-08-27 16:41:21 -0700940 if (WriteStash(params.stashbase, srchash, src_blocks, params.buffer, true,
Tao Bao0940fe12015-08-27 16:41:21 -0700941 &stash_exists) != 0) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000942 fprintf(stderr, "failed to stash overlapping source blocks\n");
Tao Bao0940fe12015-08-27 16:41:21 -0700943 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000944 }
945
946 // Can be deleted when the write has completed
Sami Tolvanen43b748f2015-04-17 12:50:31 +0100947 if (!stash_exists) {
Tao Bao0940fe12015-08-27 16:41:21 -0700948 params.freestash = srchash;
Sami Tolvanen43b748f2015-04-17 12:50:31 +0100949 }
Sami Tolvanen90221202014-12-09 16:39:47 +0000950 }
951
952 // Source blocks have expected content, command can proceed
Tao Bao0940fe12015-08-27 16:41:21 -0700953 return 0;
Sami Tolvanen90221202014-12-09 16:39:47 +0000954 }
955
Tao Bao612336d2015-08-27 16:41:21 -0700956 if (overlap && LoadStash(params.stashbase, srchash, true, nullptr, params.buffer, true) == 0) {
Sami Tolvanen43b748f2015-04-17 12:50:31 +0100957 // Overlapping source blocks were previously stashed, command can proceed.
958 // We are recovering from an interrupted command, so we don't know if the
959 // stash can safely be deleted after this command.
Tao Bao0940fe12015-08-27 16:41:21 -0700960 return 0;
Sami Tolvanen90221202014-12-09 16:39:47 +0000961 }
962
963 // Valid source data not available, update cannot be resumed
964 fprintf(stderr, "partition has unexpected contents\n");
Tao Bao0940fe12015-08-27 16:41:21 -0700965 params.isunresumable = true;
Sami Tolvanen90221202014-12-09 16:39:47 +0000966
Tao Bao0940fe12015-08-27 16:41:21 -0700967 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000968}
969
Tao Bao0940fe12015-08-27 16:41:21 -0700970static int PerformCommandMove(CommandParameters& params) {
971 size_t blocks = 0;
Tao Baoe6aa3322015-08-05 15:20:27 -0700972 bool overlap = false;
Sami Tolvanen90221202014-12-09 16:39:47 +0000973 int status = 0;
Tao Bao0940fe12015-08-27 16:41:21 -0700974 RangeSet tgt;
Sami Tolvanen90221202014-12-09 16:39:47 +0000975
Tao Bao0940fe12015-08-27 16:41:21 -0700976 if (params.version == 1) {
Tao Baobaad2d42015-12-06 16:56:27 -0800977 status = LoadSrcTgtVersion1(params, tgt, blocks, params.buffer, params.fd);
Tao Bao0940fe12015-08-27 16:41:21 -0700978 } else if (params.version == 2) {
Tao Baobaad2d42015-12-06 16:56:27 -0800979 status = LoadSrcTgtVersion2(params, tgt, blocks, params.buffer, params.fd,
Tao Bao612336d2015-08-27 16:41:21 -0700980 params.stashbase, nullptr);
Tao Bao0940fe12015-08-27 16:41:21 -0700981 } else if (params.version >= 3) {
Tao Bao34847b22015-09-08 11:05:49 -0700982 status = LoadSrcTgtVersion3(params, tgt, blocks, true, overlap);
Sami Tolvanen90221202014-12-09 16:39:47 +0000983 }
984
985 if (status == -1) {
986 fprintf(stderr, "failed to read blocks for move\n");
Tao Bao0940fe12015-08-27 16:41:21 -0700987 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +0000988 }
989
990 if (status == 0) {
Tao Bao0940fe12015-08-27 16:41:21 -0700991 params.foundwrites = true;
992 } else if (params.foundwrites) {
993 fprintf(stderr, "warning: commands executed out of order [%s]\n", params.cmdname);
Sami Tolvanen90221202014-12-09 16:39:47 +0000994 }
995
Tao Bao0940fe12015-08-27 16:41:21 -0700996 if (params.canwrite) {
Sami Tolvanen90221202014-12-09 16:39:47 +0000997 if (status == 0) {
Tao Bao0940fe12015-08-27 16:41:21 -0700998 fprintf(stderr, " moving %zu blocks\n", blocks);
Sami Tolvanen90221202014-12-09 16:39:47 +0000999
Tao Bao0940fe12015-08-27 16:41:21 -07001000 if (WriteBlocks(tgt, params.buffer, params.fd) == -1) {
1001 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001002 }
1003 } else {
Tao Bao0940fe12015-08-27 16:41:21 -07001004 fprintf(stderr, "skipping %zu already moved blocks\n", blocks);
Sami Tolvanen90221202014-12-09 16:39:47 +00001005 }
1006
1007 }
1008
Tao Baobaad2d42015-12-06 16:56:27 -08001009 if (!params.freestash.empty()) {
Tao Bao0940fe12015-08-27 16:41:21 -07001010 FreeStash(params.stashbase, params.freestash);
Tao Baobaad2d42015-12-06 16:56:27 -08001011 params.freestash.clear();
Sami Tolvanen90221202014-12-09 16:39:47 +00001012 }
1013
Tao Bao0940fe12015-08-27 16:41:21 -07001014 params.written += tgt.size;
Sami Tolvanen90221202014-12-09 16:39:47 +00001015
Tao Bao0940fe12015-08-27 16:41:21 -07001016 return 0;
Sami Tolvanen90221202014-12-09 16:39:47 +00001017}
1018
Tao Bao0940fe12015-08-27 16:41:21 -07001019static int PerformCommandStash(CommandParameters& params) {
Tao Baobaad2d42015-12-06 16:56:27 -08001020 return SaveStash(params, params.stashbase, params.buffer, params.fd,
Tao Bao612336d2015-08-27 16:41:21 -07001021 (params.version >= 3));
Sami Tolvanen90221202014-12-09 16:39:47 +00001022}
1023
Tao Bao0940fe12015-08-27 16:41:21 -07001024static int PerformCommandFree(CommandParameters& params) {
Tao Baobaad2d42015-12-06 16:56:27 -08001025 // <stash_id>
1026 if (params.cpos >= params.tokens.size()) {
1027 fprintf(stderr, "missing stash id in free command\n");
1028 return -1;
1029 }
1030
Tao Bao0940fe12015-08-27 16:41:21 -07001031 if (params.createdstash || params.canwrite) {
Tao Baobaad2d42015-12-06 16:56:27 -08001032 return FreeStash(params.stashbase, params.tokens[params.cpos++]);
Sami Tolvanen90221202014-12-09 16:39:47 +00001033 }
1034
1035 return 0;
1036}
1037
Tao Bao0940fe12015-08-27 16:41:21 -07001038static int PerformCommandZero(CommandParameters& params) {
Sami Tolvanen90221202014-12-09 16:39:47 +00001039
Tao Baobaad2d42015-12-06 16:56:27 -08001040 if (params.cpos >= params.tokens.size()) {
Sami Tolvanen90221202014-12-09 16:39:47 +00001041 fprintf(stderr, "missing target blocks for zero\n");
Tao Bao0940fe12015-08-27 16:41:21 -07001042 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001043 }
1044
Tao Bao0940fe12015-08-27 16:41:21 -07001045 RangeSet tgt;
Tao Baobaad2d42015-12-06 16:56:27 -08001046 parse_range(params.tokens[params.cpos++], tgt);
Sami Tolvanen90221202014-12-09 16:39:47 +00001047
Tao Bao0940fe12015-08-27 16:41:21 -07001048 fprintf(stderr, " zeroing %zu blocks\n", tgt.size);
Sami Tolvanen90221202014-12-09 16:39:47 +00001049
Tao Bao612336d2015-08-27 16:41:21 -07001050 allocate(BLOCKSIZE, params.buffer);
1051 memset(params.buffer.data(), 0, BLOCKSIZE);
Sami Tolvanen90221202014-12-09 16:39:47 +00001052
Tao Bao0940fe12015-08-27 16:41:21 -07001053 if (params.canwrite) {
1054 for (size_t i = 0; i < tgt.count; ++i) {
1055 if (!check_lseek(params.fd, (off64_t) tgt.pos[i * 2] * BLOCKSIZE, SEEK_SET)) {
1056 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001057 }
1058
Tao Bao0940fe12015-08-27 16:41:21 -07001059 for (size_t j = tgt.pos[i * 2]; j < tgt.pos[i * 2 + 1]; ++j) {
1060 if (write_all(params.fd, params.buffer, BLOCKSIZE) == -1) {
1061 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001062 }
1063 }
1064 }
1065 }
1066
Tao Bao0940fe12015-08-27 16:41:21 -07001067 if (params.cmdname[0] == 'z') {
Sami Tolvanene82fa182015-06-10 15:58:12 +00001068 // Update only for the zero command, as the erase command will call
1069 // this if DEBUG_ERASE is defined.
Tao Bao0940fe12015-08-27 16:41:21 -07001070 params.written += tgt.size;
Sami Tolvanen90221202014-12-09 16:39:47 +00001071 }
1072
Tao Bao0940fe12015-08-27 16:41:21 -07001073 return 0;
Sami Tolvanen90221202014-12-09 16:39:47 +00001074}
1075
Tao Bao0940fe12015-08-27 16:41:21 -07001076static int PerformCommandNew(CommandParameters& params) {
Sami Tolvanen90221202014-12-09 16:39:47 +00001077
Tao Baobaad2d42015-12-06 16:56:27 -08001078 if (params.cpos >= params.tokens.size()) {
1079 fprintf(stderr, "missing target blocks for new\n");
Tao Bao0940fe12015-08-27 16:41:21 -07001080 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001081 }
1082
Tao Bao0940fe12015-08-27 16:41:21 -07001083 RangeSet tgt;
Tao Baobaad2d42015-12-06 16:56:27 -08001084 parse_range(params.tokens[params.cpos++], tgt);
Sami Tolvanen90221202014-12-09 16:39:47 +00001085
Tao Bao0940fe12015-08-27 16:41:21 -07001086 if (params.canwrite) {
1087 fprintf(stderr, " writing %zu blocks of new data\n", tgt.size);
Sami Tolvanen90221202014-12-09 16:39:47 +00001088
Tao Bao0940fe12015-08-27 16:41:21 -07001089 RangeSinkState rss(tgt);
1090 rss.fd = params.fd;
Sami Tolvanen90221202014-12-09 16:39:47 +00001091 rss.p_block = 0;
Tao Bao0940fe12015-08-27 16:41:21 -07001092 rss.p_remain = (tgt.pos[1] - tgt.pos[0]) * BLOCKSIZE;
Sami Tolvanen90221202014-12-09 16:39:47 +00001093
Tao Bao0940fe12015-08-27 16:41:21 -07001094 if (!check_lseek(params.fd, (off64_t) tgt.pos[0] * BLOCKSIZE, SEEK_SET)) {
1095 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001096 }
1097
Tao Bao0940fe12015-08-27 16:41:21 -07001098 pthread_mutex_lock(&params.nti.mu);
1099 params.nti.rss = &rss;
1100 pthread_cond_broadcast(&params.nti.cv);
Sami Tolvanen90221202014-12-09 16:39:47 +00001101
Tao Bao0940fe12015-08-27 16:41:21 -07001102 while (params.nti.rss) {
1103 pthread_cond_wait(&params.nti.cv, &params.nti.mu);
Sami Tolvanen90221202014-12-09 16:39:47 +00001104 }
1105
Tao Bao0940fe12015-08-27 16:41:21 -07001106 pthread_mutex_unlock(&params.nti.mu);
Sami Tolvanen90221202014-12-09 16:39:47 +00001107 }
1108
Tao Bao0940fe12015-08-27 16:41:21 -07001109 params.written += tgt.size;
Sami Tolvanen90221202014-12-09 16:39:47 +00001110
Tao Bao0940fe12015-08-27 16:41:21 -07001111 return 0;
Sami Tolvanen90221202014-12-09 16:39:47 +00001112}
1113
Tao Bao0940fe12015-08-27 16:41:21 -07001114static int PerformCommandDiff(CommandParameters& params) {
Tao Bao0940fe12015-08-27 16:41:21 -07001115
Tao Baobaad2d42015-12-06 16:56:27 -08001116 // <offset> <length>
1117 if (params.cpos + 1 >= params.tokens.size()) {
1118 fprintf(stderr, "missing patch offset or length for %s\n", params.cmdname);
Tao Bao0940fe12015-08-27 16:41:21 -07001119 return -1;
1120 }
1121
Tao Baobaad2d42015-12-06 16:56:27 -08001122 size_t offset;
1123 if (!android::base::ParseUint(params.tokens[params.cpos++].c_str(), &offset)) {
1124 fprintf(stderr, "invalid patch offset\n");
Tao Bao0940fe12015-08-27 16:41:21 -07001125 return -1;
1126 }
1127
Tao Baobaad2d42015-12-06 16:56:27 -08001128 size_t len;
1129 if (!android::base::ParseUint(params.tokens[params.cpos++].c_str(), &len)) {
1130 fprintf(stderr, "invalid patch offset\n");
1131 return -1;
1132 }
Tao Bao0940fe12015-08-27 16:41:21 -07001133
Tao Bao612336d2015-08-27 16:41:21 -07001134 RangeSet tgt;
Tao Bao0940fe12015-08-27 16:41:21 -07001135 size_t blocks = 0;
Tao Bao612336d2015-08-27 16:41:21 -07001136 bool overlap = false;
Sami Tolvanen90221202014-12-09 16:39:47 +00001137 int status = 0;
Tao Bao0940fe12015-08-27 16:41:21 -07001138 if (params.version == 1) {
Tao Baobaad2d42015-12-06 16:56:27 -08001139 status = LoadSrcTgtVersion1(params, tgt, blocks, params.buffer, params.fd);
Tao Bao0940fe12015-08-27 16:41:21 -07001140 } else if (params.version == 2) {
Tao Baobaad2d42015-12-06 16:56:27 -08001141 status = LoadSrcTgtVersion2(params, tgt, blocks, params.buffer, params.fd,
Tao Bao612336d2015-08-27 16:41:21 -07001142 params.stashbase, nullptr);
Tao Bao0940fe12015-08-27 16:41:21 -07001143 } else if (params.version >= 3) {
Tao Bao34847b22015-09-08 11:05:49 -07001144 status = LoadSrcTgtVersion3(params, tgt, blocks, false, overlap);
Sami Tolvanen90221202014-12-09 16:39:47 +00001145 }
1146
1147 if (status == -1) {
1148 fprintf(stderr, "failed to read blocks for diff\n");
Tao Bao0940fe12015-08-27 16:41:21 -07001149 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001150 }
1151
1152 if (status == 0) {
Tao Bao0940fe12015-08-27 16:41:21 -07001153 params.foundwrites = true;
1154 } else if (params.foundwrites) {
1155 fprintf(stderr, "warning: commands executed out of order [%s]\n", params.cmdname);
Sami Tolvanen90221202014-12-09 16:39:47 +00001156 }
1157
Tao Bao0940fe12015-08-27 16:41:21 -07001158 if (params.canwrite) {
Sami Tolvanen90221202014-12-09 16:39:47 +00001159 if (status == 0) {
Tao Bao0940fe12015-08-27 16:41:21 -07001160 fprintf(stderr, "patching %zu blocks to %zu\n", blocks, tgt.size);
Sami Tolvanen90221202014-12-09 16:39:47 +00001161
Tao Bao0940fe12015-08-27 16:41:21 -07001162 Value patch_value;
Sami Tolvanen90221202014-12-09 16:39:47 +00001163 patch_value.type = VAL_BLOB;
1164 patch_value.size = len;
Tao Bao0940fe12015-08-27 16:41:21 -07001165 patch_value.data = (char*) (params.patch_start + offset);
Sami Tolvanen90221202014-12-09 16:39:47 +00001166
Tao Bao0940fe12015-08-27 16:41:21 -07001167 RangeSinkState rss(tgt);
1168 rss.fd = params.fd;
Sami Tolvanen90221202014-12-09 16:39:47 +00001169 rss.p_block = 0;
Tao Bao0940fe12015-08-27 16:41:21 -07001170 rss.p_remain = (tgt.pos[1] - tgt.pos[0]) * BLOCKSIZE;
Sami Tolvanen90221202014-12-09 16:39:47 +00001171
Tao Bao0940fe12015-08-27 16:41:21 -07001172 if (!check_lseek(params.fd, (off64_t) tgt.pos[0] * BLOCKSIZE, SEEK_SET)) {
1173 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001174 }
1175
Tao Bao0940fe12015-08-27 16:41:21 -07001176 if (params.cmdname[0] == 'i') { // imgdiff
Tao Bao612336d2015-08-27 16:41:21 -07001177 ApplyImagePatch(params.buffer.data(), blocks * BLOCKSIZE, &patch_value,
Tao Bao0940fe12015-08-27 16:41:21 -07001178 &RangeSinkWrite, &rss, nullptr, nullptr);
Sami Tolvanen90221202014-12-09 16:39:47 +00001179 } else {
Tao Bao612336d2015-08-27 16:41:21 -07001180 ApplyBSDiffPatch(params.buffer.data(), blocks * BLOCKSIZE, &patch_value, 0,
1181 &RangeSinkWrite, &rss, nullptr);
Sami Tolvanen90221202014-12-09 16:39:47 +00001182 }
1183
1184 // We expect the output of the patcher to fill the tgt ranges exactly.
Tao Bao0940fe12015-08-27 16:41:21 -07001185 if (rss.p_block != tgt.count || rss.p_remain != 0) {
Sami Tolvanen90221202014-12-09 16:39:47 +00001186 fprintf(stderr, "range sink underrun?\n");
1187 }
1188 } else {
Tao Bao0940fe12015-08-27 16:41:21 -07001189 fprintf(stderr, "skipping %zu blocks already patched to %zu [%s]\n",
Tao Baobaad2d42015-12-06 16:56:27 -08001190 blocks, tgt.size, params.cmdline);
Sami Tolvanen90221202014-12-09 16:39:47 +00001191 }
1192 }
1193
Tao Baobaad2d42015-12-06 16:56:27 -08001194 if (!params.freestash.empty()) {
Tao Bao0940fe12015-08-27 16:41:21 -07001195 FreeStash(params.stashbase, params.freestash);
Tao Baobaad2d42015-12-06 16:56:27 -08001196 params.freestash.clear();
Sami Tolvanen90221202014-12-09 16:39:47 +00001197 }
1198
Tao Bao0940fe12015-08-27 16:41:21 -07001199 params.written += tgt.size;
Sami Tolvanen90221202014-12-09 16:39:47 +00001200
Tao Bao0940fe12015-08-27 16:41:21 -07001201 return 0;
Sami Tolvanen90221202014-12-09 16:39:47 +00001202}
1203
Tao Bao0940fe12015-08-27 16:41:21 -07001204static int PerformCommandErase(CommandParameters& params) {
Sami Tolvanene82fa182015-06-10 15:58:12 +00001205 if (DEBUG_ERASE) {
1206 return PerformCommandZero(params);
Sami Tolvanen90221202014-12-09 16:39:47 +00001207 }
1208
Tao Bao0940fe12015-08-27 16:41:21 -07001209 struct stat sb;
1210 if (fstat(params.fd, &sb) == -1) {
Elliott Hughes1fdd4522015-03-23 13:33:57 -07001211 fprintf(stderr, "failed to fstat device to erase: %s\n", strerror(errno));
Tao Bao0940fe12015-08-27 16:41:21 -07001212 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001213 }
1214
Tao Bao0940fe12015-08-27 16:41:21 -07001215 if (!S_ISBLK(sb.st_mode)) {
Sami Tolvanen90221202014-12-09 16:39:47 +00001216 fprintf(stderr, "not a block device; skipping erase\n");
Tao Bao0940fe12015-08-27 16:41:21 -07001217 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001218 }
1219
Tao Baobaad2d42015-12-06 16:56:27 -08001220 if (params.cpos >= params.tokens.size()) {
Tao Baoba9a42a2015-06-23 23:23:33 -07001221 fprintf(stderr, "missing target blocks for erase\n");
Tao Bao0940fe12015-08-27 16:41:21 -07001222 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001223 }
1224
Tao Bao0940fe12015-08-27 16:41:21 -07001225 RangeSet tgt;
Tao Baobaad2d42015-12-06 16:56:27 -08001226 parse_range(params.tokens[params.cpos++], tgt);
Sami Tolvanen90221202014-12-09 16:39:47 +00001227
Tao Bao0940fe12015-08-27 16:41:21 -07001228 if (params.canwrite) {
1229 fprintf(stderr, " erasing %zu blocks\n", tgt.size);
Sami Tolvanen90221202014-12-09 16:39:47 +00001230
Tao Bao0940fe12015-08-27 16:41:21 -07001231 for (size_t i = 0; i < tgt.count; ++i) {
1232 uint64_t blocks[2];
Sami Tolvanen90221202014-12-09 16:39:47 +00001233 // offset in bytes
Tao Bao0940fe12015-08-27 16:41:21 -07001234 blocks[0] = tgt.pos[i * 2] * (uint64_t) BLOCKSIZE;
Sami Tolvanen90221202014-12-09 16:39:47 +00001235 // length in bytes
Tao Bao0940fe12015-08-27 16:41:21 -07001236 blocks[1] = (tgt.pos[i * 2 + 1] - tgt.pos[i * 2]) * (uint64_t) BLOCKSIZE;
Sami Tolvanen90221202014-12-09 16:39:47 +00001237
Tao Bao0940fe12015-08-27 16:41:21 -07001238 if (ioctl(params.fd, BLKDISCARD, &blocks) == -1) {
Elliott Hughes1fdd4522015-03-23 13:33:57 -07001239 fprintf(stderr, "BLKDISCARD ioctl failed: %s\n", strerror(errno));
Tao Bao0940fe12015-08-27 16:41:21 -07001240 return -1;
Sami Tolvanen90221202014-12-09 16:39:47 +00001241 }
1242 }
1243 }
1244
Tao Bao0940fe12015-08-27 16:41:21 -07001245 return 0;
Sami Tolvanen90221202014-12-09 16:39:47 +00001246}
1247
1248// Definitions for transfer list command functions
Tao Bao0940fe12015-08-27 16:41:21 -07001249typedef int (*CommandFunction)(CommandParameters&);
Sami Tolvanen90221202014-12-09 16:39:47 +00001250
Tao Bao612336d2015-08-27 16:41:21 -07001251struct Command {
Sami Tolvanen90221202014-12-09 16:39:47 +00001252 const char* name;
1253 CommandFunction f;
Tao Bao612336d2015-08-27 16:41:21 -07001254};
Sami Tolvanen90221202014-12-09 16:39:47 +00001255
1256// CompareCommands and CompareCommandNames are for the hash table
1257
1258static int CompareCommands(const void* c1, const void* c2) {
1259 return strcmp(((const Command*) c1)->name, ((const Command*) c2)->name);
1260}
1261
1262static int CompareCommandNames(const void* c1, const void* c2) {
1263 return strcmp(((const Command*) c1)->name, (const char*) c2);
1264}
1265
1266// HashString is used to hash command names for the hash table
1267
1268static unsigned int HashString(const char *s) {
1269 unsigned int hash = 0;
1270 if (s) {
1271 while (*s) {
1272 hash = hash * 33 + *s++;
1273 }
1274 }
1275 return hash;
Doug Zongker52ae67d2014-09-08 12:22:09 -07001276}
1277
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001278// args:
1279// - block device (or file) to modify in-place
1280// - transfer list (blob)
1281// - new data stream (filename within package.zip)
1282// - patch stream (filename within package.zip, must be uncompressed)
1283
Tao Bao0940fe12015-08-27 16:41:21 -07001284static Value* PerformBlockImageUpdate(const char* name, State* state, int /* argc */, Expr* argv[],
1285 const Command* commands, size_t cmdcount, bool dryrun) {
Sami Tolvanen90221202014-12-09 16:39:47 +00001286 CommandParameters params;
Sami Tolvanen90221202014-12-09 16:39:47 +00001287 memset(&params, 0, sizeof(params));
1288 params.canwrite = !dryrun;
1289
1290 fprintf(stderr, "performing %s\n", dryrun ? "verification" : "update");
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001291
Tao Bao612336d2015-08-27 16:41:21 -07001292 Value* blockdev_filename = nullptr;
1293 Value* transfer_list_value = nullptr;
1294 Value* new_data_fn = nullptr;
1295 Value* patch_data_fn = nullptr;
Doug Zongker1d5d6092014-08-21 10:47:24 -07001296 if (ReadValueArgs(state, argv, 4, &blockdev_filename, &transfer_list_value,
Sami Tolvanen90221202014-12-09 16:39:47 +00001297 &new_data_fn, &patch_data_fn) < 0) {
Tao Bao612336d2015-08-27 16:41:21 -07001298 return StringValue(strdup(""));
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001299 }
Tao Bao612336d2015-08-27 16:41:21 -07001300 std::unique_ptr<Value, decltype(&FreeValue)> blockdev_filename_holder(blockdev_filename,
1301 FreeValue);
1302 std::unique_ptr<Value, decltype(&FreeValue)> transfer_list_value_holder(transfer_list_value,
1303 FreeValue);
1304 std::unique_ptr<Value, decltype(&FreeValue)> new_data_fn_holder(new_data_fn, FreeValue);
1305 std::unique_ptr<Value, decltype(&FreeValue)> patch_data_fn_holder(patch_data_fn, FreeValue);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001306
1307 if (blockdev_filename->type != VAL_STRING) {
1308 ErrorAbort(state, "blockdev_filename argument to %s must be string", name);
Tao Bao612336d2015-08-27 16:41:21 -07001309 return StringValue(strdup(""));
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001310 }
Doug Zongker1d5d6092014-08-21 10:47:24 -07001311 if (transfer_list_value->type != VAL_BLOB) {
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001312 ErrorAbort(state, "transfer_list argument to %s must be blob", name);
Tao Bao612336d2015-08-27 16:41:21 -07001313 return StringValue(strdup(""));
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001314 }
1315 if (new_data_fn->type != VAL_STRING) {
1316 ErrorAbort(state, "new_data_fn argument to %s must be string", name);
Tao Bao612336d2015-08-27 16:41:21 -07001317 return StringValue(strdup(""));
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001318 }
1319 if (patch_data_fn->type != VAL_STRING) {
1320 ErrorAbort(state, "patch_data_fn argument to %s must be string", name);
Tao Bao612336d2015-08-27 16:41:21 -07001321 return StringValue(strdup(""));
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001322 }
1323
Tao Bao612336d2015-08-27 16:41:21 -07001324 UpdaterInfo* ui = reinterpret_cast<UpdaterInfo*>(state->cookie);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001325
Tao Bao0940fe12015-08-27 16:41:21 -07001326 if (ui == nullptr) {
Tao Bao612336d2015-08-27 16:41:21 -07001327 return StringValue(strdup(""));
Sami Tolvanen90221202014-12-09 16:39:47 +00001328 }
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001329
Tao Bao612336d2015-08-27 16:41:21 -07001330 FILE* cmd_pipe = ui->cmd_pipe;
1331 ZipArchive* za = ui->package_zip;
Sami Tolvanen90221202014-12-09 16:39:47 +00001332
Tao Bao0940fe12015-08-27 16:41:21 -07001333 if (cmd_pipe == nullptr || za == nullptr) {
Tao Bao612336d2015-08-27 16:41:21 -07001334 return StringValue(strdup(""));
Sami Tolvanen90221202014-12-09 16:39:47 +00001335 }
1336
Tao Bao612336d2015-08-27 16:41:21 -07001337 const ZipEntry* patch_entry = mzFindZipEntry(za, patch_data_fn->data);
Tao Bao0940fe12015-08-27 16:41:21 -07001338 if (patch_entry == nullptr) {
Sami Tolvanen90221202014-12-09 16:39:47 +00001339 fprintf(stderr, "%s(): no file \"%s\" in package", name, patch_data_fn->data);
Tao Bao612336d2015-08-27 16:41:21 -07001340 return StringValue(strdup(""));
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001341 }
1342
Sami Tolvanen90221202014-12-09 16:39:47 +00001343 params.patch_start = ui->package_zip_addr + mzGetZipEntryOffset(patch_entry);
Tao Bao612336d2015-08-27 16:41:21 -07001344 const ZipEntry* new_entry = mzFindZipEntry(za, new_data_fn->data);
Tao Bao0940fe12015-08-27 16:41:21 -07001345 if (new_entry == nullptr) {
Sami Tolvanen90221202014-12-09 16:39:47 +00001346 fprintf(stderr, "%s(): no file \"%s\" in package", name, new_data_fn->data);
Tao Bao612336d2015-08-27 16:41:21 -07001347 return StringValue(strdup(""));
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001348 }
1349
Jed Estepa7b9a462015-12-15 16:04:53 -08001350 params.fd = TEMP_FAILURE_RETRY(ota_open(blockdev_filename->data, O_RDWR));
Tao Bao612336d2015-08-27 16:41:21 -07001351 unique_fd fd_holder(params.fd);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001352
Sami Tolvanen90221202014-12-09 16:39:47 +00001353 if (params.fd == -1) {
Elliott Hughes1fdd4522015-03-23 13:33:57 -07001354 fprintf(stderr, "open \"%s\" failed: %s\n", blockdev_filename->data, strerror(errno));
Tao Bao612336d2015-08-27 16:41:21 -07001355 return StringValue(strdup(""));
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001356 }
1357
Sami Tolvanen90221202014-12-09 16:39:47 +00001358 if (params.canwrite) {
1359 params.nti.za = za;
1360 params.nti.entry = new_entry;
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001361
Tao Bao0940fe12015-08-27 16:41:21 -07001362 pthread_mutex_init(&params.nti.mu, nullptr);
1363 pthread_cond_init(&params.nti.cv, nullptr);
Tao Bao612336d2015-08-27 16:41:21 -07001364 pthread_attr_t attr;
Sami Tolvanen90221202014-12-09 16:39:47 +00001365 pthread_attr_init(&attr);
1366 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
1367
Elliott Hughes1fdd4522015-03-23 13:33:57 -07001368 int error = pthread_create(&params.thread, &attr, unzip_new_data, &params.nti);
1369 if (error != 0) {
1370 fprintf(stderr, "pthread_create failed: %s\n", strerror(error));
Tao Bao612336d2015-08-27 16:41:21 -07001371 return StringValue(strdup(""));
Sami Tolvanen90221202014-12-09 16:39:47 +00001372 }
1373 }
1374
Tao Baobaad2d42015-12-06 16:56:27 -08001375 // Copy all the lines in transfer_list_value into std::string for
1376 // processing.
Tao Bao612336d2015-08-27 16:41:21 -07001377 const std::string transfer_list(transfer_list_value->data, transfer_list_value->size);
1378 std::vector<std::string> lines = android::base::Split(transfer_list, "\n");
Tao Baobaad2d42015-12-06 16:56:27 -08001379 if (lines.size() < 2) {
1380 ErrorAbort(state, "too few lines in the transfer list [%zd]\n", lines.size());
1381 return StringValue(strdup(""));
1382 }
Doug Zongker1d5d6092014-08-21 10:47:24 -07001383
Sami Tolvanen90221202014-12-09 16:39:47 +00001384 // First line in transfer list is the version number
Tao Bao1fdec862015-10-21 14:57:44 -07001385 if (!android::base::ParseInt(lines[0].c_str(), &params.version, 1, 4)) {
Tao Bao612336d2015-08-27 16:41:21 -07001386 fprintf(stderr, "unexpected transfer list version [%s]\n", lines[0].c_str());
1387 return StringValue(strdup(""));
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001388 }
1389
Sami Tolvanen90221202014-12-09 16:39:47 +00001390 fprintf(stderr, "blockimg version is %d\n", params.version);
1391
1392 // Second line in transfer list is the total number of blocks we expect to write
Tao Baob15fd222015-09-24 11:10:51 -07001393 int total_blocks;
1394 if (!android::base::ParseInt(lines[1].c_str(), &total_blocks, 0)) {
Tao Bao612336d2015-08-27 16:41:21 -07001395 ErrorAbort(state, "unexpected block count [%s]\n", lines[1].c_str());
1396 return StringValue(strdup(""));
Tao Baob15fd222015-09-24 11:10:51 -07001397 }
1398
1399 if (total_blocks == 0) {
Tao Bao612336d2015-08-27 16:41:21 -07001400 return StringValue(strdup("t"));
Sami Tolvanen90221202014-12-09 16:39:47 +00001401 }
1402
Tao Bao612336d2015-08-27 16:41:21 -07001403 size_t start = 2;
Sami Tolvanen90221202014-12-09 16:39:47 +00001404 if (params.version >= 2) {
Tao Baobaad2d42015-12-06 16:56:27 -08001405 if (lines.size() < 4) {
1406 ErrorAbort(state, "too few lines in the transfer list [%zu]\n", lines.size());
1407 return StringValue(strdup(""));
1408 }
1409
Sami Tolvanen90221202014-12-09 16:39:47 +00001410 // Third line is how many stash entries are needed simultaneously
Tao Bao612336d2015-08-27 16:41:21 -07001411 fprintf(stderr, "maximum stash entries %s\n", lines[2].c_str());
Doug Zongker52ae67d2014-09-08 12:22:09 -07001412
Sami Tolvanen90221202014-12-09 16:39:47 +00001413 // Fourth line is the maximum number of blocks that will be stashed simultaneously
Tao Baob15fd222015-09-24 11:10:51 -07001414 int stash_max_blocks;
1415 if (!android::base::ParseInt(lines[3].c_str(), &stash_max_blocks, 0)) {
Tao Bao612336d2015-08-27 16:41:21 -07001416 ErrorAbort(state, "unexpected maximum stash blocks [%s]\n", lines[3].c_str());
1417 return StringValue(strdup(""));
Doug Zongker52ae67d2014-09-08 12:22:09 -07001418 }
1419
Tao Baob15fd222015-09-24 11:10:51 -07001420 int res = CreateStash(state, stash_max_blocks, blockdev_filename->data, params.stashbase);
Tao Baob15fd222015-09-24 11:10:51 -07001421 if (res == -1) {
1422 return StringValue(strdup(""));
Sami Tolvanen90221202014-12-09 16:39:47 +00001423 }
Tao Bao612336d2015-08-27 16:41:21 -07001424
Tao Baob15fd222015-09-24 11:10:51 -07001425 params.createdstash = res;
1426
Tao Bao612336d2015-08-27 16:41:21 -07001427 start += 2;
Doug Zongker52ae67d2014-09-08 12:22:09 -07001428 }
1429
Sami Tolvanen90221202014-12-09 16:39:47 +00001430 // Build a hash table of the available commands
Tao Bao612336d2015-08-27 16:41:21 -07001431 HashTable* cmdht = mzHashTableCreate(cmdcount, nullptr);
1432 std::unique_ptr<HashTable, decltype(&mzHashTableFree)> cmdht_holder(cmdht, mzHashTableFree);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001433
Tao Bao0940fe12015-08-27 16:41:21 -07001434 for (size_t i = 0; i < cmdcount; ++i) {
1435 unsigned int cmdhash = HashString(commands[i].name);
Sami Tolvanen90221202014-12-09 16:39:47 +00001436 mzHashTableLookup(cmdht, cmdhash, (void*) &commands[i], CompareCommands, true);
1437 }
1438
Tao Bao612336d2015-08-27 16:41:21 -07001439 int rc = -1;
Doug Zongker52ae67d2014-09-08 12:22:09 -07001440
Tao Bao612336d2015-08-27 16:41:21 -07001441 // Subsequent lines are all individual transfer commands
1442 for (auto it = lines.cbegin() + start; it != lines.cend(); it++) {
1443 const std::string& line_str(*it);
Tao Bao6a47dff2015-09-25 17:12:28 -07001444 if (line_str.empty()) {
1445 continue;
1446 }
1447
Tao Baobaad2d42015-12-06 16:56:27 -08001448 params.tokens = android::base::Split(line_str, " ");
1449 params.cpos = 0;
1450 params.cmdname = params.tokens[params.cpos++].c_str();
1451 params.cmdline = line_str.c_str();
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001452
Tao Bao0940fe12015-08-27 16:41:21 -07001453 unsigned int cmdhash = HashString(params.cmdname);
Tao Bao612336d2015-08-27 16:41:21 -07001454 const Command* cmd = reinterpret_cast<const Command*>(mzHashTableLookup(cmdht, cmdhash,
Tao Baobaad2d42015-12-06 16:56:27 -08001455 const_cast<char*>(params.cmdname), CompareCommandNames,
1456 false));
Doug Zongker52ae67d2014-09-08 12:22:09 -07001457
Tao Bao0940fe12015-08-27 16:41:21 -07001458 if (cmd == nullptr) {
Sami Tolvanen90221202014-12-09 16:39:47 +00001459 fprintf(stderr, "unexpected command [%s]\n", params.cmdname);
1460 goto pbiudone;
1461 }
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001462
Tao Bao0940fe12015-08-27 16:41:21 -07001463 if (cmd->f != nullptr && cmd->f(params) == -1) {
Tao Bao612336d2015-08-27 16:41:21 -07001464 fprintf(stderr, "failed to execute command [%s]\n", line_str.c_str());
Sami Tolvanen90221202014-12-09 16:39:47 +00001465 goto pbiudone;
1466 }
1467
Sami Tolvanen90221202014-12-09 16:39:47 +00001468 if (params.canwrite) {
Jed Estepa7b9a462015-12-15 16:04:53 -08001469 if (ota_fsync(params.fd) == -1) {
Tao Bao187efff2015-07-27 14:07:08 -07001470 fprintf(stderr, "fsync failed: %s\n", strerror(errno));
1471 goto pbiudone;
1472 }
Sami Tolvanen90221202014-12-09 16:39:47 +00001473 fprintf(cmd_pipe, "set_progress %.4f\n", (double) params.written / total_blocks);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001474 fflush(cmd_pipe);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001475 }
1476 }
1477
Sami Tolvanen90221202014-12-09 16:39:47 +00001478 if (params.canwrite) {
Tao Bao0940fe12015-08-27 16:41:21 -07001479 pthread_join(params.thread, nullptr);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001480
Tao Bao0940fe12015-08-27 16:41:21 -07001481 fprintf(stderr, "wrote %zu blocks; expected %d\n", params.written, total_blocks);
Tao Bao612336d2015-08-27 16:41:21 -07001482 fprintf(stderr, "max alloc needed was %zu\n", params.buffer.size());
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001483
Sami Tolvanen90221202014-12-09 16:39:47 +00001484 // Delete stash only after successfully completing the update, as it
1485 // may contain blocks needed to complete the update later.
1486 DeleteStash(params.stashbase);
1487 } else {
1488 fprintf(stderr, "verified partition contents; update may be resumed\n");
1489 }
1490
1491 rc = 0;
1492
1493pbiudone:
Jed Estepa7b9a462015-12-15 16:04:53 -08001494 if (ota_fsync(params.fd) == -1) {
Tao Baobaad2d42015-12-06 16:56:27 -08001495 fprintf(stderr, "fsync failed: %s\n", strerror(errno));
Sami Tolvanen90221202014-12-09 16:39:47 +00001496 }
Tao Baobaad2d42015-12-06 16:56:27 -08001497 // params.fd will be automatically closed because of the fd_holder above.
Sami Tolvanen90221202014-12-09 16:39:47 +00001498
Sami Tolvanen90221202014-12-09 16:39:47 +00001499 // Only delete the stash if the update cannot be resumed, or it's
1500 // a verification run and we created the stash.
1501 if (params.isunresumable || (!params.canwrite && params.createdstash)) {
1502 DeleteStash(params.stashbase);
1503 }
1504
Sami Tolvanen90221202014-12-09 16:39:47 +00001505 return StringValue(rc == 0 ? strdup("t") : strdup(""));
1506}
1507
1508// The transfer list is a text file containing commands to
1509// transfer data from one place to another on the target
1510// partition. We parse it and execute the commands in order:
1511//
1512// zero [rangeset]
1513// - fill the indicated blocks with zeros
1514//
1515// new [rangeset]
1516// - fill the blocks with data read from the new_data file
1517//
1518// erase [rangeset]
1519// - mark the given blocks as empty
1520//
1521// move <...>
1522// bsdiff <patchstart> <patchlen> <...>
1523// imgdiff <patchstart> <patchlen> <...>
1524// - read the source blocks, apply a patch (or not in the
1525// case of move), write result to target blocks. bsdiff or
1526// imgdiff specifies the type of patch; move means no patch
1527// at all.
1528//
1529// The format of <...> differs between versions 1 and 2;
1530// see the LoadSrcTgtVersion{1,2}() functions for a
1531// description of what's expected.
1532//
1533// stash <stash_id> <src_range>
1534// - (version 2+ only) load the given source range and stash
1535// the data in the given slot of the stash table.
1536//
Tao Baobaad2d42015-12-06 16:56:27 -08001537// free <stash_id>
1538// - (version 3+ only) free the given stash data.
1539//
Sami Tolvanen90221202014-12-09 16:39:47 +00001540// The creator of the transfer list will guarantee that no block
1541// is read (ie, used as the source for a patch or move) after it
1542// has been written.
1543//
1544// In version 2, the creator will guarantee that a given stash is
1545// loaded (with a stash command) before it's used in a
1546// move/bsdiff/imgdiff command.
1547//
1548// Within one command the source and target ranges may overlap so
1549// in general we need to read the entire source into memory before
1550// writing anything to the target blocks.
1551//
1552// All the patch data is concatenated into one patch_data file in
1553// the update package. It must be stored uncompressed because we
1554// memory-map it in directly from the archive. (Since patches are
1555// already compressed, we lose very little by not compressing
1556// their concatenation.)
1557//
1558// In version 3, commands that read data from the partition (i.e.
1559// move/bsdiff/imgdiff/stash) have one or more additional hashes
1560// before the range parameters, which are used to check if the
1561// command has already been completed and verify the integrity of
1562// the source data.
1563
1564Value* BlockImageVerifyFn(const char* name, State* state, int argc, Expr* argv[]) {
Tao Bao0940fe12015-08-27 16:41:21 -07001565 // Commands which are not tested are set to nullptr to skip them completely
Sami Tolvanen90221202014-12-09 16:39:47 +00001566 const Command commands[] = {
1567 { "bsdiff", PerformCommandDiff },
Tao Bao0940fe12015-08-27 16:41:21 -07001568 { "erase", nullptr },
Sami Tolvanen90221202014-12-09 16:39:47 +00001569 { "free", PerformCommandFree },
1570 { "imgdiff", PerformCommandDiff },
1571 { "move", PerformCommandMove },
Tao Bao0940fe12015-08-27 16:41:21 -07001572 { "new", nullptr },
Sami Tolvanen90221202014-12-09 16:39:47 +00001573 { "stash", PerformCommandStash },
Tao Bao0940fe12015-08-27 16:41:21 -07001574 { "zero", nullptr }
Sami Tolvanen90221202014-12-09 16:39:47 +00001575 };
1576
1577 // Perform a dry run without writing to test if an update can proceed
1578 return PerformBlockImageUpdate(name, state, argc, argv, commands,
Tao Baoe6aa3322015-08-05 15:20:27 -07001579 sizeof(commands) / sizeof(commands[0]), true);
Sami Tolvanen90221202014-12-09 16:39:47 +00001580}
1581
1582Value* BlockImageUpdateFn(const char* name, State* state, int argc, Expr* argv[]) {
1583 const Command commands[] = {
1584 { "bsdiff", PerformCommandDiff },
1585 { "erase", PerformCommandErase },
1586 { "free", PerformCommandFree },
1587 { "imgdiff", PerformCommandDiff },
1588 { "move", PerformCommandMove },
1589 { "new", PerformCommandNew },
1590 { "stash", PerformCommandStash },
1591 { "zero", PerformCommandZero }
1592 };
1593
1594 return PerformBlockImageUpdate(name, state, argc, argv, commands,
Tao Baoe6aa3322015-08-05 15:20:27 -07001595 sizeof(commands) / sizeof(commands[0]), false);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001596}
1597
Tao Bao0940fe12015-08-27 16:41:21 -07001598Value* RangeSha1Fn(const char* name, State* state, int /* argc */, Expr* argv[]) {
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001599 Value* blockdev_filename;
1600 Value* ranges;
Tao Bao0940fe12015-08-27 16:41:21 -07001601
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001602 if (ReadValueArgs(state, argv, 2, &blockdev_filename, &ranges) < 0) {
Tao Bao612336d2015-08-27 16:41:21 -07001603 return StringValue(strdup(""));
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001604 }
Tao Bao612336d2015-08-27 16:41:21 -07001605 std::unique_ptr<Value, decltype(&FreeValue)> ranges_holder(ranges, FreeValue);
1606 std::unique_ptr<Value, decltype(&FreeValue)> blockdev_filename_holder(blockdev_filename,
1607 FreeValue);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001608
1609 if (blockdev_filename->type != VAL_STRING) {
1610 ErrorAbort(state, "blockdev_filename argument to %s must be string", name);
Tao Bao612336d2015-08-27 16:41:21 -07001611 return StringValue(strdup(""));
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001612 }
1613 if (ranges->type != VAL_STRING) {
1614 ErrorAbort(state, "ranges argument to %s must be string", name);
Tao Bao612336d2015-08-27 16:41:21 -07001615 return StringValue(strdup(""));
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001616 }
1617
Jed Estepa7b9a462015-12-15 16:04:53 -08001618 int fd = ota_open(blockdev_filename->data, O_RDWR);
Tao Bao612336d2015-08-27 16:41:21 -07001619 unique_fd fd_holder(fd);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001620 if (fd < 0) {
Elliott Hughes1fdd4522015-03-23 13:33:57 -07001621 ErrorAbort(state, "open \"%s\" failed: %s", blockdev_filename->data, strerror(errno));
Tao Bao612336d2015-08-27 16:41:21 -07001622 return StringValue(strdup(""));
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001623 }
1624
Tao Bao612336d2015-08-27 16:41:21 -07001625 RangeSet rs;
Tao Bao0940fe12015-08-27 16:41:21 -07001626 parse_range(ranges->data, rs);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001627
1628 SHA_CTX ctx;
Sen Jiangc48cb5e2016-02-04 16:23:21 +08001629 SHA1_Init(&ctx);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001630
Tao Bao612336d2015-08-27 16:41:21 -07001631 std::vector<uint8_t> buffer(BLOCKSIZE);
Tao Bao0940fe12015-08-27 16:41:21 -07001632 for (size_t i = 0; i < rs.count; ++i) {
1633 if (!check_lseek(fd, (off64_t)rs.pos[i*2] * BLOCKSIZE, SEEK_SET)) {
Tao Bao612336d2015-08-27 16:41:21 -07001634 ErrorAbort(state, "failed to seek %s: %s", blockdev_filename->data, strerror(errno));
1635 return StringValue(strdup(""));
Sami Tolvanen90221202014-12-09 16:39:47 +00001636 }
1637
Tao Bao0940fe12015-08-27 16:41:21 -07001638 for (size_t j = rs.pos[i*2]; j < rs.pos[i*2+1]; ++j) {
Sami Tolvanen90221202014-12-09 16:39:47 +00001639 if (read_all(fd, buffer, BLOCKSIZE) == -1) {
1640 ErrorAbort(state, "failed to read %s: %s", blockdev_filename->data,
Tao Bao0940fe12015-08-27 16:41:21 -07001641 strerror(errno));
Tao Bao612336d2015-08-27 16:41:21 -07001642 return StringValue(strdup(""));
Sami Tolvanen90221202014-12-09 16:39:47 +00001643 }
1644
Sen Jiangc48cb5e2016-02-04 16:23:21 +08001645 SHA1_Update(&ctx, buffer.data(), BLOCKSIZE);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001646 }
1647 }
Sen Jiangc48cb5e2016-02-04 16:23:21 +08001648 uint8_t digest[SHA_DIGEST_LENGTH];
1649 SHA1_Final(digest, &ctx);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001650
Tao Bao612336d2015-08-27 16:41:21 -07001651 return StringValue(strdup(print_sha1(digest).c_str()));
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001652}
1653
Tianjie Xu57bed6d2015-12-15 11:47:30 -08001654// This function checks if a device has been remounted R/W prior to an incremental
1655// OTA update. This is an common cause of update abortion. The function reads the
1656// 1st block of each partition and check for mounting time/count. It return string "t"
1657// if executes successfully and an empty string otherwise.
1658
1659Value* CheckFirstBlockFn(const char* name, State* state, int argc, Expr* argv[]) {
1660 Value* arg_filename;
1661
1662 if (ReadValueArgs(state, argv, 1, &arg_filename) < 0) {
1663 return nullptr;
1664 }
1665 std::unique_ptr<Value, decltype(&FreeValue)> filename(arg_filename, FreeValue);
1666
1667 if (filename->type != VAL_STRING) {
1668 ErrorAbort(state, "filename argument to %s must be string", name);
1669 return StringValue(strdup(""));
1670 }
1671
Jed Estepa7b9a462015-12-15 16:04:53 -08001672 int fd = ota_open(arg_filename->data, O_RDONLY);
Tianjie Xu57bed6d2015-12-15 11:47:30 -08001673 unique_fd fd_holder(fd);
1674 if (fd == -1) {
1675 ErrorAbort(state, "open \"%s\" failed: %s", arg_filename->data, strerror(errno));
1676 return StringValue(strdup(""));
1677 }
1678
1679 RangeSet blk0 {1 /*count*/, 1/*size*/, std::vector<size_t> {0, 1}/*position*/};
1680 std::vector<uint8_t> block0_buffer(BLOCKSIZE);
1681
1682 if (ReadBlocks(blk0, block0_buffer, fd) == -1) {
1683 ErrorAbort(state, "failed to read %s: %s", arg_filename->data,
1684 strerror(errno));
1685 return StringValue(strdup(""));
1686 }
1687
1688 // https://ext4.wiki.kernel.org/index.php/Ext4_Disk_Layout
1689 // Super block starts from block 0, offset 0x400
1690 // 0x2C: len32 Mount time
1691 // 0x30: len32 Write time
1692 // 0x34: len16 Number of mounts since the last fsck
1693 // 0x38: len16 Magic signature 0xEF53
1694
1695 time_t mount_time = *reinterpret_cast<uint32_t*>(&block0_buffer[0x400+0x2C]);
1696 uint16_t mount_count = *reinterpret_cast<uint16_t*>(&block0_buffer[0x400+0x34]);
1697
1698 if (mount_count > 0) {
1699 uiPrintf(state, "Device was remounted R/W %d times\n", mount_count);
1700 uiPrintf(state, "Last remount happened on %s", ctime(&mount_time));
1701 }
1702
1703 return StringValue(strdup("t"));
1704}
1705
1706
Sami Tolvanen0a7b4732015-06-25 10:25:36 +01001707Value* BlockImageRecoverFn(const char* name, State* state, int argc, Expr* argv[]) {
1708 Value* arg_filename;
1709 Value* arg_ranges;
1710
1711 if (ReadValueArgs(state, argv, 2, &arg_filename, &arg_ranges) < 0) {
1712 return NULL;
1713 }
1714
1715 std::unique_ptr<Value, decltype(&FreeValue)> filename(arg_filename, FreeValue);
1716 std::unique_ptr<Value, decltype(&FreeValue)> ranges(arg_ranges, FreeValue);
1717
1718 if (filename->type != VAL_STRING) {
1719 ErrorAbort(state, "filename argument to %s must be string", name);
1720 return StringValue(strdup(""));
1721 }
1722 if (ranges->type != VAL_STRING) {
1723 ErrorAbort(state, "ranges argument to %s must be string", name);
1724 return StringValue(strdup(""));
1725 }
1726
Tianjie Xu3b010bc2015-12-09 15:29:45 -08001727 // Output notice to log when recover is attempted
1728 fprintf(stderr, "%s image corrupted, attempting to recover...\n", filename->data);
1729
Sami Tolvanen0a7b4732015-06-25 10:25:36 +01001730 // When opened with O_RDWR, libfec rewrites corrupted blocks when they are read
1731 fec::io fh(filename->data, O_RDWR);
1732
1733 if (!fh) {
1734 ErrorAbort(state, "fec_open \"%s\" failed: %s", filename->data, strerror(errno));
1735 return StringValue(strdup(""));
1736 }
1737
1738 if (!fh.has_ecc() || !fh.has_verity()) {
1739 ErrorAbort(state, "unable to use metadata to correct errors");
1740 return StringValue(strdup(""));
1741 }
1742
1743 fec_status status;
1744
1745 if (!fh.get_status(status)) {
1746 ErrorAbort(state, "failed to read FEC status");
1747 return StringValue(strdup(""));
1748 }
1749
1750 RangeSet rs;
1751 parse_range(ranges->data, rs);
1752
1753 uint8_t buffer[BLOCKSIZE];
1754
1755 for (size_t i = 0; i < rs.count; ++i) {
1756 for (size_t j = rs.pos[i * 2]; j < rs.pos[i * 2 + 1]; ++j) {
1757 // Stay within the data area, libfec validates and corrects metadata
1758 if (status.data_size <= (uint64_t)j * BLOCKSIZE) {
1759 continue;
1760 }
1761
1762 if (fh.pread(buffer, BLOCKSIZE, (off64_t)j * BLOCKSIZE) != BLOCKSIZE) {
Tao Baobaad2d42015-12-06 16:56:27 -08001763 ErrorAbort(state, "failed to recover %s (block %zu): %s", filename->data,
Sami Tolvanen0a7b4732015-06-25 10:25:36 +01001764 j, strerror(errno));
1765 return StringValue(strdup(""));
1766 }
1767
1768 // If we want to be able to recover from a situation where rewriting a corrected
1769 // block doesn't guarantee the same data will be returned when re-read later, we
1770 // can save a copy of corrected blocks to /cache. Note:
1771 //
1772 // 1. Maximum space required from /cache is the same as the maximum number of
1773 // corrupted blocks we can correct. For RS(255, 253) and a 2 GiB partition,
1774 // this would be ~16 MiB, for example.
1775 //
1776 // 2. To find out if this block was corrupted, call fec_get_status after each
1777 // read and check if the errors field value has increased.
1778 }
1779 }
Tianjie Xu3b010bc2015-12-09 15:29:45 -08001780 fprintf(stderr, "...%s image recovered successfully.\n", filename->data);
Sami Tolvanen0a7b4732015-06-25 10:25:36 +01001781 return StringValue(strdup("t"));
1782}
1783
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001784void RegisterBlockImageFunctions() {
Sami Tolvanen90221202014-12-09 16:39:47 +00001785 RegisterFunction("block_image_verify", BlockImageVerifyFn);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001786 RegisterFunction("block_image_update", BlockImageUpdateFn);
Sami Tolvanen0a7b4732015-06-25 10:25:36 +01001787 RegisterFunction("block_image_recover", BlockImageRecoverFn);
Tianjie Xu57bed6d2015-12-15 11:47:30 -08001788 RegisterFunction("check_first_block", CheckFirstBlockFn);
Doug Zongkerbc7ffed2014-08-15 14:31:52 -07001789 RegisterFunction("range_sha1", RangeSha1Fn);
1790}