PawletOS/android_bootable_recovery
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "updater: Switch to libbase logging." am: d2c56629ab am: 1d9779b57b

Browse Source 
am: 997ccbc5a4

Change-Id: Ic5a9d53af6e59c1e0ba16dd6275f941a21e4b98d
This commit is contained in:
Tao Bao
2016-12-02 05:52:55 +00:00
committed by android-build-merger
parent 65383535a7 997ccbc5a4
commit dd570b59ad
3 changed files with 983 additions and 982 deletions
Download Patch File Download Diff File Expand all files Collapse all files
updater/blockimg.cpp
+95 -99
View File
@@ -18,7 +18,6 @@
#include <errno.h> #include <errno.h>
#include <dirent.h> #include <dirent.h>
#include <fcntl.h> #include <fcntl.h>
#include <inttypes.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <pthread.h> #include <pthread.h>
#include <stdarg.h> #include <stdarg.h>
@@ -38,6 +37,7 @@
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
#include <android-base/logging.h>
#include <android-base/parseint.h> #include <android-base/parseint.h>
#include <android-base/strings.h> #include <android-base/strings.h>
#include <android-base/unique_fd.h> #include <android-base/unique_fd.h>
@@ -52,7 +52,7 @@
#include "print_sha1.h" #include "print_sha1.h"
#include "updater/updater.h" #include "updater/updater.h"
#define BLOCKSIZE 4096 static constexpr size_t BLOCKSIZE = 4096;
// Set this to 0 to interpret 'erase' transfers to mean do a // Set this to 0 to interpret 'erase' transfers to mean do a
// BLKDISCARD ioctl (the normal behavior). Set to 1 to interpret // BLKDISCARD ioctl (the normal behavior). Set to 1 to interpret
@@ -121,7 +121,7 @@ static void parse_range(const std::string& range_text, RangeSet& rs) {
return; return;
err: err:
fprintf(stderr, "failed to parse range '%s'\n", range_text.c_str()); LOG(ERROR) << "failed to parse range '" << range_text << "'";
exit(1); exit(1);
} }
@@ -149,11 +149,11 @@ static int read_all(int fd, uint8_t* data, size_t size) {
ssize_t r = TEMP_FAILURE_RETRY(ota_read(fd, data+so_far, size-so_far)); ssize_t r = TEMP_FAILURE_RETRY(ota_read(fd, data+so_far, size-so_far));
if (r == -1) { if (r == -1) {
failure_type = kFreadFailure; failure_type = kFreadFailure;
fprintf(stderr, "read failed: %s\n", strerror(errno)); PLOG(ERROR) << "read failed";
return -1; return -1;
} else if (r == 0) { } else if (r == 0) {
failure_type = kFreadFailure; failure_type = kFreadFailure;
fprintf(stderr, "read reached unexpected EOF.\n"); LOG(ERROR) << "read reached unexpected EOF.";
return -1; return -1;
} }
so_far += r; so_far += r;
@@ -171,7 +171,7 @@ static int write_all(int fd, const uint8_t* data, size_t size) {
ssize_t w = TEMP_FAILURE_RETRY(ota_write(fd, data+written, size-written)); ssize_t w = TEMP_FAILURE_RETRY(ota_write(fd, data+written, size-written));
if (w == -1) { if (w == -1) {
failure_type = kFwriteFailure; failure_type = kFwriteFailure;
fprintf(stderr, "write failed: %s\n", strerror(errno)); PLOG(ERROR) << "write failed";
return -1; return -1;
} }
written += w; written += w;
@@ -193,7 +193,7 @@ static bool discard_blocks(int fd, off64_t offset, uint64_t size) {
uint64_t args[2] = {static_cast<uint64_t>(offset), size}; uint64_t args[2] = {static_cast<uint64_t>(offset), size};
int status = ioctl(fd, BLKDISCARD, &args); int status = ioctl(fd, BLKDISCARD, &args);
if (status == -1) { if (status == -1) {
fprintf(stderr, "BLKDISCARD ioctl failed: %s\n", strerror(errno)); PLOG(ERROR) << "BLKDISCARD ioctl failed";
return false; return false;
} }
return true; return true;
@@ -203,7 +203,7 @@ static bool check_lseek(int fd, off64_t offset, int whence) {
off64_t rc = TEMP_FAILURE_RETRY(lseek64(fd, offset, whence)); off64_t rc = TEMP_FAILURE_RETRY(lseek64(fd, offset, whence));
if (rc == -1) { if (rc == -1) {
failure_type = kLseekFailure; failure_type = kLseekFailure;
fprintf(stderr, "lseek64 failed: %s\n", strerror(errno)); PLOG(ERROR) << "lseek64 failed";
return false; return false;
} }
return true; return true;
@@ -229,7 +229,7 @@ static ssize_t RangeSinkWrite(const uint8_t* data, ssize_t size, void* token) {
RangeSinkState* rss = reinterpret_cast<RangeSinkState*>(token); RangeSinkState* rss = reinterpret_cast<RangeSinkState*>(token);
if (rss->p_remain == 0) { if (rss->p_remain == 0) {
fprintf(stderr, "range sink write overrun"); LOG(ERROR) << "range sink write overrun";
return 0; return 0;
} }
@@ -426,7 +426,7 @@ static int LoadSrcTgtVersion1(CommandParameters& params, RangeSet& tgt, size_t&
std::vector<uint8_t>& buffer, int fd) { std::vector<uint8_t>& buffer, int fd) {
if (params.cpos + 1 >= params.tokens.size()) { if (params.cpos + 1 >= params.tokens.size()) {
fprintf(stderr, "invalid parameters\n"); LOG(ERROR) << "invalid parameters";
return -1; return -1;
} }
@@ -455,8 +455,8 @@ static int VerifyBlocks(const std::string& expected, const std::vector<uint8_t>&
if (hexdigest != expected) { if (hexdigest != expected) {
if (printerror) { if (printerror) {
fprintf(stderr, "failed to verify blocks (expected %s, read %s)\n", LOG(ERROR) << "failed to verify blocks (expected " << expected << ", read "
expected.c_str(), hexdigest.c_str()); << hexdigest << ")";
} }
return -1; return -1;
} }
@@ -492,7 +492,7 @@ static void EnumerateStash(const std::string& dirname, StashCallback callback, v
if (directory == nullptr) { if (directory == nullptr) {
if (errno != ENOENT) { if (errno != ENOENT) {
fprintf(stderr, "opendir \"%s\" failed: %s\n", dirname.c_str(), strerror(errno)); PLOG(ERROR) << "opendir \"" << dirname << "\" failed";
} }
return; return;
} }
@@ -515,7 +515,7 @@ static void UpdateFileSize(const std::string& fn, void* data) {
struct stat sb; struct stat sb;
if (stat(fn.c_str(), &sb) == -1) { if (stat(fn.c_str(), &sb) == -1) {
fprintf(stderr, "stat \"%s\" failed: %s\n", fn.c_str(), strerror(errno)); PLOG(ERROR) << "stat \"" << fn << "\" failed";
return; return;
} }
@@ -529,10 +529,10 @@ static void UpdateFileSize(const std::string& fn, void* data) {
static void DeleteFile(const std::string& fn, void* /* data */) { static void DeleteFile(const std::string& fn, void* /* data */) {
if (!fn.empty()) { if (!fn.empty()) {
fprintf(stderr, "deleting %s\n", fn.c_str()); LOG(INFO) << "deleting " << fn;
if (unlink(fn.c_str()) == -1 && errno != ENOENT) { if (unlink(fn.c_str()) == -1 && errno != ENOENT) {
fprintf(stderr, "unlink \"%s\" failed: %s\n", fn.c_str(), strerror(errno)); PLOG(ERROR) << "unlink \"" << fn << "\" failed";
} }
} }
} }
@@ -548,14 +548,14 @@ static void DeleteStash(const std::string& base) {
return; return;
} }
fprintf(stderr, "deleting stash %s\n", base.c_str()); LOG(INFO) << "deleting stash " << base;
std::string dirname = GetStashFileName(base, "", ""); std::string dirname = GetStashFileName(base, "", "");
EnumerateStash(dirname, DeleteFile, nullptr); EnumerateStash(dirname, DeleteFile, nullptr);
if (rmdir(dirname.c_str()) == -1) { if (rmdir(dirname.c_str()) == -1) {
if (errno != ENOENT && errno != ENOTDIR) { if (errno != ENOENT && errno != ENOTDIR) {
fprintf(stderr, "rmdir \"%s\" failed: %s\n", dirname.c_str(), strerror(errno)); PLOG(ERROR) << "rmdir \"" << dirname << "\" failed";
} }
} }
} }
@@ -571,11 +571,11 @@ static int LoadStash(CommandParameters& params, const std::string& base, const s
allocate(src.size * BLOCKSIZE, buffer); allocate(src.size * BLOCKSIZE, buffer);
if (ReadBlocks(src, buffer, params.fd) == -1) { if (ReadBlocks(src, buffer, params.fd) == -1) {
fprintf(stderr, "failed to read source blocks in stash map.\n"); LOG(ERROR) << "failed to read source blocks in stash map.";
return -1; return -1;
} }
if (VerifyBlocks(id, buffer, src.size, true) != 0) { if (VerifyBlocks(id, buffer, src.size, true) != 0) {
fprintf(stderr, "failed to verify loaded source blocks in stash map.\n"); LOG(ERROR) << "failed to verify loaded source blocks in stash map.";
return -1; return -1;
} }
return 0; return 0;
@@ -599,22 +599,21 @@ static int LoadStash(CommandParameters& params, const std::string& base, const s
if (res == -1) { if (res == -1) {
if (errno != ENOENT || printnoent) { if (errno != ENOENT || printnoent) {
fprintf(stderr, "stat \"%s\" failed: %s\n", fn.c_str(), strerror(errno)); PLOG(ERROR) << "stat \"" << fn << "\" failed";
} }
return -1; return -1;
} }
fprintf(stderr, " loading %s\n", fn.c_str()); LOG(INFO) << " loading " << fn;
if ((sb.st_size % BLOCKSIZE) != 0) { if ((sb.st_size % BLOCKSIZE) != 0) {
fprintf(stderr, "%s size %" PRId64 " not multiple of block size %d", LOG(ERROR) << fn << " size " << sb.st_size << " not multiple of block size " << BLOCKSIZE;
fn.c_str(), static_cast<int64_t>(sb.st_size), BLOCKSIZE);
return -1; return -1;
} }
android::base::unique_fd fd(TEMP_FAILURE_RETRY(ota_open(fn.c_str(), O_RDONLY))); android::base::unique_fd fd(TEMP_FAILURE_RETRY(ota_open(fn.c_str(), O_RDONLY)));
if (fd == -1) { if (fd == -1) {
fprintf(stderr, "open \"%s\" failed: %s\n", fn.c_str(), strerror(errno)); PLOG(ERROR) << "open \"" << fn << "\" failed";
return -1; return -1;
} }
@@ -627,7 +626,7 @@ static int LoadStash(CommandParameters& params, const std::string& base, const s
*blocks = sb.st_size / BLOCKSIZE; *blocks = sb.st_size / BLOCKSIZE;
if (verify && VerifyBlocks(id, buffer, *blocks, true) != 0) { if (verify && VerifyBlocks(id, buffer, *blocks, true) != 0) {
fprintf(stderr, "unexpected contents in %s\n", fn.c_str()); LOG(ERROR) << "unexpected contents in " << fn;
DeleteFile(fn, nullptr); DeleteFile(fn, nullptr);
return -1; return -1;
} }
@@ -642,7 +641,7 @@ static int WriteStash(const std::string& base, const std::string& id, int blocks
} }
if (checkspace && CacheSizeCheck(blocks * BLOCKSIZE) != 0) { if (checkspace && CacheSizeCheck(blocks * BLOCKSIZE) != 0) {
fprintf(stderr, "not enough space to write stash\n"); LOG(ERROR) << "not enough space to write stash";
return -1; return -1;
} }
@@ -657,7 +656,7 @@ static int WriteStash(const std::string& base, const std::string& id, int blocks
// The file already exists and since the name is the hash of the contents, // The file already exists and since the name is the hash of the contents,
// it's safe to assume the contents are identical (accidental hash collisions // it's safe to assume the contents are identical (accidental hash collisions
// are unlikely) // are unlikely)
fprintf(stderr, " skipping %d existing blocks in %s\n", blocks, cn.c_str()); LOG(INFO) << " skipping " << blocks << " existing blocks in " << cn;
*exists = true; *exists = true;
return 0; return 0;
} }
@@ -665,13 +664,12 @@ static int WriteStash(const std::string& base, const std::string& id, int blocks
*exists = false; *exists = false;
} }
fprintf(stderr, " writing %d blocks to %s\n", blocks, cn.c_str()); LOG(INFO) << " writing " << blocks << " blocks to " << cn;
android::base::unique_fd fd(TEMP_FAILURE_RETRY(ota_open(fn.c_str(), android::base::unique_fd fd(
O_WRONLY | O_CREAT | O_TRUNC, TEMP_FAILURE_RETRY(ota_open(fn.c_str(), O_WRONLY | O_CREAT | O_TRUNC, STASH_FILE_MODE)));
STASH_FILE_MODE)));
if (fd == -1) { if (fd == -1) {
fprintf(stderr, "failed to create \"%s\": %s\n", fn.c_str(), strerror(errno)); PLOG(ERROR) << "failed to create \"" << fn << "\"";
return -1; return -1;
} }
@@ -681,13 +679,12 @@ static int WriteStash(const std::string& base, const std::string& id, int blocks
if (ota_fsync(fd) == -1) { if (ota_fsync(fd) == -1) {
failure_type = kFsyncFailure; failure_type = kFsyncFailure;
fprintf(stderr, "fsync \"%s\" failed: %s\n", fn.c_str(), strerror(errno)); PLOG(ERROR) << "fsync \"" << fn << "\" failed";
return -1; return -1;
} }
if (rename(fn.c_str(), cn.c_str()) == -1) { if (rename(fn.c_str(), cn.c_str()) == -1) {
fprintf(stderr, "rename(\"%s\", \"%s\") failed: %s\n", fn.c_str(), cn.c_str(), PLOG(ERROR) << "rename(\"" << fn << "\", \"" << cn << "\") failed";
strerror(errno));
return -1; return -1;
} }
@@ -696,13 +693,13 @@ static int WriteStash(const std::string& base, const std::string& id, int blocks
O_RDONLY | O_DIRECTORY))); O_RDONLY | O_DIRECTORY)));
if (dfd == -1) { if (dfd == -1) {
failure_type = kFileOpenFailure; failure_type = kFileOpenFailure;
fprintf(stderr, "failed to open \"%s\" failed: %s\n", dname.c_str(), strerror(errno)); PLOG(ERROR) << "failed to open \"" << dname << "\" failed";
return -1; return -1;
} }
if (ota_fsync(dfd) == -1) { if (ota_fsync(dfd) == -1) {
failure_type = kFsyncFailure; failure_type = kFsyncFailure;
fprintf(stderr, "fsync \"%s\" failed: %s\n", dname.c_str(), strerror(errno)); PLOG(ERROR) << "fsync \"" << dname << "\" failed";
return -1; return -1;
} }
@@ -734,7 +731,7 @@ static int CreateStash(State* state, int maxblocks, const char* blockdev, std::s
dirname.c_str(), strerror(errno)); dirname.c_str(), strerror(errno));
return -1; return -1;
} else if (res != 0) { } else if (res != 0) {
fprintf(stderr, "creating stash %s\n", dirname.c_str()); LOG(INFO) << "creating stash " << dirname;
res = mkdir(dirname.c_str(), STASH_DIRECTORY_MODE); res = mkdir(dirname.c_str(), STASH_DIRECTORY_MODE);
if (res != 0) { if (res != 0) {
@@ -751,7 +748,7 @@ static int CreateStash(State* state, int maxblocks, const char* blockdev, std::s
return 1; // Created directory return 1; // Created directory
} }
fprintf(stderr, "using existing stash %s\n", dirname.c_str()); LOG(INFO) << "using existing stash " << dirname;
// If the directory already exists, calculate the space already allocated to // If the directory already exists, calculate the space already allocated to
// stash files and check if there's enough for all required blocks. Delete any // stash files and check if there's enough for all required blocks. Delete any
@@ -777,7 +774,7 @@ static int SaveStash(CommandParameters& params, const std::string& base,
// <stash_id> <src_range> // <stash_id> <src_range>
if (params.cpos + 1 >= params.tokens.size()) { if (params.cpos + 1 >= params.tokens.size()) {
fprintf(stderr, "missing id and/or src range fields in stash command\n"); LOG(ERROR) << "missing id and/or src range fields in stash command";
return -1; return -1;
} }
const std::string& id = params.tokens[params.cpos++]; const std::string& id = params.tokens[params.cpos++];
@@ -804,7 +801,7 @@ static int SaveStash(CommandParameters& params, const std::string& base,
// data later, this is an unrecoverable error. However, the command // data later, this is an unrecoverable error. However, the command
// that uses the data may have already completed previously, so the // that uses the data may have already completed previously, so the
// possible failure will occur during source block verification. // possible failure will occur during source block verification.
fprintf(stderr, "failed to load source blocks for stash %s\n", id.c_str()); LOG(ERROR) << "failed to load source blocks for stash " << id;
return 0; return 0;
} }
@@ -814,7 +811,7 @@ static int SaveStash(CommandParameters& params, const std::string& base,
return 0; return 0;
} }
fprintf(stderr, "stashing %zu blocks to %s\n", blocks, id.c_str()); LOG(INFO) << "stashing " << blocks << " blocks to " << id;
params.stashed += blocks; params.stashed += blocks;
return WriteStash(base, id, blocks, buffer, false, nullptr); return WriteStash(base, id, blocks, buffer, false, nullptr);
} }
@@ -870,7 +867,7 @@ static int LoadSrcTgtVersion2(CommandParameters& params, RangeSet& tgt, size_t&
// At least it needs to provide three parameters: <tgt_range>, // At least it needs to provide three parameters: <tgt_range>,
// <src_block_count> and "-"/<src_range>. // <src_block_count> and "-"/<src_range>.
if (params.cpos + 2 >= params.tokens.size()) { if (params.cpos + 2 >= params.tokens.size()) {
fprintf(stderr, "invalid parameters\n"); LOG(ERROR) << "invalid parameters";
return -1; return -1;
} }
@@ -880,7 +877,7 @@ static int LoadSrcTgtVersion2(CommandParameters& params, RangeSet& tgt, size_t&
// <src_block_count> // <src_block_count>
const std::string& token = params.tokens[params.cpos++]; const std::string& token = params.tokens[params.cpos++];
if (!android::base::ParseUint(token.c_str(), &src_blocks)) { if (!android::base::ParseUint(token.c_str(), &src_blocks)) {
fprintf(stderr, "invalid src_block_count \"%s\"\n", token.c_str()); LOG(ERROR) << "invalid src_block_count \"" << token << "\"";
return -1; return -1;
} }
@@ -920,7 +917,7 @@ static int LoadSrcTgtVersion2(CommandParameters& params, RangeSet& tgt, size_t&
// stashed data should go. // stashed data should go.
std::vector<std::string> tokens = android::base::Split(params.tokens[params.cpos++], ":"); std::vector<std::string> tokens = android::base::Split(params.tokens[params.cpos++], ":");
if (tokens.size() != 2) { if (tokens.size() != 2) {
fprintf(stderr, "invalid parameter\n"); LOG(ERROR) << "invalid parameter";
return -1; return -1;
} }
@@ -930,7 +927,7 @@ static int LoadSrcTgtVersion2(CommandParameters& params, RangeSet& tgt, size_t&
if (res == -1) { if (res == -1) {
// These source blocks will fail verification if used later, but we // These source blocks will fail verification if used later, but we
// will let the caller decide if this is a fatal failure // will let the caller decide if this is a fatal failure
fprintf(stderr, "failed to load stash %s\n", tokens[0].c_str()); LOG(ERROR) << "failed to load stash " << tokens[0];
continue; continue;
} }
@@ -964,7 +961,7 @@ static int LoadSrcTgtVersion3(CommandParameters& params, RangeSet& tgt, size_t&
bool onehash, bool& overlap) { bool onehash, bool& overlap) {
if (params.cpos >= params.tokens.size()) { if (params.cpos >= params.tokens.size()) {
fprintf(stderr, "missing source hash\n"); LOG(ERROR) << "missing source hash";
return -1; return -1;
} }
@@ -975,7 +972,7 @@ static int LoadSrcTgtVersion3(CommandParameters& params, RangeSet& tgt, size_t&
tgthash = srchash; tgthash = srchash;
} else { } else {
if (params.cpos >= params.tokens.size()) { if (params.cpos >= params.tokens.size()) {
fprintf(stderr, "missing target hash\n"); LOG(ERROR) << "missing target hash";
return -1; return -1;
} }
tgthash = params.tokens[params.cpos++]; tgthash = params.tokens[params.cpos++];
@@ -1002,13 +999,12 @@ static int LoadSrcTgtVersion3(CommandParameters& params, RangeSet& tgt, size_t&
// resume from possible write errors. In verify mode, we can skip stashing // resume from possible write errors. In verify mode, we can skip stashing
// because the source blocks won't be overwritten. // because the source blocks won't be overwritten.
if (overlap && params.canwrite) { if (overlap && params.canwrite) {
fprintf(stderr, "stashing %zu overlapping blocks to %s\n", src_blocks, LOG(INFO) << "stashing " << src_blocks << " overlapping blocks to " << srchash;
srchash.c_str());
bool stash_exists = false; bool stash_exists = false;
if (WriteStash(params.stashbase, srchash, src_blocks, params.buffer, true, if (WriteStash(params.stashbase, srchash, src_blocks, params.buffer, true,
&stash_exists) != 0) { &stash_exists) != 0) {
fprintf(stderr, "failed to stash overlapping source blocks\n"); LOG(ERROR) << "failed to stash overlapping source blocks";
return -1; return -1;
} }
@@ -1032,7 +1028,7 @@ static int LoadSrcTgtVersion3(CommandParameters& params, RangeSet& tgt, size_t&
} }
// Valid source data not available, update cannot be resumed // Valid source data not available, update cannot be resumed
fprintf(stderr, "partition has unexpected contents\n"); LOG(ERROR) << "partition has unexpected contents";
params.isunresumable = true; params.isunresumable = true;
return -1; return -1;
@@ -1054,25 +1050,25 @@ static int PerformCommandMove(CommandParameters& params) {
} }
if (status == -1) { if (status == -1) {
fprintf(stderr, "failed to read blocks for move\n"); LOG(ERROR) << "failed to read blocks for move";
return -1; return -1;
} }
if (status == 0) { if (status == 0) {
params.foundwrites = true; params.foundwrites = true;
} else if (params.foundwrites) { } else if (params.foundwrites) {
fprintf(stderr, "warning: commands executed out of order [%s]\n", params.cmdname); LOG(WARNING) << "warning: commands executed out of order [" << params.cmdname << "]";
} }
if (params.canwrite) { if (params.canwrite) {
if (status == 0) { if (status == 0) {
fprintf(stderr, " moving %zu blocks\n", blocks); LOG(INFO) << " moving " << blocks << " blocks";
if (WriteBlocks(tgt, params.buffer, params.fd) == -1) { if (WriteBlocks(tgt, params.buffer, params.fd) == -1) {
return -1; return -1;
} }
} else { } else {
fprintf(stderr, "skipping %zu already moved blocks\n", blocks); LOG(INFO) << "skipping " << blocks << " already moved blocks";
} }
} }
@@ -1095,7 +1091,7 @@ static int PerformCommandStash(CommandParameters& params) {
static int PerformCommandFree(CommandParameters& params) { static int PerformCommandFree(CommandParameters& params) {
// <stash_id> // <stash_id>
if (params.cpos >= params.tokens.size()) { if (params.cpos >= params.tokens.size()) {
fprintf(stderr, "missing stash id in free command\n"); LOG(ERROR) << "missing stash id in free command";
return -1; return -1;
} }
@@ -1116,14 +1112,14 @@ static int PerformCommandFree(CommandParameters& params) {
static int PerformCommandZero(CommandParameters& params) { static int PerformCommandZero(CommandParameters& params) {
if (params.cpos >= params.tokens.size()) { if (params.cpos >= params.tokens.size()) {
fprintf(stderr, "missing target blocks for zero\n"); LOG(ERROR) << "missing target blocks for zero";
return -1; return -1;
} }
RangeSet tgt; RangeSet tgt;
parse_range(params.tokens[params.cpos++], tgt); parse_range(params.tokens[params.cpos++], tgt);
fprintf(stderr, " zeroing %zu blocks\n", tgt.size); LOG(INFO) << " zeroing " << tgt.size << " blocks";
allocate(BLOCKSIZE, params.buffer); allocate(BLOCKSIZE, params.buffer);
memset(params.buffer.data(), 0, BLOCKSIZE); memset(params.buffer.data(), 0, BLOCKSIZE);
@@ -1160,7 +1156,7 @@ static int PerformCommandZero(CommandParameters& params) {
static int PerformCommandNew(CommandParameters& params) { static int PerformCommandNew(CommandParameters& params) {
if (params.cpos >= params.tokens.size()) { if (params.cpos >= params.tokens.size()) {
fprintf(stderr, "missing target blocks for new\n"); LOG(ERROR) << "missing target blocks for new";
return -1; return -1;
} }
@@ -1168,7 +1164,7 @@ static int PerformCommandNew(CommandParameters& params) {
parse_range(params.tokens[params.cpos++], tgt); parse_range(params.tokens[params.cpos++], tgt);
if (params.canwrite) { if (params.canwrite) {
fprintf(stderr, " writing %zu blocks of new data\n", tgt.size); LOG(INFO) << " writing " << tgt.size << " blocks of new data";
RangeSinkState rss(tgt); RangeSinkState rss(tgt);
rss.fd = params.fd; rss.fd = params.fd;
@@ -1204,19 +1200,19 @@ static int PerformCommandDiff(CommandParameters& params) {
// <offset> <length> // <offset> <length>
if (params.cpos + 1 >= params.tokens.size()) { if (params.cpos + 1 >= params.tokens.size()) {
fprintf(stderr, "missing patch offset or length for %s\n", params.cmdname); LOG(ERROR) << "missing patch offset or length for " << params.cmdname;
return -1; return -1;
} }
size_t offset; size_t offset;
if (!android::base::ParseUint(params.tokens[params.cpos++].c_str(), &offset)) { if (!android::base::ParseUint(params.tokens[params.cpos++].c_str(), &offset)) {
fprintf(stderr, "invalid patch offset\n"); LOG(ERROR) << "invalid patch offset";
return -1; return -1;
} }
size_t len; size_t len;
if (!android::base::ParseUint(params.tokens[params.cpos++].c_str(), &len)) { if (!android::base::ParseUint(params.tokens[params.cpos++].c_str(), &len)) {
fprintf(stderr, "invalid patch len\n"); LOG(ERROR) << "invalid patch len";
return -1; return -1;
} }
@@ -1234,19 +1230,19 @@ static int PerformCommandDiff(CommandParameters& params) {
} }
if (status == -1) { if (status == -1) {
fprintf(stderr, "failed to read blocks for diff\n"); LOG(ERROR) << "failed to read blocks for diff";
return -1; return -1;
} }
if (status == 0) { if (status == 0) {
params.foundwrites = true; params.foundwrites = true;
} else if (params.foundwrites) { } else if (params.foundwrites) {
fprintf(stderr, "warning: commands executed out of order [%s]\n", params.cmdname); LOG(WARNING) << "warning: commands executed out of order [" << params.cmdname << "]";
} }
if (params.canwrite) { if (params.canwrite) {
if (status == 0) { if (status == 0) {
fprintf(stderr, "patching %zu blocks to %zu\n", blocks, tgt.size); LOG(INFO) << "patching " << blocks << " blocks to " << tgt.size;
Value patch_value(VAL_BLOB, Value patch_value(VAL_BLOB,
std::string(reinterpret_cast<const char*>(params.patch_start + offset), len)); std::string(reinterpret_cast<const char*>(params.patch_start + offset), len));
@@ -1268,24 +1264,24 @@ static int PerformCommandDiff(CommandParameters& params) {
if (params.cmdname[0] == 'i') { // imgdiff if (params.cmdname[0] == 'i') { // imgdiff
if (ApplyImagePatch(params.buffer.data(), blocks * BLOCKSIZE, &patch_value, if (ApplyImagePatch(params.buffer.data(), blocks * BLOCKSIZE, &patch_value,
&RangeSinkWrite, &rss, nullptr, nullptr) != 0) { &RangeSinkWrite, &rss, nullptr, nullptr) != 0) {
fprintf(stderr, "Failed to apply image patch.\n"); LOG(ERROR) << "Failed to apply image patch.";
return -1; return -1;
} }
} else { } else {
if (ApplyBSDiffPatch(params.buffer.data(), blocks * BLOCKSIZE, &patch_value, if (ApplyBSDiffPatch(params.buffer.data(), blocks * BLOCKSIZE, &patch_value,
0, &RangeSinkWrite, &rss, nullptr) != 0) { 0, &RangeSinkWrite, &rss, nullptr) != 0) {
fprintf(stderr, "Failed to apply bsdiff patch.\n"); LOG(ERROR) << "Failed to apply bsdiff patch.";
return -1; return -1;
} }
} }
// We expect the output of the patcher to fill the tgt ranges exactly. // We expect the output of the patcher to fill the tgt ranges exactly.
if (rss.p_block != tgt.count || rss.p_remain != 0) { if (rss.p_block != tgt.count || rss.p_remain != 0) {
fprintf(stderr, "range sink underrun?\n"); LOG(ERROR) << "range sink underrun?";
} }
} else { } else {
fprintf(stderr, "skipping %zu blocks already patched to %zu [%s]\n", LOG(INFO) << "skipping " << blocks << " blocks already patched to " << tgt.size
blocks, tgt.size, params.cmdline); << " [" << params.cmdline << "]";
} }
} }
@@ -1306,17 +1302,17 @@ static int PerformCommandErase(CommandParameters& params) {
struct stat sb; struct stat sb;
if (fstat(params.fd, &sb) == -1) { if (fstat(params.fd, &sb) == -1) {
fprintf(stderr, "failed to fstat device to erase: %s\n", strerror(errno)); PLOG(ERROR) << "failed to fstat device to erase";
return -1; return -1;
} }
if (!S_ISBLK(sb.st_mode)) { if (!S_ISBLK(sb.st_mode)) {
fprintf(stderr, "not a block device; skipping erase\n"); LOG(ERROR) << "not a block device; skipping erase";
return -1; return -1;
} }
if (params.cpos >= params.tokens.size()) { if (params.cpos >= params.tokens.size()) {
fprintf(stderr, "missing target blocks for erase\n"); LOG(ERROR) << "missing target blocks for erase";
return -1; return -1;
} }
@@ -1324,7 +1320,7 @@ static int PerformCommandErase(CommandParameters& params) {
parse_range(params.tokens[params.cpos++], tgt); parse_range(params.tokens[params.cpos++], tgt);
if (params.canwrite) { if (params.canwrite) {
fprintf(stderr, " erasing %zu blocks\n", tgt.size); LOG(INFO) << " erasing " << tgt.size << " blocks";
for (size_t i = 0; i < tgt.count; ++i) { for (size_t i = 0; i < tgt.count; ++i) {
uint64_t blocks[2]; uint64_t blocks[2];
@@ -1334,7 +1330,7 @@ static int PerformCommandErase(CommandParameters& params) {
blocks[1] = (tgt.pos[i * 2 + 1] - tgt.pos[i * 2]) * (uint64_t) BLOCKSIZE; blocks[1] = (tgt.pos[i * 2 + 1] - tgt.pos[i * 2]) * (uint64_t) BLOCKSIZE;
if (ioctl(params.fd, BLKDISCARD, &blocks) == -1) { if (ioctl(params.fd, BLKDISCARD, &blocks) == -1) {
fprintf(stderr, "BLKDISCARD ioctl failed: %s\n", strerror(errno)); PLOG(ERROR) << "BLKDISCARD ioctl failed";
return -1; return -1;
} }
} }
@@ -1362,10 +1358,10 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg
CommandParameters params = {}; CommandParameters params = {};
params.canwrite = !dryrun; params.canwrite = !dryrun;
fprintf(stderr, "performing %s\n", dryrun ? "verification" : "update"); LOG(INFO) << "performing " << dryrun ? "verification" : "update";
if (state->is_retry) { if (state->is_retry) {
is_retry = true; is_retry = true;
fprintf(stderr, "This update is a retry.\n"); LOG(INFO) << "This update is a retry.";
} }
std::vector<std::unique_ptr<Value>> args; std::vector<std::unique_ptr<Value>> args;
@@ -1413,7 +1409,7 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg
ZipString path_data(patch_data_fn->data.c_str()); ZipString path_data(patch_data_fn->data.c_str());
ZipEntry patch_entry; ZipEntry patch_entry;
if (FindEntry(za, path_data, &patch_entry) != 0) { if (FindEntry(za, path_data, &patch_entry) != 0) {
fprintf(stderr, "%s(): no file \"%s\" in package", name, patch_data_fn->data.c_str()); LOG(ERROR) << name << "(): no file \"" << patch_data_fn->data << "\" in package";
return StringValue(""); return StringValue("");
} }
@@ -1421,13 +1417,13 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg
ZipString new_data(new_data_fn->data.c_str()); ZipString new_data(new_data_fn->data.c_str());
ZipEntry new_entry; ZipEntry new_entry;
if (FindEntry(za, new_data, &new_entry) != 0) { if (FindEntry(za, new_data, &new_entry) != 0) {
fprintf(stderr, "%s(): no file \"%s\" in package", name, new_data_fn->data.c_str()); LOG(ERROR) << name << "(): no file \"" << new_data_fn->data << "\" in package";
return StringValue(""); return StringValue("");
} }
params.fd.reset(TEMP_FAILURE_RETRY(ota_open(blockdev_filename->data.c_str(), O_RDWR))); params.fd.reset(TEMP_FAILURE_RETRY(ota_open(blockdev_filename->data.c_str(), O_RDWR)));
if (params.fd == -1) { if (params.fd == -1) {
fprintf(stderr, "open \"%s\" failed: %s\n", blockdev_filename->data.c_str(), strerror(errno)); PLOG(ERROR) << "open \"" << blockdev_filename->data << "\" failed";
return StringValue(""); return StringValue("");
} }
@@ -1443,7 +1439,7 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg
int error = pthread_create(&params.thread, &attr, unzip_new_data, &params.nti); int error = pthread_create(&params.thread, &attr, unzip_new_data, &params.nti);
if (error != 0) { if (error != 0) {
fprintf(stderr, "pthread_create failed: %s\n", strerror(error)); PLOG(ERROR) << "pthread_create failed";
return StringValue(""); return StringValue("");
} }
} }
@@ -1457,11 +1453,11 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg
// First line in transfer list is the version number // First line in transfer list is the version number
if (!android::base::ParseInt(lines[0].c_str(), &params.version, 1, 4)) { if (!android::base::ParseInt(lines[0].c_str(), &params.version, 1, 4)) {
fprintf(stderr, "unexpected transfer list version [%s]\n", lines[0].c_str()); LOG(ERROR) << "unexpected transfer list version [" << lines[0] << "]";
return StringValue(""); return StringValue("");
} }
fprintf(stderr, "blockimg version is %d\n", params.version); LOG(INFO) << "blockimg version is " << params.version;
// Second line in transfer list is the total number of blocks we expect to write // Second line in transfer list is the total number of blocks we expect to write
int total_blocks; int total_blocks;
@@ -1483,7 +1479,7 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg
} }
// Third line is how many stash entries are needed simultaneously // Third line is how many stash entries are needed simultaneously
fprintf(stderr, "maximum stash entries %s\n", lines[2].c_str()); LOG(INFO) << "maximum stash entries " << lines[2];
// Fourth line is the maximum number of blocks that will be stashed simultaneously // Fourth line is the maximum number of blocks that will be stashed simultaneously
int stash_max_blocks; int stash_max_blocks;
@@ -1507,8 +1503,8 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg
std::unordered_map<std::string, const Command*> cmd_map; std::unordered_map<std::string, const Command*> cmd_map;
for (size_t i = 0; i < cmdcount; ++i) { for (size_t i = 0; i < cmdcount; ++i) {
if (cmd_map.find(commands[i].name) != cmd_map.end()) { if (cmd_map.find(commands[i].name) != cmd_map.end()) {
fprintf(stderr, "Error: command [%s] already exists in the cmd map.\n", LOG(ERROR) << "Error: command [" << commands[i].name
commands[i].name); << "] already exists in the cmd map.";
return StringValue(strdup("")); return StringValue(strdup(""));
} }
cmd_map[commands[i].name] = &commands[i]; cmd_map[commands[i].name] = &commands[i];
@@ -1529,21 +1525,21 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg
params.cmdline = line_str.c_str(); params.cmdline = line_str.c_str();
if (cmd_map.find(params.cmdname) == cmd_map.end()) { if (cmd_map.find(params.cmdname) == cmd_map.end()) {
fprintf(stderr, "unexpected command [%s]\n", params.cmdname); LOG(ERROR) << "unexpected command [" << params.cmdname << "]";
goto pbiudone; goto pbiudone;
} }
const Command* cmd = cmd_map[params.cmdname]; const Command* cmd = cmd_map[params.cmdname];
if (cmd->f != nullptr && cmd->f(params) == -1) { if (cmd->f != nullptr && cmd->f(params) == -1) {
fprintf(stderr, "failed to execute command [%s]\n", line_str.c_str()); LOG(ERROR) << "failed to execute command [" << line_str << "]";
goto pbiudone; goto pbiudone;
} }
if (params.canwrite) { if (params.canwrite) {
if (ota_fsync(params.fd) == -1) { if (ota_fsync(params.fd) == -1) {
failure_type = kFsyncFailure; failure_type = kFsyncFailure;
fprintf(stderr, "fsync failed: %s\n", strerror(errno)); PLOG(ERROR) << "fsync failed";
goto pbiudone; goto pbiudone;
} }
fprintf(cmd_pipe, "set_progress %.4f\n", (double) params.written / total_blocks); fprintf(cmd_pipe, "set_progress %.4f\n", (double) params.written / total_blocks);
@@ -1554,9 +1550,9 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg
if (params.canwrite) { if (params.canwrite) {
pthread_join(params.thread, nullptr); pthread_join(params.thread, nullptr);
fprintf(stderr, "wrote %zu blocks; expected %d\n", params.written, total_blocks); LOG(INFO) << "wrote " << params.written << " blocks; expected " << total_blocks;
fprintf(stderr, "stashed %zu blocks\n", params.stashed); LOG(INFO) << "stashed " << params.stashed << " blocks";
fprintf(stderr, "max alloc needed was %zu\n", params.buffer.size()); LOG(INFO) << "max alloc needed was " << params.buffer.size();
const char* partition = strrchr(blockdev_filename->data.c_str(), '/'); const char* partition = strrchr(blockdev_filename->data.c_str(), '/');
if (partition != nullptr && *(partition+1) != 0) { if (partition != nullptr && *(partition+1) != 0) {
@@ -1570,7 +1566,7 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg
// may contain blocks needed to complete the update later. // may contain blocks needed to complete the update later.
DeleteStash(params.stashbase); DeleteStash(params.stashbase);
} else { } else {
fprintf(stderr, "verified partition contents; update may be resumed\n"); LOG(INFO) << "verified partition contents; update may be resumed";
} }
rc = 0; rc = 0;
@@ -1578,7 +1574,7 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int /* arg
pbiudone: pbiudone:
if (ota_fsync(params.fd) == -1) { if (ota_fsync(params.fd) == -1) {
failure_type = kFsyncFailure; failure_type = kFsyncFailure;
fprintf(stderr, "fsync failed: %s\n", strerror(errno)); PLOG(ERROR) << "fsync failed";
} }
// params.fd will be automatically closed because it's a unique_fd. // params.fd will be automatically closed because it's a unique_fd.
@@ -1813,7 +1809,7 @@ Value* BlockImageRecoverFn(const char* name, State* state, int argc, Expr* argv[
} }
// Output notice to log when recover is attempted // Output notice to log when recover is attempted
fprintf(stderr, "%s image corrupted, attempting to recover...\n", filename->data.c_str()); LOG(INFO) << filename->data << " image corrupted, attempting to recover...";
// When opened with O_RDWR, libfec rewrites corrupted blocks when they are read // When opened with O_RDWR, libfec rewrites corrupted blocks when they are read
fec::io fh(filename->data.c_str(), O_RDWR); fec::io fh(filename->data.c_str(), O_RDWR);
@@ -1866,7 +1862,7 @@ Value* BlockImageRecoverFn(const char* name, State* state, int argc, Expr* argv[
// read and check if the errors field value has increased. // read and check if the errors field value has increased.
} }
} }
fprintf(stderr, "...%s image recovered successfully.\n", filename->data.c_str()); LOG(INFO) << "..." << filename->data << " image recovered successfully.";
return StringValue("t"); return StringValue("t");
} }
updater/install.cpp
+136 -136
View File
@@ -40,6 +40,7 @@
#include <vector> #include <vector>
#include <android-base/file.h> #include <android-base/file.h>
#include <android-base/logging.h>
#include <android-base/parsedouble.h> #include <android-base/parsedouble.h>
#include <android-base/parseint.h> #include <android-base/parseint.h>
#include <android-base/properties.h> #include <android-base/properties.h>
@@ -72,7 +73,7 @@ static void uiPrint(State* state, const std::string& buffer) {
// "line1\nline2\n" will be split into 3 tokens: "line1", "line2" and "". // "line1\nline2\n" will be split into 3 tokens: "line1", "line2" and "".
// So skip sending empty strings to UI. // So skip sending empty strings to UI.
std::vector<std::string> lines = android::base::Split(buffer, "\n"); std::vector<std::string> lines = android::base::Split(buffer, "\n");
for (auto& line: lines) { for (auto& line : lines) {
if (!line.empty()) { if (!line.empty()) {
fprintf(ui->cmd_pipe, "ui_print %s\n", line.c_str()); fprintf(ui->cmd_pipe, "ui_print %s\n", line.c_str());
fprintf(ui->cmd_pipe, "ui_print\n"); fprintf(ui->cmd_pipe, "ui_print\n");
@@ -82,7 +83,7 @@ static void uiPrint(State* state, const std::string& buffer) {
// On the updater side, we need to dump the contents to stderr (which has // On the updater side, we need to dump the contents to stderr (which has
// been redirected to the log file). Because the recovery will only print // been redirected to the log file). Because the recovery will only print
// the contents to screen when processing pipe command ui_print. // the contents to screen when processing pipe command ui_print.
fprintf(stderr, "%s", buffer.c_str()); LOG(INFO) << buffer;
} }
void uiPrintf(State* _Nonnull state, const char* _Nonnull format, ...) { void uiPrintf(State* _Nonnull state, const char* _Nonnull format, ...) {
@@ -113,12 +114,11 @@ static bool make_parents(const std::string& name) {
if (!is_dir(dir_path)) { if (!is_dir(dir_path)) {
int result = mkdir(dir_path.c_str(), 0700); int result = mkdir(dir_path.c_str(), 0700);
if (result != 0) { if (result != 0) {
printf("failed to mkdir %s when make parents for %s: %s\n", dir_path.c_str(), PLOG(ERROR) << "failed to mkdir " << dir_path << " when make parents for " << name;
name.c_str(), strerror(errno));
return false; return false;
} }
printf("created [%s]\n", dir_path.c_str()); LOG(INFO) << "created [" << dir_path << "]";
} }
prev_end = next_end; prev_end = next_end;
} }
@@ -149,16 +149,14 @@ Value* MountFn(const char* name, State* state, int argc, Expr* argv[]) {
} }
if (fs_type.empty()) { if (fs_type.empty()) {
return ErrorAbort(state, kArgsParsingFailure, "fs_type argument to %s() can't be empty", return ErrorAbort(state, kArgsParsingFailure, "fs_type argument to %s() can't be empty", name);
name);
} }
if (partition_type.empty()) { if (partition_type.empty()) {
return ErrorAbort(state, kArgsParsingFailure, "partition_type argument to %s() can't be empty", return ErrorAbort(state, kArgsParsingFailure, "partition_type argument to %s() can't be empty",
name); name);
} }
if (location.empty()) { if (location.empty()) {
return ErrorAbort(state, kArgsParsingFailure, "location argument to %s() can't be empty", return ErrorAbort(state, kArgsParsingFailure, "location argument to %s() can't be empty", name);
name);
} }
if (mount_point.empty()) { if (mount_point.empty()) {
return ErrorAbort(state, kArgsParsingFailure, "mount_point argument to %s() can't be empty", return ErrorAbort(state, kArgsParsingFailure, "mount_point argument to %s() can't be empty",
@@ -166,7 +164,7 @@ Value* MountFn(const char* name, State* state, int argc, Expr* argv[]) {
} }
{ {
char *secontext = NULL; char* secontext = nullptr;
if (sehandle) { if (sehandle) {
selabel_lookup(sehandle, &secontext, mount_point.c_str(), 0755); selabel_lookup(sehandle, &secontext, mount_point.c_str(), 0755);
@@ -177,14 +175,14 @@ Value* MountFn(const char* name, State* state, int argc, Expr* argv[]) {
if (secontext) { if (secontext) {
freecon(secontext); freecon(secontext);
setfscreatecon(NULL); setfscreatecon(nullptr);
} }
} }
if (mount(location.c_str(), mount_point.c_str(), fs_type.c_str(), if (mount(location.c_str(), mount_point.c_str(), fs_type.c_str(),
MS_NOATIME | MS_NODEV | MS_NODIRATIME, mount_options.c_str()) < 0) { MS_NOATIME | MS_NODEV | MS_NODIRATIME, mount_options.c_str()) < 0) {
uiPrintf(state, "%s: failed to mount %s at %s: %s\n", uiPrintf(state, "%s: failed to mount %s at %s: %s\n", name, location.c_str(),
name, location.c_str(), mount_point.c_str(), strerror(errno)); mount_point.c_str(), strerror(errno));
return StringValue(""); return StringValue("");
} }
@@ -217,7 +215,6 @@ Value* IsMountedFn(const char* name, State* state, int argc, Expr* argv[]) {
return StringValue(mount_point); return StringValue(mount_point);
} }
Value* UnmountFn(const char* name, State* state, int argc, Expr* argv[]) { Value* UnmountFn(const char* name, State* state, int argc, Expr* argv[]) {
if (argc != 1) { if (argc != 1) {
return ErrorAbort(state, kArgsParsingFailure, "%s() expects 1 arg, got %d", name, argc); return ErrorAbort(state, kArgsParsingFailure, "%s() expects 1 arg, got %d", name, argc);
@@ -240,8 +237,7 @@ Value* UnmountFn(const char* name, State* state, int argc, Expr* argv[]) {
} else { } else {
int ret = unmount_mounted_volume(vol); int ret = unmount_mounted_volume(vol);
if (ret != 0) { if (ret != 0) {
uiPrintf(state, "unmount of %s failed (%d): %s\n", uiPrintf(state, "unmount of %s failed (%d): %s\n", mount_point.c_str(), ret, strerror(errno));
mount_point.c_str(), ret, strerror(errno));
} }
} }
@@ -249,15 +245,16 @@ Value* UnmountFn(const char* name, State* state, int argc, Expr* argv[]) {
} }
static int exec_cmd(const char* path, char* const argv[]) { static int exec_cmd(const char* path, char* const argv[]) {
int status;
pid_t child; pid_t child;
if ((child = vfork()) == 0) { if ((child = vfork()) == 0) {
execv(path, argv); execv(path, argv);
_exit(-1); _exit(-1);
} }
int status;
waitpid(child, &status, 0); waitpid(child, &status, 0);
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) { if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
printf("%s failed with status %d\n", path, WEXITSTATUS(status)); LOG(ERROR) << path << " failed with status " << WEXITSTATUS(status);
} }
return WEXITSTATUS(status); return WEXITSTATUS(status);
} }
@@ -285,54 +282,52 @@ Value* FormatFn(const char* name, State* state, int argc, Expr* argv[]) {
const std::string& mount_point = args[4]; const std::string& mount_point = args[4];
if (fs_type.empty()) { if (fs_type.empty()) {
return ErrorAbort(state, kArgsParsingFailure, "fs_type argument to %s() can't be empty", return ErrorAbort(state, kArgsParsingFailure, "fs_type argument to %s() can't be empty", name);
name);
} }
if (partition_type.empty()) { if (partition_type.empty()) {
return ErrorAbort(state, kArgsParsingFailure, return ErrorAbort(state, kArgsParsingFailure, "partition_type argument to %s() can't be empty",
"partition_type argument to %s() can't be empty", name);
}
if (location.empty()) {
return ErrorAbort(state, kArgsParsingFailure, "location argument to %s() can't be empty",
name); name);
} }
if (location.empty()) {
return ErrorAbort(state, kArgsParsingFailure, "location argument to %s() can't be empty", name);
}
if (mount_point.empty()) { if (mount_point.empty()) {
return ErrorAbort(state, kArgsParsingFailure, return ErrorAbort(state, kArgsParsingFailure, "mount_point argument to %s() can't be empty",
"mount_point argument to %s() can't be empty", name); name);
} }
int64_t size; int64_t size;
if (!android::base::ParseInt(fs_size, &size)) { if (!android::base::ParseInt(fs_size, &size)) {
return ErrorAbort(state, kArgsParsingFailure, return ErrorAbort(state, kArgsParsingFailure, "%s: failed to parse int in %s\n", name,
"%s: failed to parse int in %s\n", name, fs_size.c_str()); fs_size.c_str());
} }
if (fs_type == "ext4") { if (fs_type == "ext4") {
int status = make_ext4fs(location.c_str(), size, mount_point.c_str(), sehandle); int status = make_ext4fs(location.c_str(), size, mount_point.c_str(), sehandle);
if (status != 0) { if (status != 0) {
printf("%s: make_ext4fs failed (%d) on %s", name, status, location.c_str()); LOG(ERROR) << name << ": make_ext4fs failed (" << status << ") on " << location;
return StringValue(""); return StringValue("");
} }
return StringValue(location); return StringValue(location);
} else if (fs_type == "f2fs") { } else if (fs_type == "f2fs") {
if (size < 0) { if (size < 0) {
printf("%s: fs_size can't be negative for f2fs: %s", name, fs_size.c_str()); LOG(ERROR) << name << ": fs_size can't be negative for f2fs: " << fs_size;
return StringValue(""); return StringValue("");
} }
std::string num_sectors = std::to_string(size / 512); std::string num_sectors = std::to_string(size / 512);
const char *f2fs_path = "/sbin/mkfs.f2fs"; const char* f2fs_path = "/sbin/mkfs.f2fs";
const char* const f2fs_argv[] = {"mkfs.f2fs", "-t", "-d1", location.c_str(), const char* const f2fs_argv[] = { "mkfs.f2fs", "-t", "-d1", location.c_str(),
num_sectors.c_str(), nullptr}; num_sectors.c_str(), nullptr };
int status = exec_cmd(f2fs_path, (char* const*)f2fs_argv); int status = exec_cmd(f2fs_path, const_cast<char* const*>(f2fs_argv));
if (status != 0) { if (status != 0) {
printf("%s: mkfs.f2fs failed (%d) on %s", name, status, location.c_str()); LOG(ERROR) << name << ": mkfs.f2fs failed (" << status << ") on " << location;
return StringValue(""); return StringValue("");
} }
return StringValue(location); return StringValue(location);
} else { } else {
printf("%s: unsupported fs_type \"%s\" partition_type \"%s\"", LOG(ERROR) << name << ": unsupported fs_type \"" << fs_type << "\" partition_type \""
name, fs_type.c_str(), partition_type.c_str()); << partition_type << "\"";
} }
return nullptr; return nullptr;
@@ -354,12 +349,10 @@ Value* RenameFn(const char* name, State* state, int argc, Expr* argv[]) {
const std::string& dst_name = args[1]; const std::string& dst_name = args[1];
if (src_name.empty()) { if (src_name.empty()) {
return ErrorAbort(state, kArgsParsingFailure, "src_name argument to %s() can't be empty", return ErrorAbort(state, kArgsParsingFailure, "src_name argument to %s() can't be empty", name);
name);
} }
if (dst_name.empty()) { if (dst_name.empty()) {
return ErrorAbort(state, kArgsParsingFailure, "dst_name argument to %s() can't be empty", return ErrorAbort(state, kArgsParsingFailure, "dst_name argument to %s() can't be empty", name);
name);
} }
if (!make_parents(dst_name)) { if (!make_parents(dst_name)) {
return ErrorAbort(state, kFileRenameFailure, "Creating parent of %s failed, error %s", return ErrorAbort(state, kFileRenameFailure, "Creating parent of %s failed, error %s",
@@ -416,16 +409,16 @@ Value* ShowProgressFn(const char* name, State* state, int argc, Expr* argv[]) {
double frac; double frac;
if (!android::base::ParseDouble(frac_str.c_str(), &frac)) { if (!android::base::ParseDouble(frac_str.c_str(), &frac)) {
return ErrorAbort(state, kArgsParsingFailure, return ErrorAbort(state, kArgsParsingFailure, "%s: failed to parse double in %s\n", name,
"%s: failed to parse double in %s\n", name, frac_str.c_str()); frac_str.c_str());
} }
int sec; int sec;
if (!android::base::ParseInt(sec_str.c_str(), &sec)) { if (!android::base::ParseInt(sec_str.c_str(), &sec)) {
return ErrorAbort(state, kArgsParsingFailure, return ErrorAbort(state, kArgsParsingFailure, "%s: failed to parse int in %s\n", name,
"%s: failed to parse int in %s\n", name, sec_str.c_str()); sec_str.c_str());
} }
UpdaterInfo* ui = (UpdaterInfo*)(state->cookie); UpdaterInfo* ui = static_cast<UpdaterInfo*>(state->cookie);
fprintf(ui->cmd_pipe, "progress %f %d\n", frac, sec); fprintf(ui->cmd_pipe, "progress %f %d\n", frac, sec);
return StringValue(frac_str); return StringValue(frac_str);
@@ -444,11 +437,11 @@ Value* SetProgressFn(const char* name, State* state, int argc, Expr* argv[]) {
double frac; double frac;
if (!android::base::ParseDouble(frac_str.c_str(), &frac)) { if (!android::base::ParseDouble(frac_str.c_str(), &frac)) {
return ErrorAbort(state, kArgsParsingFailure, return ErrorAbort(state, kArgsParsingFailure, "%s: failed to parse double in %s\n", name,
"%s: failed to parse double in %s\n", name, frac_str.c_str()); frac_str.c_str());
} }
UpdaterInfo* ui = (UpdaterInfo*)(state->cookie); UpdaterInfo* ui = static_cast<UpdaterInfo*>(state->cookie);
fprintf(ui->cmd_pipe, "set_progress %f\n", frac); fprintf(ui->cmd_pipe, "set_progress %f\n", frac);
return StringValue(frac_str); return StringValue(frac_str);
@@ -505,30 +498,31 @@ Value* PackageExtractFileFn(const char* name, State* state, int argc, Expr* argv
ZipString zip_string_path(zip_path.c_str()); ZipString zip_string_path(zip_path.c_str());
ZipEntry entry; ZipEntry entry;
if (FindEntry(za, zip_string_path, &entry) != 0) { if (FindEntry(za, zip_string_path, &entry) != 0) {
printf("%s: no %s in package\n", name, zip_path.c_str()); LOG(ERROR) << name << ": no " << zip_path << " in package";
return StringValue(""); return StringValue("");
} }
unique_fd fd(TEMP_FAILURE_RETRY( unique_fd fd(TEMP_FAILURE_RETRY(
ota_open(dest_path.c_str(), O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR))); ota_open(dest_path.c_str(), O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR)));
if (fd == -1) { if (fd == -1) {
printf("%s: can't open %s for write: %s\n", name, dest_path.c_str(), strerror(errno)); PLOG(ERROR) << name << ": can't open " << dest_path << " for write";
return StringValue(""); return StringValue("");
} }
bool success = true; bool success = true;
int32_t ret = ExtractEntryToFile(za, &entry, fd); int32_t ret = ExtractEntryToFile(za, &entry, fd);
if (ret != 0) { if (ret != 0) {
printf("%s: Failed to extract entry \"%s\" (%u bytes) to \"%s\": %s\n", name, LOG(ERROR) << name << ": Failed to extract entry \"" << zip_path << "\" ("
zip_path.c_str(), entry.uncompressed_length, dest_path.c_str(), ErrorCodeString(ret)); << entry.uncompressed_length << " bytes) to \"" << dest_path
<< "\": " << ErrorCodeString(ret);
success = false; success = false;
} }
if (ota_fsync(fd) == -1) { if (ota_fsync(fd) == -1) {
printf("fsync of \"%s\" failed: %s\n", dest_path.c_str(), strerror(errno)); PLOG(ERROR) << "fsync of \"" << dest_path << "\" failed";
success = false; success = false;
} }
if (ota_close(fd) == -1) { if (ota_close(fd) == -1) {
printf("close of \"%s\" failed: %s\n", dest_path.c_str(), strerror(errno)); PLOG(ERROR) << "close of \"" << dest_path << "\" failed";
success = false; success = false;
} }
@@ -577,23 +571,21 @@ Value* SymlinkFn(const char* name, State* state, int argc, Expr* argv[]) {
} }
std::vector<std::string> srcs; std::vector<std::string> srcs;
if (!ReadArgs(state, argc-1, argv+1, &srcs)) { if (!ReadArgs(state, argc - 1, argv + 1, &srcs)) {
return ErrorAbort(state, kArgsParsingFailure, "%s(): Failed to parse the argument(s)", return ErrorAbort(state, kArgsParsingFailure, "%s(): Failed to parse the argument(s)", name);
name);
} }
size_t bad = 0; size_t bad = 0;
for (const auto& src : srcs) { for (const auto& src : srcs) {
if (unlink(src.c_str()) == -1 && errno != ENOENT) { if (unlink(src.c_str()) == -1 && errno != ENOENT) {
printf("%s: failed to remove %s: %s\n", name, src.c_str(), strerror(errno)); PLOG(ERROR) << name << ": failed to remove " << src;
++bad; ++bad;
} else if (!make_parents(src)) { } else if (!make_parents(src)) {
printf("%s: failed to symlink %s to %s: making parents failed\n", LOG(ERROR) << name << ": failed to symlink " << src << " to " << target
name, src.c_str(), target.c_str()); << ": making parents failed";
++bad; ++bad;
} else if (symlink(target.c_str(), src.c_str()) == -1) { } else if (symlink(target.c_str(), src.c_str()) == -1) {
printf("%s: failed to symlink %s to %s: %s\n", PLOG(ERROR) << name << ": failed to symlink " << src << " to " << target;
name, src.c_str(), target.c_str(), strerror(errno));
++bad; ++bad;
} }
} }
@@ -622,17 +614,16 @@ struct perm_parsed_args {
static struct perm_parsed_args ParsePermArgs(State * state, int argc, static struct perm_parsed_args ParsePermArgs(State * state, int argc,
const std::vector<std::string>& args) { const std::vector<std::string>& args) {
int i;
struct perm_parsed_args parsed; struct perm_parsed_args parsed;
int bad = 0; int bad = 0;
static int max_warnings = 20; static int max_warnings = 20;
memset(&parsed, 0, sizeof(parsed)); memset(&parsed, 0, sizeof(parsed));
for (i = 1; i < argc; i += 2) { for (int i = 1; i < argc; i += 2) {
if (args[i] == "uid") { if (args[i] == "uid") {
int64_t uid; int64_t uid;
if (sscanf(args[i+1].c_str(), "%" SCNd64, &uid) == 1) { if (sscanf(args[i + 1].c_str(), "%" SCNd64, &uid) == 1) {
parsed.uid = uid; parsed.uid = uid;
parsed.has_uid = true; parsed.has_uid = true;
} else { } else {
@@ -643,7 +634,7 @@ static struct perm_parsed_args ParsePermArgs(State * state, int argc,
} }
if (args[i] == "gid") { if (args[i] == "gid") {
int64_t gid; int64_t gid;
if (sscanf(args[i+1].c_str(), "%" SCNd64, &gid) == 1) { if (sscanf(args[i + 1].c_str(), "%" SCNd64, &gid) == 1) {
parsed.gid = gid; parsed.gid = gid;
parsed.has_gid = true; parsed.has_gid = true;
} else { } else {
@@ -654,7 +645,7 @@ static struct perm_parsed_args ParsePermArgs(State * state, int argc,
} }
if (args[i] == "mode") { if (args[i] == "mode") {
int32_t mode; int32_t mode;
if (sscanf(args[i+1].c_str(), "%" SCNi32, &mode) == 1) { if (sscanf(args[i + 1].c_str(), "%" SCNi32, &mode) == 1) {
parsed.mode = mode; parsed.mode = mode;
parsed.has_mode = true; parsed.has_mode = true;
} else { } else {
@@ -665,7 +656,7 @@ static struct perm_parsed_args ParsePermArgs(State * state, int argc,
} }
if (args[i] == "dmode") { if (args[i] == "dmode") {
int32_t mode; int32_t mode;
if (sscanf(args[i+1].c_str(), "%" SCNi32, &mode) == 1) { if (sscanf(args[i + 1].c_str(), "%" SCNi32, &mode) == 1) {
parsed.dmode = mode; parsed.dmode = mode;
parsed.has_dmode = true; parsed.has_dmode = true;
} else { } else {
@@ -676,7 +667,7 @@ static struct perm_parsed_args ParsePermArgs(State * state, int argc,
} }
if (args[i] == "fmode") { if (args[i] == "fmode") {
int32_t mode; int32_t mode;
if (sscanf(args[i+1].c_str(), "%" SCNi32, &mode) == 1) { if (sscanf(args[i + 1].c_str(), "%" SCNi32, &mode) == 1) {
parsed.fmode = mode; parsed.fmode = mode;
parsed.has_fmode = true; parsed.has_fmode = true;
} else { } else {
@@ -687,7 +678,7 @@ static struct perm_parsed_args ParsePermArgs(State * state, int argc,
} }
if (args[i] == "capabilities") { if (args[i] == "capabilities") {
int64_t capabilities; int64_t capabilities;
if (sscanf(args[i+1].c_str(), "%" SCNi64, &capabilities) == 1) { if (sscanf(args[i + 1].c_str(), "%" SCNi64, &capabilities) == 1) {
parsed.capabilities = capabilities; parsed.capabilities = capabilities;
parsed.has_capabilities = true; parsed.has_capabilities = true;
} else { } else {
@@ -697,8 +688,8 @@ static struct perm_parsed_args ParsePermArgs(State * state, int argc,
continue; continue;
} }
if (args[i] == "selabel") { if (args[i] == "selabel") {
if (!args[i+1].empty()) { if (!args[i + 1].empty()) {
parsed.selabel = args[i+1].c_str(); parsed.selabel = args[i + 1].c_str();
parsed.has_selabel = true; parsed.has_selabel = true;
} else { } else {
uiPrintf(state, "ParsePermArgs: invalid selabel \"%s\"\n", args[i + 1].c_str()); uiPrintf(state, "ParsePermArgs: invalid selabel \"%s\"\n", args[i + 1].c_str());
@@ -710,25 +701,21 @@ static struct perm_parsed_args ParsePermArgs(State * state, int argc,
printf("ParsedPermArgs: unknown key \"%s\", ignoring\n", args[i].c_str()); printf("ParsedPermArgs: unknown key \"%s\", ignoring\n", args[i].c_str());
max_warnings--; max_warnings--;
if (max_warnings == 0) { if (max_warnings == 0) {
printf("ParsedPermArgs: suppressing further warnings\n"); LOG(INFO) << "ParsedPermArgs: suppressing further warnings";
} }
} }
} }
return parsed; return parsed;
} }
static int ApplyParsedPerms( static int ApplyParsedPerms(State* state, const char* filename, const struct stat* statptr,
State * state, struct perm_parsed_args parsed) {
const char* filename,
const struct stat *statptr,
struct perm_parsed_args parsed)
{
int bad = 0; int bad = 0;
if (parsed.has_selabel) { if (parsed.has_selabel) {
if (lsetfilecon(filename, parsed.selabel) != 0) { if (lsetfilecon(filename, parsed.selabel) != 0) {
uiPrintf(state, "ApplyParsedPerms: lsetfilecon of %s to %s failed: %s\n", uiPrintf(state, "ApplyParsedPerms: lsetfilecon of %s to %s failed: %s\n", filename,
filename, parsed.selabel, strerror(errno)); parsed.selabel, strerror(errno));
bad++; bad++;
} }
} }
@@ -740,40 +727,40 @@ static int ApplyParsedPerms(
if (parsed.has_uid) { if (parsed.has_uid) {
if (chown(filename, parsed.uid, -1) < 0) { if (chown(filename, parsed.uid, -1) < 0) {
uiPrintf(state, "ApplyParsedPerms: chown of %s to %d failed: %s\n", uiPrintf(state, "ApplyParsedPerms: chown of %s to %d failed: %s\n", filename, parsed.uid,
filename, parsed.uid, strerror(errno)); strerror(errno));
bad++; bad++;
} }
} }
if (parsed.has_gid) { if (parsed.has_gid) {
if (chown(filename, -1, parsed.gid) < 0) { if (chown(filename, -1, parsed.gid) < 0) {
uiPrintf(state, "ApplyParsedPerms: chgrp of %s to %d failed: %s\n", uiPrintf(state, "ApplyParsedPerms: chgrp of %s to %d failed: %s\n", filename, parsed.gid,
filename, parsed.gid, strerror(errno)); strerror(errno));
bad++; bad++;
} }
} }
if (parsed.has_mode) { if (parsed.has_mode) {
if (chmod(filename, parsed.mode) < 0) { if (chmod(filename, parsed.mode) < 0) {
uiPrintf(state, "ApplyParsedPerms: chmod of %s to %d failed: %s\n", uiPrintf(state, "ApplyParsedPerms: chmod of %s to %d failed: %s\n", filename, parsed.mode,
filename, parsed.mode, strerror(errno)); strerror(errno));
bad++; bad++;
} }
} }
if (parsed.has_dmode && S_ISDIR(statptr->st_mode)) { if (parsed.has_dmode && S_ISDIR(statptr->st_mode)) {
if (chmod(filename, parsed.dmode) < 0) { if (chmod(filename, parsed.dmode) < 0) {
uiPrintf(state, "ApplyParsedPerms: chmod of %s to %d failed: %s\n", uiPrintf(state, "ApplyParsedPerms: chmod of %s to %d failed: %s\n", filename, parsed.dmode,
filename, parsed.dmode, strerror(errno)); strerror(errno));
bad++; bad++;
} }
} }
if (parsed.has_fmode && S_ISREG(statptr->st_mode)) { if (parsed.has_fmode && S_ISREG(statptr->st_mode)) {
if (chmod(filename, parsed.fmode) < 0) { if (chmod(filename, parsed.fmode) < 0) {
uiPrintf(state, "ApplyParsedPerms: chmod of %s to %d failed: %s\n", uiPrintf(state, "ApplyParsedPerms: chmod of %s to %d failed: %s\n", filename, parsed.fmode,
filename, parsed.fmode, strerror(errno)); strerror(errno));
bad++; bad++;
} }
} }
@@ -782,21 +769,21 @@ static int ApplyParsedPerms(
if (parsed.capabilities == 0) { if (parsed.capabilities == 0) {
if ((removexattr(filename, XATTR_NAME_CAPS) == -1) && (errno != ENODATA)) { if ((removexattr(filename, XATTR_NAME_CAPS) == -1) && (errno != ENODATA)) {
// Report failure unless it's ENODATA (attribute not set) // Report failure unless it's ENODATA (attribute not set)
uiPrintf(state, "ApplyParsedPerms: removexattr of %s to %" PRIx64 " failed: %s\n", uiPrintf(state, "ApplyParsedPerms: removexattr of %s to %" PRIx64 " failed: %s\n", filename,
filename, parsed.capabilities, strerror(errno)); parsed.capabilities, strerror(errno));
bad++; bad++;
} }
} else { } else {
struct vfs_cap_data cap_data; struct vfs_cap_data cap_data;
memset(&cap_data, 0, sizeof(cap_data)); memset(&cap_data, 0, sizeof(cap_data));
cap_data.magic_etc = VFS_CAP_REVISION | VFS_CAP_FLAGS_EFFECTIVE; cap_data.magic_etc = VFS_CAP_REVISION | VFS_CAP_FLAGS_EFFECTIVE;
cap_data.data[0].permitted = (uint32_t) (parsed.capabilities & 0xffffffff); cap_data.data[0].permitted = (uint32_t)(parsed.capabilities & 0xffffffff);
cap_data.data[0].inheritable = 0; cap_data.data[0].inheritable = 0;
cap_data.data[1].permitted = (uint32_t) (parsed.capabilities >> 32); cap_data.data[1].permitted = (uint32_t)(parsed.capabilities >> 32);
cap_data.data[1].inheritable = 0; cap_data.data[1].inheritable = 0;
if (setxattr(filename, XATTR_NAME_CAPS, &cap_data, sizeof(cap_data), 0) < 0) { if (setxattr(filename, XATTR_NAME_CAPS, &cap_data, sizeof(cap_data), 0) < 0) {
uiPrintf(state, "ApplyParsedPerms: setcap of %s to %" PRIx64 " failed: %s\n", uiPrintf(state, "ApplyParsedPerms: setcap of %s to %" PRIx64 " failed: %s\n", filename,
filename, parsed.capabilities, strerror(errno)); parsed.capabilities, strerror(errno));
bad++; bad++;
} }
} }
@@ -810,15 +797,15 @@ static int ApplyParsedPerms(
static struct perm_parsed_args recursive_parsed_args; static struct perm_parsed_args recursive_parsed_args;
static State* recursive_state; static State* recursive_state;
static int do_SetMetadataRecursive(const char* filename, const struct stat *statptr, static int do_SetMetadataRecursive(const char* filename, const struct stat* statptr, int fileflags,
int fileflags, struct FTW *pfwt) { struct FTW* pfwt) {
return ApplyParsedPerms(recursive_state, filename, statptr, recursive_parsed_args); return ApplyParsedPerms(recursive_state, filename, statptr, recursive_parsed_args);
} }
static Value* SetMetadataFn(const char* name, State* state, int argc, Expr* argv[]) { static Value* SetMetadataFn(const char* name, State* state, int argc, Expr* argv[]) {
if ((argc % 2) != 1) { if ((argc % 2) != 1) {
return ErrorAbort(state, kArgsParsingFailure, return ErrorAbort(state, kArgsParsingFailure, "%s() expects an odd number of arguments, got %d",
"%s() expects an odd number of arguments, got %d", name, argc); name, argc);
} }
std::vector<std::string> args; std::vector<std::string> args;
@@ -828,8 +815,8 @@ static Value* SetMetadataFn(const char* name, State* state, int argc, Expr* argv
struct stat sb; struct stat sb;
if (lstat(args[0].c_str(), &sb) == -1) { if (lstat(args[0].c_str(), &sb) == -1) {
return ErrorAbort(state, kSetMetadataFailure, "%s: Error on lstat of \"%s\": %s", return ErrorAbort(state, kSetMetadataFailure, "%s: Error on lstat of \"%s\": %s", name,
name, args[0].c_str(), strerror(errno)); args[0].c_str(), strerror(errno));
} }
struct perm_parsed_args parsed = ParsePermArgs(state, argc, args); struct perm_parsed_args parsed = ParsePermArgs(state, argc, args);
@@ -936,8 +923,7 @@ Value* FileGetPropFn(const char* name, State* state, int argc, Expr* argv[]) {
} }
// apply_patch_space(bytes) // apply_patch_space(bytes)
Value* ApplyPatchSpaceFn(const char* name, State* state, Value* ApplyPatchSpaceFn(const char* name, State* state, int argc, Expr* argv[]) {
int argc, Expr* argv[]) {
std::vector<std::string> args; std::vector<std::string> args;
if (!ReadArgs(state, 1, argv, &args)) { if (!ReadArgs(state, 1, argv, &args)) {
return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name);
@@ -953,8 +939,18 @@ Value* ApplyPatchSpaceFn(const char* name, State* state,
return StringValue(CacheSizeCheck(bytes) ? "" : "t"); return StringValue(CacheSizeCheck(bytes) ? "" : "t");
} }
// apply_patch(file, size, init_sha1, tgt_sha1, patch) // apply_patch(src_file, tgt_file, tgt_sha1, tgt_size, patch1_sha1, patch1_blob, [...])
// Applies a binary patch to the src_file to produce the tgt_file. If the desired target is the
// same as the source, pass "-" for tgt_file. tgt_sha1 and tgt_size are the expected final SHA1
// hash and size of the target file. The remaining arguments must come in pairs: a SHA1 hash (a
// 40-character hex string) and a blob. The blob is the patch to be applied when the source
// file's current contents have the given SHA1.
//
// The patching is done in a safe manner that guarantees the target file either has the desired
// SHA1 hash and size, or it is untouched -- it will not be left in an unrecoverable intermediate
// state. If the process is interrupted during patching, the target file may be in an intermediate
// state; a copy exists in the cache partition so restarting the update can successfully update
// the file.
Value* ApplyPatchFn(const char* name, State* state, int argc, Expr* argv[]) { Value* ApplyPatchFn(const char* name, State* state, int argc, Expr* argv[]) {
if (argc < 6 || (argc % 2) == 1) { if (argc < 6 || (argc % 2) == 1) {
return ErrorAbort(state, kArgsParsingFailure, "%s(): expected at least 6 args and an " return ErrorAbort(state, kArgsParsingFailure, "%s(): expected at least 6 args and an "
@@ -1007,12 +1003,16 @@ Value* ApplyPatchFn(const char* name, State* state, int argc, Expr* argv[]) {
return StringValue(result == 0 ? "t" : ""); return StringValue(result == 0 ? "t" : "");
} }
// apply_patch_check(file, [sha1_1, ...]) // apply_patch_check(filename, [sha1, ...])
Value* ApplyPatchCheckFn(const char* name, State* state, // Returns true if the contents of filename or the temporary copy in the cache partition (if
int argc, Expr* argv[]) { // present) have a SHA-1 checksum equal to one of the given sha1 values. sha1 values are
// specified as 40 hex digits. This function differs from sha1_check(read_file(filename),
// sha1 [, ...]) in that it knows to check the cache partition copy, so apply_patch_check() will
// succeed even if the file was corrupted by an interrupted apply_patch() update.
Value* ApplyPatchCheckFn(const char* name, State* state, int argc, Expr* argv[]) {
if (argc < 1) { if (argc < 1) {
return ErrorAbort(state, kArgsParsingFailure, "%s(): expected at least 1 arg, got %d", return ErrorAbort(state, kArgsParsingFailure, "%s(): expected at least 1 arg, got %d", name,
name, argc); argc);
} }
std::vector<std::string> args; std::vector<std::string> args;
@@ -1047,7 +1047,7 @@ Value* WipeCacheFn(const char* name, State* state, int argc, Expr* argv[]) {
if (argc != 0) { if (argc != 0) {
return ErrorAbort(state, kArgsParsingFailure, "%s() expects no args, got %d", name, argc); return ErrorAbort(state, kArgsParsingFailure, "%s() expects no args, got %d", name, argc);
} }
fprintf(((UpdaterInfo*)(state->cookie))->cmd_pipe, "wipe_cache\n"); fprintf(static_cast<UpdaterInfo*>(state->cookie)->cmd_pipe, "wipe_cache\n");
return StringValue("t"); return StringValue("t");
} }
@@ -1061,33 +1061,32 @@ Value* RunProgramFn(const char* name, State* state, int argc, Expr* argv[]) {
return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name); return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name);
} }
char* args2[argc+1]; char* args2[argc + 1];
for (int i = 0; i < argc; i++) { for (int i = 0; i < argc; i++) {
args2[i] = &args[i][0]; args2[i] = &args[i][0];
} }
args2[argc] = nullptr; args2[argc] = nullptr;
printf("about to run program [%s] with %d args\n", args2[0], argc); LOG(INFO) << "about to run program [" << args2[0] << "] with " << argc << " args";
pid_t child = fork(); pid_t child = fork();
if (child == 0) { if (child == 0) {
execv(args2[0], args2); execv(args2[0], args2);
printf("run_program: execv failed: %s\n", strerror(errno)); PLOG(ERROR) << "run_program: execv failed";
_exit(1); _exit(1);
} }
int status; int status;
waitpid(child, &status, 0); waitpid(child, &status, 0);
if (WIFEXITED(status)) { if (WIFEXITED(status)) {
if (WEXITSTATUS(status) != 0) { if (WEXITSTATUS(status) != 0) {
printf("run_program: child exited with status %d\n", LOG(ERROR) << "run_program: child exited with status " << WEXITSTATUS(status);
WEXITSTATUS(status));
} }
} else if (WIFSIGNALED(status)) { } else if (WIFSIGNALED(status)) {
printf("run_program: child terminated by signal %d\n", LOG(ERROR) << "run_program: child terminated by signal " << WTERMSIG(status);
WTERMSIG(status));
} }
return StringValue(android::base::StringPrintf("%d", status)); return StringValue(std::to_string(status));
} }
// sha1_check(data) // sha1_check(data)
@@ -1121,10 +1120,10 @@ Value* Sha1CheckFn(const char* name, State* state, int argc, Expr* argv[]) {
for (int i = 1; i < argc; ++i) { for (int i = 1; i < argc; ++i) {
uint8_t arg_digest[SHA_DIGEST_LENGTH]; uint8_t arg_digest[SHA_DIGEST_LENGTH];
if (args[i]->type != VAL_STRING) { if (args[i]->type != VAL_STRING) {
printf("%s(): arg %d is not a string; skipping", name, i); LOG(ERROR) << name << "(): arg " << i << " is not a string; skipping";
} else if (ParseSha1(args[i]->data.c_str(), arg_digest) != 0) { } else if (ParseSha1(args[i]->data.c_str(), arg_digest) != 0) {
// Warn about bad args and skip them. // Warn about bad args and skip them.
printf("%s(): error parsing \"%s\" as sha-1; skipping", name, args[i]->data.c_str()); LOG(ERROR) << name << "(): error parsing \"" << args[i]->data << "\" as sha-1; skipping";
} else if (memcmp(digest, arg_digest, SHA_DIGEST_LENGTH) == 0) { } else if (memcmp(digest, arg_digest, SHA_DIGEST_LENGTH) == 0) {
// Found a match. // Found a match.
return args[i].release(); return args[i].release();
@@ -1178,7 +1177,7 @@ Value* WriteValueFn(const char* name, State* state, int argc, Expr* argv[]) {
const std::string& value = args[0]; const std::string& value = args[0];
if (!android::base::WriteStringToFile(value, filename)) { if (!android::base::WriteStringToFile(value, filename)) {
printf("%s: Failed to write to \"%s\": %s\n", name, filename.c_str(), strerror(errno)); PLOG(ERROR) << name << ": Failed to write to \"" << filename << "\"";
return StringValue(""); return StringValue("");
} else { } else {
return StringValue("t"); return StringValue("t");
@@ -1210,12 +1209,12 @@ Value* RebootNowFn(const char* name, State* state, int argc, Expr* argv[]) {
bootloader_message boot; bootloader_message boot;
std::string err; std::string err;
if (!read_bootloader_message_from(&boot, filename, &err)) { if (!read_bootloader_message_from(&boot, filename, &err)) {
printf("%s(): Failed to read from \"%s\": %s", name, filename.c_str(), err.c_str()); LOG(ERROR) << name << "(): Failed to read from \"" << filename << "\": " << err;
return StringValue(""); return StringValue("");
} }
memset(boot.command, 0, sizeof(boot.command)); memset(boot.command, 0, sizeof(boot.command));
if (!write_bootloader_message_to(boot, filename, &err)) { if (!write_bootloader_message_to(boot, filename, &err)) {
printf("%s(): Failed to write to \"%s\": %s", name, filename.c_str(), err.c_str()); LOG(ERROR) << name << "(): Failed to write to \"" << filename << "\": " << err;
return StringValue(""); return StringValue("");
} }
@@ -1255,12 +1254,12 @@ Value* SetStageFn(const char* name, State* state, int argc, Expr* argv[]) {
bootloader_message boot; bootloader_message boot;
std::string err; std::string err;
if (!read_bootloader_message_from(&boot, filename, &err)) { if (!read_bootloader_message_from(&boot, filename, &err)) {
printf("%s(): Failed to read from \"%s\": %s", name, filename.c_str(), err.c_str()); LOG(ERROR) << name << "(): Failed to read from \"" << filename << "\": " << err;
return StringValue(""); return StringValue("");
} }
strlcpy(boot.stage, stagestr.c_str(), sizeof(boot.stage)); strlcpy(boot.stage, stagestr.c_str(), sizeof(boot.stage));
if (!write_bootloader_message_to(boot, filename, &err)) { if (!write_bootloader_message_to(boot, filename, &err)) {
printf("%s(): Failed to write to \"%s\": %s", name, filename.c_str(), err.c_str()); LOG(ERROR) << name << "(): Failed to write to \"" << filename << "\": " << err;
return StringValue(""); return StringValue("");
} }
@@ -1283,7 +1282,7 @@ Value* GetStageFn(const char* name, State* state, int argc, Expr* argv[]) {
bootloader_message boot; bootloader_message boot;
std::string err; std::string err;
if (!read_bootloader_message_from(&boot, filename, &err)) { if (!read_bootloader_message_from(&boot, filename, &err)) {
printf("%s(): Failed to read from \"%s\": %s", name, filename.c_str(), err.c_str()); LOG(ERROR) << name << "(): Failed to read from \"" << filename << "\": " << err;
return StringValue(""); return StringValue("");
} }
@@ -1317,7 +1316,7 @@ Value* EnableRebootFn(const char* name, State* state, int argc, Expr* argv[]) {
if (argc != 0) { if (argc != 0) {
return ErrorAbort(state, kArgsParsingFailure, "%s() expects no args, got %d", name, argc); return ErrorAbort(state, kArgsParsingFailure, "%s() expects no args, got %d", name, argc);
} }
UpdaterInfo* ui = (UpdaterInfo*)(state->cookie); UpdaterInfo* ui = static_cast<UpdaterInfo*>(state->cookie);
fprintf(ui->cmd_pipe, "enable_reboot\n"); fprintf(ui->cmd_pipe, "enable_reboot\n");
return StringValue("t"); return StringValue("t");
} }
@@ -1332,7 +1331,7 @@ Value* Tune2FsFn(const char* name, State* state, int argc, Expr* argv[]) {
return ErrorAbort(state, kArgsParsingFailure, "%s() could not read args", name); return ErrorAbort(state, kArgsParsingFailure, "%s() could not read args", name);
} }
char* args2[argc+1]; char* args2[argc + 1];
// Tune2fs expects the program name as its args[0] // Tune2fs expects the program name as its args[0]
args2[0] = const_cast<char*>(name); args2[0] = const_cast<char*>(name);
if (args2[0] == nullptr) { if (args2[0] == nullptr) {
@@ -1345,7 +1344,6 @@ Value* Tune2FsFn(const char* name, State* state, int argc, Expr* argv[]) {
// tune2fs changes the file system parameters on an ext2 file system; it // tune2fs changes the file system parameters on an ext2 file system; it
// returns 0 on success. // returns 0 on success.
int result = tune2fs_main(argc + 1, args2); int result = tune2fs_main(argc + 1, args2);
if (result != 0) { if (result != 0) {
return ErrorAbort(state, kTune2FsFailure, "%s() returned error code %d", name, result); return ErrorAbort(state, kTune2FsFailure, "%s() returned error code %d", name, result);
} }
@@ -1368,13 +1366,15 @@ void RegisterInstallFunctions() {
// Usage: // Usage:
// set_metadata("filename", "key1", "value1", "key2", "value2", ...) // set_metadata("filename", "key1", "value1", "key2", "value2", ...)
// Example: // Example:
// set_metadata("/system/bin/netcfg", "uid", 0, "gid", 3003, "mode", 02750, "selabel", "u:object_r:system_file:s0", "capabilities", 0x0); // set_metadata("/system/bin/netcfg", "uid", 0, "gid", 3003, "mode", 02750, "selabel",
// "u:object_r:system_file:s0", "capabilities", 0x0);
RegisterFunction("set_metadata", SetMetadataFn); RegisterFunction("set_metadata", SetMetadataFn);
// Usage: // Usage:
// set_metadata_recursive("dirname", "key1", "value1", "key2", "value2", ...) // set_metadata_recursive("dirname", "key1", "value1", "key2", "value2", ...)
// Example: // Example:
// set_metadata_recursive("/system", "uid", 0, "gid", 0, "fmode", 0644, "dmode", 0755, "selabel", "u:object_r:system_file:s0", "capabilities", 0x0); // set_metadata_recursive("/system", "uid", 0, "gid", 0, "fmode", 0644, "dmode", 0755,
// "selabel", "u:object_r:system_file:s0", "capabilities", 0x0);
RegisterFunction("set_metadata_recursive", SetMetadataFn); RegisterFunction("set_metadata_recursive", SetMetadataFn);
RegisterFunction("getprop", GetPropFn); RegisterFunction("getprop", GetPropFn);
updater/updater.cpp
+27 -22
View File
@@ -23,6 +23,7 @@
#include <string> #include <string>
#include <android-base/logging.h>
#include <android-base/strings.h> #include <android-base/strings.h>
#include <selinux/label.h> #include <selinux/label.h>
#include <selinux/selinux.h> #include <selinux/selinux.h>
@@ -42,32 +43,39 @@
// Where in the package we expect to find the edify script to execute. // Where in the package we expect to find the edify script to execute.
// (Note it's "updateR-script", not the older "update-script".) // (Note it's "updateR-script", not the older "update-script".)
#define SCRIPT_NAME "META-INF/com/google/android/updater-script" static constexpr const char* SCRIPT_NAME = "META-INF/com/google/android/updater-script";
extern bool have_eio_error; extern bool have_eio_error;
struct selabel_handle *sehandle; struct selabel_handle *sehandle;
static void UpdaterLogger(android::base::LogId /* id */, android::base::LogSeverity /* severity */,
const char* /* tag */, const char* /* file */, unsigned int /* line */,
const char* message) {
fprintf(stdout, "%s\n", message);
}
int main(int argc, char** argv) { int main(int argc, char** argv) {
// Various things log information to stdout or stderr more or less // Various things log information to stdout or stderr more or less
// at random (though we've tried to standardize on stdout). The // at random (though we've tried to standardize on stdout). The
// log file makes more sense if buffering is turned off so things // log file makes more sense if buffering is turned off so things
// appear in the right order. // appear in the right order.
setbuf(stdout, NULL); setbuf(stdout, nullptr);
setbuf(stderr, NULL); setbuf(stderr, nullptr);
// We don't have logcat yet under recovery. Update logs will always be written to stdout
// (which is redirected to recovery.log).
android::base::InitLogging(argv, &UpdaterLogger);
if (argc != 4 && argc != 5) { if (argc != 4 && argc != 5) {
printf("unexpected number of arguments (%d)\n", argc); LOG(ERROR) << "unexpected number of arguments: " << argc;
return 1; return 1;
} }
char* version = argv[1]; char* version = argv[1];
if ((version[0] != '1' && version[0] != '2' && version[0] != '3') || if ((version[0] != '1' && version[0] != '2' && version[0] != '3') || version[1] != '\0') {
version[1] != '\0') {
// We support version 1, 2, or 3. // We support version 1, 2, or 3.
printf("wrong updater binary API; expected 1, 2, or 3; " LOG(ERROR) << "wrong updater binary API; expected 1, 2, or 3; got " << argv[1];
"got %s\n",
argv[1]);
return 2; return 2;
} }
@@ -82,14 +90,13 @@ int main(int argc, char** argv) {
const char* package_filename = argv[3]; const char* package_filename = argv[3];
MemMapping map; MemMapping map;
if (sysMapFile(package_filename, &map) != 0) { if (sysMapFile(package_filename, &map) != 0) {
printf("failed to map package %s\n", argv[3]); LOG(ERROR) << "failed to map package " << argv[3];
return 3; return 3;
} }
ZipArchiveHandle za; ZipArchiveHandle za;
int open_err = OpenArchiveFromMemory(map.addr, map.length, argv[3], &za); int open_err = OpenArchiveFromMemory(map.addr, map.length, argv[3], &za);
if (open_err != 0) { if (open_err != 0) {
printf("failed to open package %s: %s\n", LOG(ERROR) << "failed to open package " << argv[3] << ": " << ErrorCodeString(open_err);
argv[3], ErrorCodeString(open_err));
CloseArchive(za); CloseArchive(za);
return 3; return 3;
} }
@@ -99,8 +106,8 @@ int main(int argc, char** argv) {
ZipEntry script_entry; ZipEntry script_entry;
int find_err = FindEntry(za, script_name, &script_entry); int find_err = FindEntry(za, script_name, &script_entry);
if (find_err != 0) { if (find_err != 0) {
printf("failed to find %s in %s: %s\n", SCRIPT_NAME, package_filename, LOG(ERROR) << "failed to find " << SCRIPT_NAME << " in " << package_filename << ": "
ErrorCodeString(find_err)); << ErrorCodeString(find_err);
CloseArchive(za); CloseArchive(za);
return 4; return 4;
} }
@@ -110,7 +117,7 @@ int main(int argc, char** argv) {
int extract_err = ExtractToMemory(za, &script_entry, reinterpret_cast<uint8_t*>(&script[0]), int extract_err = ExtractToMemory(za, &script_entry, reinterpret_cast<uint8_t*>(&script[0]),
script_entry.uncompressed_length); script_entry.uncompressed_length);
if (extract_err != 0) { if (extract_err != 0) {
printf("failed to read script from package: %s\n", ErrorCodeString(extract_err)); LOG(ERROR) << "failed to read script from package: " << ErrorCodeString(extract_err);
CloseArchive(za); CloseArchive(za);
return 5; return 5;
} }
@@ -128,14 +135,12 @@ int main(int argc, char** argv) {
int error_count = 0; int error_count = 0;
int error = parse_string(script.c_str(), &root, &error_count); int error = parse_string(script.c_str(), &root, &error_count);
if (error != 0 || error_count > 0) { if (error != 0 || error_count > 0) {
printf("%d parse errors\n", error_count); LOG(ERROR) << error_count << " parse errors";
CloseArchive(za); CloseArchive(za);
return 6; return 6;
} }
struct selinux_opt seopts[] = { struct selinux_opt seopts[] = { { SELABEL_OPT_PATH, "/file_contexts" } };
{ SELABEL_OPT_PATH, "/file_contexts" }
};
sehandle = selabel_open(SELABEL_CTX_FILE, seopts, 1); sehandle = selabel_open(SELABEL_CTX_FILE, seopts, 1);
@@ -171,17 +176,17 @@ int main(int argc, char** argv) {
if (!status) { if (!status) {
if (state.errmsg.empty()) { if (state.errmsg.empty()) {
printf("script aborted (no error message)\n"); LOG(ERROR) << "script aborted (no error message)";
fprintf(cmd_pipe, "ui_print script aborted (no error message)\n"); fprintf(cmd_pipe, "ui_print script aborted (no error message)\n");
} else { } else {
printf("script aborted: %s\n", state.errmsg.c_str()); LOG(ERROR) << "script aborted: " << state.errmsg;
const std::vector<std::string> lines = android::base::Split(state.errmsg, "\n"); const std::vector<std::string> lines = android::base::Split(state.errmsg, "\n");
for (const std::string& line : lines) { for (const std::string& line : lines) {
// Parse the error code in abort message. // Parse the error code in abort message.
// Example: "E30: This package is for bullhead devices." // Example: "E30: This package is for bullhead devices."
if (!line.empty() && line[0] == 'E') { if (!line.empty() && line[0] == 'E') {
if (sscanf(line.c_str(), "E%u: ", &state.error_code) != 1) { if (sscanf(line.c_str(), "E%u: ", &state.error_code) != 1) {
printf("Failed to parse error code: [%s]\n", line.c_str()); LOG(ERROR) << "Failed to parse error code: [" << line << "]";
} }
} }
fprintf(cmd_pipe, "ui_print %s\n", line.c_str()); fprintf(cmd_pipe, "ui_print %s\n", line.c_str());