From 641fa97def3e6ef52471e47ad25d0658ef4d943e Mon Sep 17 00:00:00 2001 From: Tao Bao Date: Wed, 25 Apr 2018 18:59:40 -0700 Subject: [PATCH] Rename CacheLocation to Paths. We have a general need for overriding more paths (e.g. "/tmp"), mostly for testing purpose. Rename CacheLocation to Paths, and use that to manage TEMPORARY_{INSTALL,LOG}_FILE. Test: mmma -j bootable/recovery Test: recovery_component_test Change-Id: Ia8ce8e5695df37ca434f13ac4d3206de1e8e9396 --- adb_install.cpp | 4 +- adb_install.h | 2 +- applypatch/applypatch.cpp | 10 +- applypatch/freecache.cpp | 8 +- common.h | 4 +- install.cpp | 6 +- install.h | 7 +- otautil/Android.bp | 2 +- otautil/include/otautil/cache_location.h | 79 ------------ otautil/include/otautil/paths.h | 98 +++++++++++++++ otautil/{cache_location.cpp => paths.cpp} | 20 +-- recovery.cpp | 145 +++++++++++----------- tests/component/applypatch_test.cpp | 10 +- tests/component/updater_test.cpp | 15 ++- updater/blockimg.cpp | 28 ++--- updater/updater.cpp | 3 +- 16 files changed, 229 insertions(+), 212 deletions(-) delete mode 100644 otautil/include/otautil/cache_location.h create mode 100644 otautil/include/otautil/paths.h rename otautil/{cache_location.cpp => paths.cpp} (68%) diff --git a/adb_install.cpp b/adb_install.cpp index ac013065..4ee5333c 100644 --- a/adb_install.cpp +++ b/adb_install.cpp @@ -70,7 +70,7 @@ static void maybe_restart_adbd() { } } -int apply_from_adb(bool* wipe_cache, const char* install_file) { +int apply_from_adb(bool* wipe_cache) { modified_flash = true; stop_adbd(); @@ -113,7 +113,7 @@ int apply_from_adb(bool* wipe_cache, const char* install_file) { break; } } - result = install_package(FUSE_SIDELOAD_HOST_PATHNAME, wipe_cache, install_file, false, 0); + result = install_package(FUSE_SIDELOAD_HOST_PATHNAME, wipe_cache, false, 0); break; } diff --git a/adb_install.h b/adb_install.h index e654c893..cc3ca267 100644 --- a/adb_install.h +++ b/adb_install.h @@ -17,6 +17,6 @@ #ifndef _ADB_INSTALL_H #define _ADB_INSTALL_H -int apply_from_adb(bool* wipe_cache, const char* install_file); +int apply_from_adb(bool* wipe_cache); #endif diff --git a/applypatch/applypatch.cpp b/applypatch/applypatch.cpp index db7530be..39b8030d 100644 --- a/applypatch/applypatch.cpp +++ b/applypatch/applypatch.cpp @@ -40,7 +40,7 @@ #include "edify/expr.h" #include "otafault/ota_io.h" -#include "otautil/cache_location.h" +#include "otautil/paths.h" #include "otautil/print_sha1.h" static int LoadPartitionContents(const std::string& filename, FileContents* file); @@ -403,7 +403,7 @@ int applypatch_check(const char* filename, const std::vector& patch // If the source file is missing or corrupted, it might be because we were killed in the middle // of patching it. A copy of it should have been made in cache_temp_source. If that file // exists and matches the sha1 we're looking for, the check still passes. - if (LoadFileContents(CacheLocation::location().cache_temp_source().c_str(), &file) != 0) { + if (LoadFileContents(Paths::Get().cache_temp_source().c_str(), &file) != 0) { printf("failed to load cache file\n"); return 1; } @@ -525,7 +525,7 @@ int applypatch(const char* source_filename, const char* target_filename, printf("source file is bad; trying copy\n"); FileContents copy_file; - if (LoadFileContents(CacheLocation::location().cache_temp_source().c_str(), ©_file) < 0) { + if (LoadFileContents(Paths::Get().cache_temp_source().c_str(), ©_file) < 0) { printf("failed to read copy file\n"); return 1; } @@ -620,7 +620,7 @@ static int GenerateTarget(const FileContents& source_file, const std::unique_ptr printf("not enough free space on /cache\n"); return 1; } - if (SaveFileContents(CacheLocation::location().cache_temp_source().c_str(), &source_file) < 0) { + if (SaveFileContents(Paths::Get().cache_temp_source().c_str(), &source_file) < 0) { printf("failed to back up source file\n"); return 1; } @@ -685,7 +685,7 @@ static int GenerateTarget(const FileContents& source_file, const std::unique_ptr } // Delete the backup copy of the source. - unlink(CacheLocation::location().cache_temp_source().c_str()); + unlink(Paths::Get().cache_temp_source().c_str()); // Success! return 0; diff --git a/applypatch/freecache.cpp b/applypatch/freecache.cpp index cfab0f6d..dbd4b72b 100644 --- a/applypatch/freecache.cpp +++ b/applypatch/freecache.cpp @@ -38,7 +38,7 @@ #include #include "applypatch/applypatch.h" -#include "otautil/cache_location.h" +#include "otautil/paths.h" static int EliminateOpenFiles(const std::string& dirname, std::set* files) { std::unique_ptr d(opendir("/proc"), closedir); @@ -95,7 +95,7 @@ static std::vector FindExpendableFiles( // We can't delete cache_temp_source; if it's there we might have restarted during // installation and could be depending on it to be there. - if (path == CacheLocation::location().cache_temp_source()) { + if (path == Paths::Get().cache_temp_source()) { continue; } @@ -142,7 +142,7 @@ int MakeFreeSpaceOnCache(size_t bytes_needed) { return 0; #endif - std::vector dirs = { "/cache", CacheLocation::location().cache_log_directory() }; + std::vector dirs = { "/cache", Paths::Get().cache_log_directory() }; for (const auto& dirname : dirs) { if (RemoveFilesInDirectory(bytes_needed, dirname, FreeSpaceForFile)) { return 0; @@ -172,7 +172,7 @@ bool RemoveFilesInDirectory(size_t bytes_needed, const std::string& dirname, } std::vector files; - if (dirname == CacheLocation::location().cache_log_directory()) { + if (dirname == Paths::Get().cache_log_directory()) { // Deletes the log files only. auto log_filter = [](const std::string& file_name) { return android::base::StartsWith(file_name, "last_log") || diff --git a/common.h b/common.h index 8b336f80..a8513069 100644 --- a/common.h +++ b/common.h @@ -17,8 +17,8 @@ #ifndef RECOVERY_COMMON_H #define RECOVERY_COMMON_H -#include #include +#include #include @@ -38,7 +38,7 @@ extern std::string stage; extern const char* reason; // fopen a file, mounting volumes and making parent dirs as necessary. -FILE* fopen_path(const char *path, const char *mode); +FILE* fopen_path(const std::string& path, const char* mode); void ui_print(const char* format, ...); diff --git a/install.cpp b/install.cpp index d0589317..30fd2c6b 100644 --- a/install.cpp +++ b/install.cpp @@ -52,6 +52,7 @@ #include "otautil/SysUtil.h" #include "otautil/ThermalUtil.h" #include "otautil/error_code.h" +#include "otautil/paths.h" #include "private/install.h" #include "roots.h" #include "ui.h" @@ -627,10 +628,8 @@ static int really_install_package(const std::string& path, bool* wipe_cache, boo return result; } -int install_package(const std::string& path, bool* wipe_cache, const std::string& install_file, - bool needs_mount, int retry_count) { +int install_package(const std::string& path, bool* wipe_cache, bool needs_mount, int retry_count) { CHECK(!path.empty()); - CHECK(!install_file.empty()); CHECK(wipe_cache != nullptr); modified_flash = true; @@ -693,6 +692,7 @@ int install_package(const std::string& path, bool* wipe_cache, const std::string std::string log_content = android::base::Join(log_header, "\n") + "\n" + android::base::Join(log_buffer, "\n") + "\n"; + const std::string& install_file = Paths::Get().temporary_install_file(); if (!android::base::WriteStringToFile(log_content, install_file)) { PLOG(ERROR) << "failed to write " << install_file; } diff --git a/install.h b/install.h index f3fda305..0f6670a3 100644 --- a/install.h +++ b/install.h @@ -17,7 +17,10 @@ #ifndef RECOVERY_INSTALL_H_ #define RECOVERY_INSTALL_H_ +#include + #include + #include enum { INSTALL_SUCCESS, INSTALL_ERROR, INSTALL_CORRUPT, INSTALL_NONE, INSTALL_SKIPPED, @@ -25,8 +28,8 @@ enum { INSTALL_SUCCESS, INSTALL_ERROR, INSTALL_CORRUPT, INSTALL_NONE, INSTALL_SK // Installs the given update package. If INSTALL_SUCCESS is returned and *wipe_cache is true on // exit, caller should wipe the cache partition. -int install_package(const std::string& package, bool* wipe_cache, const std::string& install_file, - bool needs_mount, int retry_count); +int install_package(const std::string& package, bool* wipe_cache, bool needs_mount, + int retry_count); // Verify the package by ota keys. Return true if the package is verified successfully, // otherwise return false. diff --git a/otautil/Android.bp b/otautil/Android.bp index 75cf6914..958f98b7 100644 --- a/otautil/Android.bp +++ b/otautil/Android.bp @@ -21,7 +21,7 @@ cc_library_static { "SysUtil.cpp", "DirUtil.cpp", "ThermalUtil.cpp", - "cache_location.cpp", + "paths.cpp", "rangeset.cpp", ], diff --git a/otautil/include/otautil/cache_location.h b/otautil/include/otautil/cache_location.h deleted file mode 100644 index 005395e5..00000000 --- a/otautil/include/otautil/cache_location.h +++ /dev/null @@ -1,79 +0,0 @@ -/* - * Copyright (C) 2018 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef _OTAUTIL_OTAUTIL_CACHE_LOCATION_H_ -#define _OTAUTIL_OTAUTIL_CACHE_LOCATION_H_ - -#include - -#include "android-base/macros.h" - -// A singleton class to maintain the update related locations. The locations should be only set -// once at the start of the program. -class CacheLocation { - public: - static CacheLocation& location(); - - // getter and setter functions. - std::string cache_temp_source() const { - return cache_temp_source_; - } - void set_cache_temp_source(const std::string& temp_source) { - cache_temp_source_ = temp_source; - } - - std::string last_command_file() const { - return last_command_file_; - } - void set_last_command_file(const std::string& last_command) { - last_command_file_ = last_command; - } - - std::string stash_directory_base() const { - return stash_directory_base_; - } - void set_stash_directory_base(const std::string& base) { - stash_directory_base_ = base; - } - - std::string cache_log_directory() const { - return cache_log_directory_; - } - void set_cache_log_directory(const std::string& log_dir) { - cache_log_directory_ = log_dir; - } - - private: - CacheLocation(); - DISALLOW_COPY_AND_ASSIGN(CacheLocation); - - // When there isn't enough room on the target filesystem to hold the patched version of the file, - // we copy the original here and delete it to free up space. If the expected source file doesn't - // exist, or is corrupted, we look to see if the cached file contains the bits we want and use it - // as the source instead. The default location for the cached source is "/cache/saved.file". - std::string cache_temp_source_; - - // Location to save the last command that stashes blocks. - std::string last_command_file_; - - // The base directory to write stashes during update. - std::string stash_directory_base_; - - // The location of last_log & last_kmsg. - std::string cache_log_directory_; -}; - -#endif // _OTAUTIL_OTAUTIL_CACHE_LOCATION_H_ diff --git a/otautil/include/otautil/paths.h b/otautil/include/otautil/paths.h new file mode 100644 index 00000000..788c3de3 --- /dev/null +++ b/otautil/include/otautil/paths.h @@ -0,0 +1,98 @@ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _OTAUTIL_PATHS_H_ +#define _OTAUTIL_PATHS_H_ + +#include + +#include + +// A singleton class to maintain the update related paths. The paths should be only set once at the +// start of the program. +class Paths { + public: + static Paths& Get(); + + std::string cache_log_directory() const { + return cache_log_directory_; + } + void set_cache_log_directory(const std::string& log_dir) { + cache_log_directory_ = log_dir; + } + + std::string cache_temp_source() const { + return cache_temp_source_; + } + void set_cache_temp_source(const std::string& temp_source) { + cache_temp_source_ = temp_source; + } + + std::string last_command_file() const { + return last_command_file_; + } + void set_last_command_file(const std::string& last_command_file) { + last_command_file_ = last_command_file; + } + + std::string stash_directory_base() const { + return stash_directory_base_; + } + void set_stash_directory_base(const std::string& base) { + stash_directory_base_ = base; + } + + std::string temporary_install_file() const { + return temporary_install_file_; + } + void set_temporary_install_file(const std::string& install_file) { + temporary_install_file_ = install_file; + } + + std::string temporary_log_file() const { + return temporary_log_file_; + } + void set_temporary_log_file(const std::string& log_file) { + temporary_log_file_ = log_file; + } + + private: + Paths(); + DISALLOW_COPY_AND_ASSIGN(Paths); + + // Path to the directory that contains last_log and last_kmsg log files. + std::string cache_log_directory_; + + // Path to the temporary source file on /cache. When there isn't enough room on the target + // filesystem to hold the patched version of the file, we copy the original here and delete it to + // free up space. If the expected source file doesn't exist, or is corrupted, we look to see if + // the cached file contains the bits we want and use it as the source instead. + std::string cache_temp_source_; + + // Path to the last command file. + std::string last_command_file_; + + // Path to the base directory to write stashes during update. + std::string stash_directory_base_; + + // Path to the temporary file that contains the install result. + std::string temporary_install_file_; + + // Path to the temporary log file while under recovery. + std::string temporary_log_file_; +}; + +#endif // _OTAUTIL_PATHS_H_ diff --git a/otautil/cache_location.cpp b/otautil/paths.cpp similarity index 68% rename from otautil/cache_location.cpp rename to otautil/paths.cpp index 6139bf17..ad9ec114 100644 --- a/otautil/cache_location.cpp +++ b/otautil/paths.cpp @@ -14,20 +14,24 @@ * limitations under the License. */ -#include "otautil/cache_location.h" +#include "otautil/paths.h" +constexpr const char kDefaultCacheLogDirectory[] = "/cache/recovery"; constexpr const char kDefaultCacheTempSource[] = "/cache/saved.file"; constexpr const char kDefaultLastCommandFile[] = "/cache/recovery/last_command"; constexpr const char kDefaultStashDirectoryBase[] = "/cache/recovery"; -constexpr const char kDefaultCacheLogDirectory[] = "/cache/recovery"; +constexpr const char kDefaultTemporaryInstallFile[] = "/tmp/last_install"; +constexpr const char kDefaultTemporaryLogFile[] = "/tmp/recovery.log"; -CacheLocation& CacheLocation::location() { - static CacheLocation cache_location; - return cache_location; +Paths& Paths::Get() { + static Paths paths; + return paths; } -CacheLocation::CacheLocation() - : cache_temp_source_(kDefaultCacheTempSource), +Paths::Paths() + : cache_log_directory_(kDefaultCacheLogDirectory), + cache_temp_source_(kDefaultCacheTempSource), last_command_file_(kDefaultLastCommandFile), stash_directory_base_(kDefaultStashDirectoryBase), - cache_log_directory_(kDefaultCacheLogDirectory) {} + temporary_install_file_(kDefaultTemporaryInstallFile), + temporary_log_file_(kDefaultTemporaryLogFile) {} diff --git a/recovery.cpp b/recovery.cpp index ceb19413..dbbac7a7 100644 --- a/recovery.cpp +++ b/recovery.cpp @@ -68,6 +68,7 @@ #include "minui/minui.h" #include "otautil/DirUtil.h" #include "otautil/error_code.h" +#include "otautil/paths.h" #include "roots.h" #include "rotate_logs.h" #include "screen_ui.h" @@ -110,8 +111,6 @@ static const char *CACHE_ROOT = "/cache"; static const char *DATA_ROOT = "/data"; static const char* METADATA_ROOT = "/metadata"; static const char *SDCARD_ROOT = "/sdcard"; -static const char *TEMPORARY_LOG_FILE = "/tmp/recovery.log"; -static const char *TEMPORARY_INSTALL_FILE = "/tmp/last_install"; static const char *LAST_KMSG_FILE = "/cache/recovery/last_kmsg"; static const char *LAST_LOG_FILE = "/cache/recovery/last_log"; // We will try to apply the update package 5 times at most in case of an I/O error or @@ -185,8 +184,8 @@ struct selabel_handle* sehandle; */ // Open a given path, mounting partitions as necessary. -FILE* fopen_path(const char* path, const char* mode) { - if (ensure_path_mounted(path) != 0) { +FILE* fopen_path(const std::string& path, const char* mode) { + if (ensure_path_mounted(path.c_str()) != 0) { LOG(ERROR) << "Can't mount " << path; return nullptr; } @@ -196,19 +195,19 @@ FILE* fopen_path(const char* path, const char* mode) { if (strchr("wa", mode[0])) { mkdir_recursively(path, 0777, true, sehandle); } - return fopen(path, mode); + return fopen(path.c_str(), mode); } // close a file, log an error if the error indicator is set -static void check_and_fclose(FILE *fp, const char *name) { - fflush(fp); - if (fsync(fileno(fp)) == -1) { - PLOG(ERROR) << "Failed to fsync " << name; - } - if (ferror(fp)) { - PLOG(ERROR) << "Error in " << name; - } - fclose(fp); +static void check_and_fclose(FILE* fp, const std::string& name) { + fflush(fp); + if (fsync(fileno(fp)) == -1) { + PLOG(ERROR) << "Failed to fsync " << name; + } + if (ferror(fp)) { + PLOG(ERROR) << "Error in " << name; + } + fclose(fp); } bool is_ro_debuggable() { @@ -408,27 +407,27 @@ static void save_kernel_log(const char* destination) { android::base::WriteStringToFile(buffer, destination); } -// write content to the current pmsg session. -static ssize_t __pmsg_write(const char *filename, const char *buf, size_t len) { - return __android_log_pmsg_file_write(LOG_ID_SYSTEM, ANDROID_LOG_INFO, - filename, buf, len); +// Writes content to the current pmsg session. +static ssize_t __pmsg_write(const std::string& filename, const std::string& buf) { + return __android_log_pmsg_file_write(LOG_ID_SYSTEM, ANDROID_LOG_INFO, filename.c_str(), + buf.data(), buf.size()); } -static void copy_log_file_to_pmsg(const char* source, const char* destination) { - std::string content; - android::base::ReadFileToString(source, &content); - __pmsg_write(destination, content.c_str(), content.length()); +static void copy_log_file_to_pmsg(const std::string& source, const std::string& destination) { + std::string content; + android::base::ReadFileToString(source, &content); + __pmsg_write(destination, content); } // How much of the temp log we have copied to the copy in cache. static off_t tmplog_offset = 0; -static void copy_log_file(const char* source, const char* destination, bool append) { +static void copy_log_file(const std::string& source, const std::string& destination, bool append) { FILE* dest_fp = fopen_path(destination, append ? "ae" : "we"); if (dest_fp == nullptr) { PLOG(ERROR) << "Can't open " << destination; } else { - FILE* source_fp = fopen(source, "re"); + FILE* source_fp = fopen(source.c_str(), "re"); if (source_fp != nullptr) { if (append) { fseeko(source_fp, tmplog_offset, SEEK_SET); // Since last write @@ -448,39 +447,38 @@ static void copy_log_file(const char* source, const char* destination, bool appe } static void copy_logs() { - // We only rotate and record the log of the current session if there are - // actual attempts to modify the flash, such as wipes, installs from BCB - // or menu selections. This is to avoid unnecessary rotation (and - // possible deletion) of log files, if it does not do anything loggable. - if (!modified_flash) { - return; - } + // We only rotate and record the log of the current session if there are actual attempts to modify + // the flash, such as wipes, installs from BCB or menu selections. This is to avoid unnecessary + // rotation (and possible deletion) of log files, if it does not do anything loggable. + if (!modified_flash) { + return; + } - // Always write to pmsg, this allows the OTA logs to be caught in logcat -L - copy_log_file_to_pmsg(TEMPORARY_LOG_FILE, LAST_LOG_FILE); - copy_log_file_to_pmsg(TEMPORARY_INSTALL_FILE, LAST_INSTALL_FILE); + // Always write to pmsg, this allows the OTA logs to be caught in `logcat -L`. + copy_log_file_to_pmsg(Paths::Get().temporary_log_file(), LAST_LOG_FILE); + copy_log_file_to_pmsg(Paths::Get().temporary_install_file(), LAST_INSTALL_FILE); - // We can do nothing for now if there's no /cache partition. - if (!has_cache) { - return; - } + // We can do nothing for now if there's no /cache partition. + if (!has_cache) { + return; + } - ensure_path_mounted(LAST_LOG_FILE); - ensure_path_mounted(LAST_KMSG_FILE); - rotate_logs(LAST_LOG_FILE, LAST_KMSG_FILE); + ensure_path_mounted(LAST_LOG_FILE); + ensure_path_mounted(LAST_KMSG_FILE); + rotate_logs(LAST_LOG_FILE, LAST_KMSG_FILE); - // Copy logs to cache so the system can find out what happened. - copy_log_file(TEMPORARY_LOG_FILE, LOG_FILE, true); - copy_log_file(TEMPORARY_LOG_FILE, LAST_LOG_FILE, false); - copy_log_file(TEMPORARY_INSTALL_FILE, LAST_INSTALL_FILE, false); - save_kernel_log(LAST_KMSG_FILE); - chmod(LOG_FILE, 0600); - chown(LOG_FILE, AID_SYSTEM, AID_SYSTEM); - chmod(LAST_KMSG_FILE, 0600); - chown(LAST_KMSG_FILE, AID_SYSTEM, AID_SYSTEM); - chmod(LAST_LOG_FILE, 0640); - chmod(LAST_INSTALL_FILE, 0644); - sync(); + // Copy logs to cache so the system can find out what happened. + copy_log_file(Paths::Get().temporary_log_file(), LOG_FILE, true); + copy_log_file(Paths::Get().temporary_log_file(), LAST_LOG_FILE, false); + copy_log_file(Paths::Get().temporary_install_file(), LAST_INSTALL_FILE, false); + save_kernel_log(LAST_KMSG_FILE); + chmod(LOG_FILE, 0600); + chown(LOG_FILE, AID_SYSTEM, AID_SYSTEM); + chmod(LAST_KMSG_FILE, 0600); + chown(LAST_KMSG_FILE, AID_SYSTEM, AID_SYSTEM); + chmod(LAST_LOG_FILE, 0640); + chmod(LAST_INSTALL_FILE, 0644); + sync(); } // Clear the recovery command and prepare to boot a (hopefully working) system, @@ -966,10 +964,10 @@ static void choose_recovery_file(Device* device) { } } else { // If cache partition is not found, view /tmp/recovery.log instead. - if (access(TEMPORARY_LOG_FILE, R_OK) == -1) { + if (access(Paths::Get().temporary_log_file().c_str(), R_OK) == -1) { return; } else { - entries.push_back(TEMPORARY_LOG_FILE); + entries.push_back(Paths::Get().temporary_log_file()); } } @@ -1091,8 +1089,7 @@ static int apply_from_sdcard(Device* device, bool* wipe_cache) { } } - result = install_package(FUSE_SIDELOAD_HOST_PATHNAME, wipe_cache, - TEMPORARY_INSTALL_FILE, false, 0/*retry_count*/); + result = install_package(FUSE_SIDELOAD_HOST_PATHNAME, wipe_cache, false, 0 /*retry_count*/); break; } @@ -1169,7 +1166,7 @@ static Device::BuiltinAction prompt_and_wait(Device* device, int status) { { bool adb = (chosen_action == Device::APPLY_ADB_SIDELOAD); if (adb) { - status = apply_from_adb(&should_wipe_cache, TEMPORARY_INSTALL_FILE); + status = apply_from_adb(&should_wipe_cache); } else { status = apply_from_sdcard(device, &should_wipe_cache); } @@ -1351,19 +1348,20 @@ static bool bootreason_in_blacklist() { return false; } -static void log_failure_code(ErrorCode code, const char *update_package) { - std::vector log_buffer = { - update_package, - "0", // install result - "error: " + std::to_string(code), - }; - std::string log_content = android::base::Join(log_buffer, "\n"); - if (!android::base::WriteStringToFile(log_content, TEMPORARY_INSTALL_FILE)) { - PLOG(ERROR) << "failed to write " << TEMPORARY_INSTALL_FILE; - } +static void log_failure_code(ErrorCode code, const std::string& update_package) { + std::vector log_buffer = { + update_package, + "0", // install result + "error: " + std::to_string(code), + }; + std::string log_content = android::base::Join(log_buffer, "\n"); + const std::string& install_file = Paths::Get().temporary_install_file(); + if (!android::base::WriteStringToFile(log_content, install_file)) { + PLOG(ERROR) << "Failed to write " << install_file; + } - // Also write the info into last_log. - LOG(INFO) << log_content; + // Also write the info into last_log. + LOG(INFO) << log_content; } int main(int argc, char **argv) { @@ -1396,7 +1394,7 @@ int main(int argc, char **argv) { // redirect_stdio should be called only in non-sideload mode. Otherwise // we may have two logger instances with different timestamps. - redirect_stdio(TEMPORARY_LOG_FILE); + redirect_stdio(Paths::Get().temporary_log_file().c_str()); printf("Starting recovery (pid %d) on %s", getpid(), ctime(&start)); @@ -1565,8 +1563,7 @@ int main(int argc, char **argv) { set_retry_bootloader_message(retry_count + 1, args); } - status = install_package(update_package, &should_wipe_cache, TEMPORARY_INSTALL_FILE, true, - retry_count); + status = install_package(update_package, &should_wipe_cache, true, retry_count); if (status == INSTALL_SUCCESS && should_wipe_cache) { wipe_cache(false, device); } @@ -1627,7 +1624,7 @@ int main(int argc, char **argv) { if (!sideload_auto_reboot) { ui->ShowText(true); } - status = apply_from_adb(&should_wipe_cache, TEMPORARY_INSTALL_FILE); + status = apply_from_adb(&should_wipe_cache); if (status == INSTALL_SUCCESS && should_wipe_cache) { if (!wipe_cache(false, device)) { status = INSTALL_ERROR; diff --git a/tests/component/applypatch_test.cpp b/tests/component/applypatch_test.cpp index 292d76e4..158ea635 100644 --- a/tests/component/applypatch_test.cpp +++ b/tests/component/applypatch_test.cpp @@ -16,7 +16,6 @@ #include #include -#include #include #include #include @@ -36,12 +35,13 @@ #include #include #include +#include #include #include "applypatch/applypatch.h" #include "applypatch/applypatch_modes.h" #include "common/test_constants.h" -#include "otautil/cache_location.h" +#include "otautil/paths.h" #include "otautil/print_sha1.h" using namespace std::string_literals; @@ -110,14 +110,14 @@ class ApplyPatchCacheTest : public ApplyPatchTest { protected: void SetUp() override { ApplyPatchTest::SetUp(); - CacheLocation::location().set_cache_temp_source(old_file); + Paths::Get().set_cache_temp_source(old_file); } }; class ApplyPatchModesTest : public ::testing::Test { protected: void SetUp() override { - CacheLocation::location().set_cache_temp_source(cache_source.path); + Paths::Get().set_cache_temp_source(cache_source.path); android::base::InitLogging(nullptr, &test_logger); android::base::SetMinimumLogSeverity(android::base::LogSeverity::DEBUG); } @@ -157,7 +157,7 @@ class FreeCacheTest : public ::testing::Test { } void SetUp() override { - CacheLocation::location().set_cache_log_directory(mock_log_dir.path); + Paths::Get().set_cache_log_directory(mock_log_dir.path); } // A mock method to calculate the free space. It assumes the partition has a total size of 40960 diff --git a/tests/component/updater_test.cpp b/tests/component/updater_test.cpp index 5bfd7cb4..5d3b2d99 100644 --- a/tests/component/updater_test.cpp +++ b/tests/component/updater_test.cpp @@ -41,8 +41,8 @@ #include "common/test_constants.h" #include "edify/expr.h" #include "otautil/SysUtil.h" -#include "otautil/cache_location.h" #include "otautil/error_code.h" +#include "otautil/paths.h" #include "otautil/print_sha1.h" #include "updater/blockimg.h" #include "updater/install.h" @@ -106,10 +106,9 @@ class UpdaterTest : public ::testing::Test { RegisterInstallFunctions(); RegisterBlockImageFunctions(); - // Mock the location of last_command_file. - CacheLocation::location().set_cache_temp_source(temp_saved_source_.path); - CacheLocation::location().set_last_command_file(temp_last_command_.path); - CacheLocation::location().set_stash_directory_base(temp_stash_base_.path); + Paths::Get().set_cache_temp_source(temp_saved_source_.path); + Paths::Get().set_last_command_file(temp_last_command_.path); + Paths::Get().set_stash_directory_base(temp_stash_base_.path); } TemporaryFile temp_saved_source_; @@ -719,7 +718,7 @@ TEST_F(UpdaterTest, brotli_new_data) { } TEST_F(UpdaterTest, last_command_update) { - std::string last_command_file = CacheLocation::location().last_command_file(); + std::string last_command_file = Paths::Get().last_command_file(); std::string block1 = std::string(4096, '1'); std::string block2 = std::string(4096, '2'); @@ -806,7 +805,7 @@ TEST_F(UpdaterTest, last_command_update) { } TEST_F(UpdaterTest, last_command_update_unresumable) { - std::string last_command_file = CacheLocation::location().last_command_file(); + std::string last_command_file = Paths::Get().last_command_file(); std::string block1 = std::string(4096, '1'); std::string block2 = std::string(4096, '2'); @@ -861,7 +860,7 @@ TEST_F(UpdaterTest, last_command_update_unresumable) { } TEST_F(UpdaterTest, last_command_verify) { - std::string last_command_file = CacheLocation::location().last_command_file(); + std::string last_command_file = Paths::Get().last_command_file(); std::string block1 = std::string(4096, '1'); std::string block2 = std::string(4096, '2'); diff --git a/updater/blockimg.cpp b/updater/blockimg.cpp index e7d213a7..d767d446 100644 --- a/updater/blockimg.cpp +++ b/updater/blockimg.cpp @@ -15,8 +15,8 @@ */ #include -#include #include +#include #include #include #include @@ -25,13 +25,12 @@ #include #include #include +#include #include #include #include -#include #include #include -#include #include #include @@ -47,14 +46,15 @@ #include #include #include +#include #include #include #include #include "edify/expr.h" #include "otafault/ota_io.h" -#include "otautil/cache_location.h" #include "otautil/error_code.h" +#include "otautil/paths.h" #include "otautil/print_sha1.h" #include "otautil/rangeset.h" #include "updater/install.h" @@ -74,7 +74,7 @@ static bool is_retry = false; static std::unordered_map stash_map; static void DeleteLastCommandFile() { - std::string last_command_file = CacheLocation::location().last_command_file(); + const std::string& last_command_file = Paths::Get().last_command_file(); if (unlink(last_command_file.c_str()) == -1 && errno != ENOENT) { PLOG(ERROR) << "Failed to unlink: " << last_command_file; } @@ -83,7 +83,7 @@ static void DeleteLastCommandFile() { // Parse the last command index of the last update and save the result to |last_command_index|. // Return true if we successfully read the index. static bool ParseLastCommandFile(int* last_command_index) { - std::string last_command_file = CacheLocation::location().last_command_file(); + const std::string& last_command_file = Paths::Get().last_command_file(); android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(last_command_file.c_str(), O_RDONLY))); if (fd == -1) { if (errno != ENOENT) { @@ -119,7 +119,7 @@ static bool ParseLastCommandFile(int* last_command_index) { // Update the last command index in the last_command_file if the current command writes to the // stash either explicitly or implicitly. static bool UpdateLastCommandIndex(int command_index, const std::string& command_string) { - std::string last_command_file = CacheLocation::location().last_command_file(); + const std::string& last_command_file = Paths::Get().last_command_file(); std::string last_command_tmp = last_command_file + ".tmp"; std::string content = std::to_string(command_index) + "\n" + command_string; android::base::unique_fd wfd( @@ -672,15 +672,11 @@ static int VerifyBlocks(const std::string& expected, const std::vector& } static std::string GetStashFileName(const std::string& base, const std::string& id, - const std::string& postfix) { - if (base.empty()) { - return ""; - } - - std::string fn(CacheLocation::location().stash_directory_base()); - fn += "/" + base + "/" + id + postfix; - - return fn; + const std::string& postfix) { + if (base.empty()) { + return ""; + } + return Paths::Get().stash_directory_base() + "/" + base + "/" + id + postfix; } // Does a best effort enumeration of stash files. Ignores possible non-file items in the stash diff --git a/updater/updater.cpp b/updater/updater.cpp index 1d6b172b..bf7c36ca 100644 --- a/updater/updater.cpp +++ b/updater/updater.cpp @@ -17,9 +17,9 @@ #include "updater/updater.h" #include -#include #include #include +#include #include @@ -34,7 +34,6 @@ #include "otafault/config.h" #include "otautil/DirUtil.h" #include "otautil/SysUtil.h" -#include "otautil/cache_location.h" #include "otautil/error_code.h" #include "updater/blockimg.h" #include "updater/install.h"