tequilaOS/platform_bootable_recovery
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Drop the dependency on AB_OTA_UPDATER flag.

Browse source 
This shortens the gap between A/B and non-A/B builds, by replacing the
dependency on build-time flag with runtime detection instead. It also
allows building and testing both paths regardless of the target OTA
type.

The size increase to /sbin/recovery looks negligible (< 0.01%).
 - marlin: increased from 2084928 to 2085024;
 - angler: increased from 2084776 to 2084896.

Test: Run recovery_component_test on angler and marlin.
Test: Sideload an A/B OTA package on marlin.
Test: Sideload a non-A/B OTA package on angler.
Change-Id: I1d927d1ede9713fb42f73b4fe324aa5705ee6f99
This commit is contained in:
Tao Bao 2018-06-18 14:56:20 -07:00
parent 5af63a45d9
commit cf60a44bd4
7 changed files with 126 additions and 127 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Android.mk
View file

@ -143,10 +143,6 @@ LOCAL_C_INCLUDES := \
LOCAL_CFLAGS := $(recovery_common_cflags)
ifeq ($(AB_OTA_UPDATER),true)
LOCAL_CFLAGS += -DAB_OTA_UPDATER=1
endif
LOCAL_MODULE := librecovery
LOCAL_STATIC_LIBRARIES := \

39
install.cpp
View file

@ -45,6 +45,7 @@
#include <android-base/properties.h>
#include <android-base/stringprintf.h>
#include <android-base/strings.h>
#include <android-base/unique_fd.h>
#include <vintf/VintfObjectRecovery.h>
#include <ziparchive/zip_archive.h>
@ -124,11 +125,9 @@ static void read_source_target_build(ZipArchiveHandle zip, std::vector<std::stri
}
}
#ifdef AB_OTA_UPDATER
// Parses the metadata of the OTA package in |zip| and checks whether we are
// allowed to accept this A/B package. Downgrading is not allowed unless
// explicitly enabled in the package and only for incremental packages.
// Parses the metadata of the OTA package in |zip| and checks whether we are allowed to accept this
// A/B package. Downgrading is not allowed unless explicitly enabled in the package and only for
// incremental packages.
static int check_newer_ab_build(ZipArchiveHandle zip) {
std::string metadata_str;
if (!read_metadata_from_package(zip, &metadata_str)) {
@ -214,8 +213,7 @@ static int check_newer_ab_build(ZipArchiveHandle zip) {
return 0;
}
int update_binary_command(const std::string& package, ZipArchiveHandle zip,
const std::string& binary_path, int /* retry_count */, int status_fd,
int SetUpAbUpdateCommands(const std::string& package, ZipArchiveHandle zip, int status_fd,
std::vector<std::string>* cmd) {
CHECK(cmd != nullptr);
int ret = check_newer_ab_build(zip);
@ -250,7 +248,7 @@ int update_binary_command(const std::string& package, ZipArchiveHandle zip,
}
long payload_offset = payload_entry.offset;
*cmd = {
binary_path,
"/sbin/update_engine_sideload",
"--payload=file://" + package,
android::base::StringPrintf("--offset=%ld", payload_offset),
"--headers=" + std::string(payload_properties.begin(), payload_properties.end()),
@ -259,14 +257,11 @@ int update_binary_command(const std::string& package, ZipArchiveHandle zip,
return 0;
}
#else // !AB_OTA_UPDATER
int update_binary_command(const std::string& package, ZipArchiveHandle zip,
const std::string& binary_path, int retry_count, int status_fd,
std::vector<std::string>* cmd) {
int SetUpNonAbUpdateCommands(const std::string& package, ZipArchiveHandle zip, int retry_count,
int status_fd, std::vector<std::string>* cmd) {
CHECK(cmd != nullptr);
// On traditional updates we extract the update binary from the package.
// In non-A/B updates we extract the update binary from the package.
static constexpr const char* UPDATE_BINARY_NAME = "META-INF/com/google/android/update-binary";
ZipString binary_name(UPDATE_BINARY_NAME);
ZipEntry binary_entry;
@ -275,15 +270,16 @@ int update_binary_command(const std::string& package, ZipArchiveHandle zip,
return INSTALL_CORRUPT;
}
const std::string binary_path = Paths::Get().temporary_update_binary();
unlink(binary_path.c_str());
int fd = open(binary_path.c_str(), O_CREAT | O_WRONLY | O_TRUNC | O_CLOEXEC, 0755);
android::base::unique_fd fd(
open(binary_path.c_str(), O_CREAT | O_WRONLY | O_TRUNC | O_CLOEXEC, 0755));
if (fd == -1) {
PLOG(ERROR) << "Failed to create " << binary_path;
return INSTALL_ERROR;
}
int32_t error = ExtractEntryToFile(zip, &binary_entry, fd);
close(fd);
if (error != 0) {
LOG(ERROR) << "Failed to extract " << UPDATE_BINARY_NAME << ": " << ErrorCodeString(error);
return INSTALL_ERROR;
@ -300,7 +296,6 @@ int update_binary_command(const std::string& package, ZipArchiveHandle zip,
}
return 0;
}
#endif // !AB_OTA_UPDATER
static void log_max_temperature(int* max_temperature, const std::atomic<bool>& logger_finished) {
CHECK(max_temperature != nullptr);
@ -321,14 +316,10 @@ static int try_update_binary(const std::string& package, ZipArchiveHandle zip, b
int pipefd[2];
pipe(pipefd);
bool is_ab = android::base::GetBoolProperty("ro.build.ab_update", false);
std::vector<std::string> args;
#ifdef AB_OTA_UPDATER
int ret = update_binary_command(package, zip, "/sbin/update_engine_sideload", retry_count,
pipefd[1], &args);
#else
int ret = update_binary_command(package, zip, "/tmp/update-binary", retry_count, pipefd[1],
&args);
#endif
int ret = is_ab ? SetUpAbUpdateCommands(package, zip, pipefd[1], &args)
: SetUpNonAbUpdateCommands(package, zip, retry_count, pipefd[1], &args);
if (ret) {
close(pipefd[0]);
close(pipefd[1]);

10
otautil/include/otautil/paths.h
View file

@ -76,6 +76,13 @@ class Paths {
temporary_log_file_ = log_file;
}
std::string temporary_update_binary() const {
return temporary_update_binary_;
}
void set_temporary_update_binary(const std::string& update_binary) {
temporary_update_binary_ = update_binary;
}
private:
Paths();
DISALLOW_COPY_AND_ASSIGN(Paths);
@ -103,6 +110,9 @@ class Paths {
// Path to the temporary log file while under recovery.
std::string temporary_log_file_;
// Path to the temporary update binary while installing a non-A/B package.
std::string temporary_update_binary_;
};
#endif // _OTAUTIL_PATHS_H_

4
otautil/paths.cpp
View file

@ -23,6 +23,7 @@ constexpr const char kDefaultResourceDirectory[] = "/res/images";
constexpr const char kDefaultStashDirectoryBase[] = "/cache/recovery";
constexpr const char kDefaultTemporaryInstallFile[] = "/tmp/last_install";
constexpr const char kDefaultTemporaryLogFile[] = "/tmp/recovery.log";
constexpr const char kDefaultTemporaryUpdateBinary[] = "/tmp/update-binary";
Paths& Paths::Get() {
static Paths paths;
@ -36,4 +37,5 @@ Paths::Paths()
resource_dir_(kDefaultResourceDirectory),
stash_directory_base_(kDefaultStashDirectoryBase),
temporary_install_file_(kDefaultTemporaryInstallFile),
temporary_log_file_(kDefaultTemporaryLogFile) {}
temporary_log_file_(kDefaultTemporaryLogFile),
temporary_update_binary_(kDefaultTemporaryUpdateBinary) {}

18
private/install.h
View file

@ -23,9 +23,17 @@
#include <ziparchive/zip_archive.h>
// Extract the update binary from the open zip archive |zip| located at |package| to |binary_path|.
// Store the command line that should be called into |cmd|. The |status_fd| is the file descriptor
// the child process should use to report back the progress of the update.
int update_binary_command(const std::string& package, ZipArchiveHandle zip,
const std::string& binary_path, int retry_count, int status_fd,
// Sets up the commands for a non-A/B update. Extracts the updater binary from the open zip archive
// |zip| located at |package|. Stores the command line that should be called into |cmd|. The
// |status_fd| is the file descriptor the child process should use to report back the progress of
// the update.
int SetUpNonAbUpdateCommands(const std::string& package, ZipArchiveHandle zip, int retry_count,
int status_fd, std::vector<std::string>* cmd);
// Sets up the commands for an A/B update. Extracts the needed entries from the open zip archive
// |zip| located at |package|. Stores the command line that should be called into |cmd|. The
// |status_fd| is the file descriptor the child process should use to report back the progress of
// the update. Note that since this applies to the sideloading flow only, it takes one less
// parameter |retry_count| than the non-A/B version.
int SetUpAbUpdateCommands(const std::string& package, ZipArchiveHandle zip, int status_fd,
std::vector<std::string>* cmd);

4
tests/Android.mk
View file

@ -72,10 +72,6 @@ LOCAL_CFLAGS := \
-Werror \
-D_FILE_OFFSET_BITS=64
ifeq ($(AB_OTA_UPDATER),true)
LOCAL_CFLAGS += -DAB_OTA_UPDATER=1
endif
LOCAL_MODULE := recovery_component_test
LOCAL_COMPATIBILITY_SUITE := device-tests
LOCAL_C_INCLUDES := bootable/recovery

174
tests/component/install_test.cpp
View file

@ -33,6 +33,7 @@
#include <ziparchive/zip_writer.h>
#include "install.h"
#include "otautil/paths.h"
#include "private/install.h"
TEST(InstallTest, verify_package_compatibility_no_entry) {
@ -199,8 +200,73 @@ TEST(InstallTest, verify_package_compatibility_with_libvintf_system_manifest_xml
CloseArchive(zip);
}
#ifdef AB_OTA_UPDATER
static void VerifyAbUpdateBinaryCommand(const std::string& serialno, bool success = true) {
TEST(InstallTest, SetUpNonAbUpdateCommands) {
TemporaryFile temp_file;
FILE* zip_file = fdopen(temp_file.release(), "w");
ZipWriter writer(zip_file);
static constexpr const char* UPDATE_BINARY_NAME = "META-INF/com/google/android/update-binary";
ASSERT_EQ(0, writer.StartEntry(UPDATE_BINARY_NAME, kCompressStored));
ASSERT_EQ(0, writer.FinishEntry());
ASSERT_EQ(0, writer.Finish());
ASSERT_EQ(0, fclose(zip_file));
ZipArchiveHandle zip;
ASSERT_EQ(0, OpenArchive(temp_file.path, &zip));
int status_fd = 10;
std::string package = "/path/to/update.zip";
TemporaryDir td;
std::string binary_path = std::string(td.path) + "/update_binary";
Paths::Get().set_temporary_update_binary(binary_path);
std::vector<std::string> cmd;
ASSERT_EQ(0, SetUpNonAbUpdateCommands(package, zip, 0, status_fd, &cmd));
ASSERT_EQ(4U, cmd.size());
ASSERT_EQ(binary_path, cmd[0]);
ASSERT_EQ("3", cmd[1]); // RECOVERY_API_VERSION
ASSERT_EQ(std::to_string(status_fd), cmd[2]);
ASSERT_EQ(package, cmd[3]);
struct stat sb;
ASSERT_EQ(0, stat(binary_path.c_str(), &sb));
ASSERT_EQ(static_cast<mode_t>(0755), sb.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO));
// With non-zero retry count. update_binary will be removed automatically.
cmd.clear();
ASSERT_EQ(0, SetUpNonAbUpdateCommands(package, zip, 2, status_fd, &cmd));
ASSERT_EQ(5U, cmd.size());
ASSERT_EQ(binary_path, cmd[0]);
ASSERT_EQ("3", cmd[1]); // RECOVERY_API_VERSION
ASSERT_EQ(std::to_string(status_fd), cmd[2]);
ASSERT_EQ(package, cmd[3]);
ASSERT_EQ("retry", cmd[4]);
sb = {};
ASSERT_EQ(0, stat(binary_path.c_str(), &sb));
ASSERT_EQ(static_cast<mode_t>(0755), sb.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO));
CloseArchive(zip);
}
TEST(InstallTest, SetUpNonAbUpdateCommands_MissingUpdateBinary) {
TemporaryFile temp_file;
FILE* zip_file = fdopen(temp_file.release(), "w");
ZipWriter writer(zip_file);
// The archive must have something to be opened correctly.
ASSERT_EQ(0, writer.StartEntry("dummy_entry", 0));
ASSERT_EQ(0, writer.FinishEntry());
ASSERT_EQ(0, writer.Finish());
ASSERT_EQ(0, fclose(zip_file));
// Missing update binary.
ZipArchiveHandle zip;
ASSERT_EQ(0, OpenArchive(temp_file.path, &zip));
int status_fd = 10;
std::string package = "/path/to/update.zip";
TemporaryDir td;
Paths::Get().set_temporary_update_binary(std::string(td.path) + "/update_binary");
std::vector<std::string> cmd;
ASSERT_EQ(INSTALL_CORRUPT, SetUpNonAbUpdateCommands(package, zip, 0, status_fd, &cmd));
CloseArchive(zip);
}
static void VerifyAbUpdateCommands(const std::string& serialno, bool success = true) {
TemporaryFile temp_file;
FILE* zip_file = fdopen(temp_file.release(), "w");
ZipWriter writer(zip_file);
@ -235,73 +301,27 @@ static void VerifyAbUpdateBinaryCommand(const std::string& serialno, bool succes
ASSERT_EQ(0, FindEntry(zip, payload_name, &payload_entry));
int status_fd = 10;
std::string package = "/path/to/update.zip";
std::string binary_path = "/sbin/update_engine_sideload";
std::vector<std::string> cmd;
if (success) {
ASSERT_EQ(0, update_binary_command(package, zip, binary_path, 0, status_fd, &cmd));
ASSERT_EQ(0, SetUpAbUpdateCommands(package, zip, status_fd, &cmd));
ASSERT_EQ(5U, cmd.size());
ASSERT_EQ(binary_path, cmd[0]);
ASSERT_EQ("/sbin/update_engine_sideload", cmd[0]);
ASSERT_EQ("--payload=file://" + package, cmd[1]);
ASSERT_EQ("--offset=" + std::to_string(payload_entry.offset), cmd[2]);
ASSERT_EQ("--headers=" + properties, cmd[3]);
ASSERT_EQ("--status_fd=" + std::to_string(status_fd), cmd[4]);
} else {
ASSERT_EQ(INSTALL_ERROR, update_binary_command(package, zip, binary_path, 0, status_fd, &cmd));
ASSERT_EQ(INSTALL_ERROR, SetUpAbUpdateCommands(package, zip, status_fd, &cmd));
}
CloseArchive(zip);
}
#endif // AB_OTA_UPDATER
TEST(InstallTest, update_binary_command_smoke) {
#ifdef AB_OTA_UPDATER
TEST(InstallTest, SetUpAbUpdateCommands) {
// Empty serialno will pass the verification.
VerifyAbUpdateBinaryCommand({});
#else
TemporaryFile temp_file;
FILE* zip_file = fdopen(temp_file.release(), "w");
ZipWriter writer(zip_file);
static constexpr const char* UPDATE_BINARY_NAME = "META-INF/com/google/android/update-binary";
ASSERT_EQ(0, writer.StartEntry(UPDATE_BINARY_NAME, kCompressStored));
ASSERT_EQ(0, writer.FinishEntry());
ASSERT_EQ(0, writer.Finish());
ASSERT_EQ(0, fclose(zip_file));
ZipArchiveHandle zip;
ASSERT_EQ(0, OpenArchive(temp_file.path, &zip));
int status_fd = 10;
std::string package = "/path/to/update.zip";
TemporaryDir td;
std::string binary_path = std::string(td.path) + "/update_binary";
std::vector<std::string> cmd;
ASSERT_EQ(0, update_binary_command(package, zip, binary_path, 0, status_fd, &cmd));
ASSERT_EQ(4U, cmd.size());
ASSERT_EQ(binary_path, cmd[0]);
ASSERT_EQ("3", cmd[1]); // RECOVERY_API_VERSION
ASSERT_EQ(std::to_string(status_fd), cmd[2]);
ASSERT_EQ(package, cmd[3]);
struct stat sb;
ASSERT_EQ(0, stat(binary_path.c_str(), &sb));
ASSERT_EQ(static_cast<mode_t>(0755), sb.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO));
// With non-zero retry count. update_binary will be removed automatically.
cmd.clear();
ASSERT_EQ(0, update_binary_command(package, zip, binary_path, 2, status_fd, &cmd));
ASSERT_EQ(5U, cmd.size());
ASSERT_EQ(binary_path, cmd[0]);
ASSERT_EQ("3", cmd[1]); // RECOVERY_API_VERSION
ASSERT_EQ(std::to_string(status_fd), cmd[2]);
ASSERT_EQ(package, cmd[3]);
ASSERT_EQ("retry", cmd[4]);
sb = {};
ASSERT_EQ(0, stat(binary_path.c_str(), &sb));
ASSERT_EQ(static_cast<mode_t>(0755), sb.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO));
CloseArchive(zip);
#endif // AB_OTA_UPDATER
VerifyAbUpdateCommands({});
}
TEST(InstallTest, update_binary_command_invalid) {
#ifdef AB_OTA_UPDATER
TEST(InstallTest, SetUpAbUpdateCommands_MissingPayloadPropertiesTxt) {
TemporaryFile temp_file;
FILE* zip_file = fdopen(temp_file.release(), "w");
ZipWriter writer(zip_file);
@ -328,60 +348,36 @@ TEST(InstallTest, update_binary_command_invalid) {
ASSERT_EQ(0, OpenArchive(temp_file.path, &zip));
int status_fd = 10;
std::string package = "/path/to/update.zip";
std::string binary_path = "/sbin/update_engine_sideload";
std::vector<std::string> cmd;
ASSERT_EQ(INSTALL_CORRUPT, update_binary_command(package, zip, binary_path, 0, status_fd, &cmd));
ASSERT_EQ(INSTALL_CORRUPT, SetUpAbUpdateCommands(package, zip, status_fd, &cmd));
CloseArchive(zip);
#else
TemporaryFile temp_file;
FILE* zip_file = fdopen(temp_file.release(), "w");
ZipWriter writer(zip_file);
// The archive must have something to be opened correctly.
ASSERT_EQ(0, writer.StartEntry("dummy_entry", 0));
ASSERT_EQ(0, writer.FinishEntry());
ASSERT_EQ(0, writer.Finish());
ASSERT_EQ(0, fclose(zip_file));
// Missing update binary.
ZipArchiveHandle zip;
ASSERT_EQ(0, OpenArchive(temp_file.path, &zip));
int status_fd = 10;
std::string package = "/path/to/update.zip";
TemporaryDir td;
std::string binary_path = std::string(td.path) + "/update_binary";
std::vector<std::string> cmd;
ASSERT_EQ(INSTALL_CORRUPT, update_binary_command(package, zip, binary_path, 0, status_fd, &cmd));
CloseArchive(zip);
#endif // AB_OTA_UPDATER
}
#ifdef AB_OTA_UPDATER
TEST(InstallTest, update_binary_command_multiple_serialno) {
TEST(InstallTest, SetUpAbUpdateCommands_MultipleSerialnos) {
std::string serialno = android::base::GetProperty("ro.serialno", "");
ASSERT_NE("", serialno);
// Single matching serialno will pass the verification.
VerifyAbUpdateBinaryCommand(serialno);
VerifyAbUpdateCommands(serialno);
static constexpr char alphabet[] =
"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
auto generator = []() { return alphabet[rand() % (sizeof(alphabet) - 1)]; };
// Generate 900 random serial numbers.
std::string random_serial;
std::string random_serialno;
for (size_t i = 0; i < 900; i++) {
generate_n(back_inserter(random_serial), serialno.size(), generator);
random_serial.append("|");
generate_n(back_inserter(random_serialno), serialno.size(), generator);
random_serialno.append("|");
}
// Random serialnos should fail the verification.
VerifyAbUpdateBinaryCommand(random_serial, false);
VerifyAbUpdateCommands(random_serialno, false);
std::string long_serial = random_serial + serialno + "|";
std::string long_serialno = random_serialno + serialno + "|";
for (size_t i = 0; i < 99; i++) {
generate_n(back_inserter(long_serial), serialno.size(), generator);
long_serial.append("|");
generate_n(back_inserter(long_serialno), serialno.size(), generator);
long_serialno.append("|");
}
// String with the matching serialno should pass the verification.
VerifyAbUpdateBinaryCommand(long_serial);
VerifyAbUpdateCommands(long_serialno);
}
#endif // AB_OTA_UPDATER