Snap for 8426163 from 0dc29da7841e9d6d93e4d3483fc4d9897b29f0c5 to mainline-tzdata2-release
Change-Id: I78fb252166268fcc39824003399fdafa92eb1adf
diff --git a/Android.bp b/Android.bp
index 52de770..8e29dc8 100644
--- a/Android.bp
+++ b/Android.bp
@@ -12,40 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-// *** THIS PACKAGE HAS SPECIAL LICENSING CONDITIONS. PLEASE
-// CONSULT THE OWNERS AND opensource-licensing@google.com BEFORE
-// DEPENDING ON IT IN YOUR PROJECT. ***
-package {
- default_applicable_licenses: ["bootable_recovery_license"],
-}
-
-// Added automatically by a large-scale-change that took the approach of
-// 'apply every license found to every target'. While this makes sure we respect
-// every license restriction, it may not be entirely correct.
-//
-// e.g. GPL in an MIT project might only apply to the contrib/ directory.
-//
-// Please consider splitting the single license below into multiple licenses,
-// taking care not to lose any license_kind information, and overriding the
-// default license using the 'licenses: [...]' property on targets as needed.
-//
-// For unused files, consider creating a 'fileGroup' with "//visibility:private"
-// to attach the license to, and including a comment whether the files may be
-// used in the current project.
-// See: http://go/android-license-faq
-license {
- name: "bootable_recovery_license",
- visibility: [":__subpackages__"],
- license_kinds: [
- "SPDX-license-identifier-Apache-2.0",
- "SPDX-license-identifier-MIT",
- "SPDX-license-identifier-OFL", // by exception only
- ],
- license_text: [
- "NOTICE",
- ],
-}
-
cc_defaults {
name: "recovery_defaults",
@@ -113,7 +79,6 @@
"librecovery_utils",
"libotautil",
"libsnapshot_nobinder",
- "update_metadata-protos",
],
}
diff --git a/Android.mk b/Android.mk
index 96af417..9f69153 100644
--- a/Android.mk
+++ b/Android.mk
@@ -28,9 +28,6 @@
include $(CLEAR_VARS)
LOCAL_MODULE := librecovery_ui_ext
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0 SPDX-license-identifier-MIT SPDX-license-identifier-OFL
-LOCAL_LICENSE_CONDITIONS := by_exception_only notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/NOTICE
# LOCAL_MODULE_PATH for shared libraries is unsupported in multiarch builds.
LOCAL_MULTILIB := first
@@ -57,15 +54,14 @@
include $(CLEAR_VARS)
LOCAL_MODULE := recovery_deps
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0 SPDX-license-identifier-MIT SPDX-license-identifier-OFL
-LOCAL_LICENSE_CONDITIONS := by_exception_only notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/NOTICE
ifeq ($(TARGET_USERIMAGES_USE_F2FS),true)
+ifeq ($(HOST_OS),linux)
LOCAL_REQUIRED_MODULES += \
make_f2fs.recovery \
sload_f2fs.recovery
endif
+endif
# On A/B devices recovery-persist reads the recovery related file from the persist storage and
# copies them into /data/misc/recovery. Then, for both A/B and non-A/B devices, recovery-persist
diff --git a/METADATA b/METADATA
deleted file mode 100644
index a1ce3c6..0000000
--- a/METADATA
+++ /dev/null
@@ -1,9 +0,0 @@
-# *** THIS PACKAGE HAS SPECIAL LICENSING CONDITIONS. PLEASE
-# CONSULT THE OWNERS AND opensource-licensing@google.com BEFORE
-# DEPENDING ON IT IN YOUR PROJECT. ***
-third_party {
- # would be NOTICE save for OFL in:
- # fonts/README
- # fonts/OFL.txt
- license_type: BY_EXCEPTION_ONLY
-}
diff --git a/README.md b/README.md
index 5ab19d1..bd1cf7d 100644
--- a/README.md
+++ b/README.md
@@ -143,17 +143,3 @@
Both of the two conditions need to be satisfied. Although `ro.adb.secure` is a runtime property, its
value is set at build time (written into `/prop.default`). It defaults to `1` on `-user` builds, and
`0` for other build variants. The value is overridable via `PRODUCT_DEFAULT_PROPERTY_OVERRIDES`.
-
-Localization of the background texts
-------------------------------------
-
-The recovery image supports localization of several background texts, e.g. installing, error,
-factory reset warnings, etc. For devices using `xxhdpi` and `xxxhdpi`, the build system generates
-these localization images dynamically since android-10 when building the recovery image. While
-the static images under res-*dpi/images/ is used for other display resolutions and as a
-backup.
-
-Check the invocation of the image_generator tool in the [makefile]. And the detailed usage of the
-image_generator is documented [here](./tools/image_generator/README.md).
-
-[makefile]: https://android.googlesource.com/platform/build/+/refs/heads/master/core/Makefile#1800
diff --git a/TEST_MAPPING b/TEST_MAPPING
index 1237285..a304582 100644
--- a/TEST_MAPPING
+++ b/TEST_MAPPING
@@ -5,6 +5,10 @@
},
{
"name": "recovery_unit_test"
+ },
+ {
+ "name": "recovery_host_test",
+ "host": true
}
]
}
diff --git a/applypatch/Android.bp b/applypatch/Android.bp
index 0d6d23b..13a9625 100644
--- a/applypatch/Android.bp
+++ b/applypatch/Android.bp
@@ -12,23 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package {
- default_applicable_licenses: ["bootable_recovery_applypatch_license"],
-}
-
-// Added automatically by a large-scale-change
-// See: http://go/android-license-faq
-license {
- name: "bootable_recovery_applypatch_license",
- visibility: [":__subpackages__"],
- license_kinds: [
- "SPDX-license-identifier-Apache-2.0",
- ],
- license_text: [
- "NOTICE",
- ],
-}
-
cc_defaults {
name: "applypatch_defaults",
@@ -71,7 +54,7 @@
"libbz",
"libedify",
"libotautil",
- "libz_stable",
+ "libz",
],
shared_libs: [
@@ -137,7 +120,7 @@
"libbase",
"libcrypto",
"liblog",
- "libz_stable",
+ "libz",
"libziparchive",
],
@@ -146,9 +129,9 @@
],
}
-cc_library_static {
+cc_library_host_static {
name: "libimgdiff",
- host_supported: true,
+
defaults: [
"applypatch_defaults",
],
@@ -169,13 +152,14 @@
"liblog",
"libotautil",
"libutils",
- "libz_stable",
+ "libz",
"libziparchive",
],
}
cc_binary_host {
name: "imgdiff",
+
srcs: [
"imgdiff_main.cpp",
],
@@ -196,6 +180,6 @@
"liblog",
"libbrotli",
"libbz",
- "libz_stable",
+ "libz",
],
}
diff --git a/applypatch/imgdiff.cpp b/applypatch/imgdiff.cpp
index 376c511..6ad4a61 100644
--- a/applypatch/imgdiff.cpp
+++ b/applypatch/imgdiff.cpp
@@ -682,9 +682,9 @@
}
// Create a list of deflated zip entries, sorted by offset.
- std::vector<std::pair<std::string, ZipEntry64>> temp_entries;
+ std::vector<std::pair<std::string, ZipEntry>> temp_entries;
std::string name;
- ZipEntry64 entry;
+ ZipEntry entry;
while ((ret = Next(cookie, &entry, &name)) == 0) {
if (entry.method == kCompressDeflated || limit_ > 0) {
temp_entries.emplace_back(name, entry);
@@ -712,14 +712,8 @@
// Add the end of zip file (mainly central directory) as a normal chunk.
size_t entries_end = 0;
if (!temp_entries.empty()) {
- CHECK_GE(temp_entries.back().second.offset, 0);
- if (__builtin_add_overflow(temp_entries.back().second.offset,
- temp_entries.back().second.compressed_length, &entries_end)) {
- LOG(ERROR) << "`entries_end` overflows on entry with offset "
- << temp_entries.back().second.offset << " and compressed_length "
- << temp_entries.back().second.compressed_length;
- return false;
- }
+ entries_end = static_cast<size_t>(temp_entries.back().second.offset +
+ temp_entries.back().second.compressed_length);
}
CHECK_LT(entries_end, file_content_.size());
chunks_.emplace_back(CHUNK_NORMAL, entries_end, &file_content_,
@@ -741,16 +735,8 @@
LOG(ERROR) << "Failed to add " << entry_name << " to target chunks";
return false;
}
- if (temp_entries[nextentry].second.compressed_length > std::numeric_limits<size_t>::max()) {
- LOG(ERROR) << "Entry " << name << " compressed size exceeds size of address space. "
- << entry.compressed_length;
- return false;
- }
- if (__builtin_add_overflow(pos, temp_entries[nextentry].second.compressed_length, &pos)) {
- LOG(ERROR) << "`pos` overflows after adding "
- << temp_entries[nextentry].second.compressed_length;
- return false;
- }
+
+ pos += temp_entries[nextentry].second.compressed_length;
++nextentry;
continue;
}
@@ -771,13 +757,7 @@
}
bool ZipModeImage::AddZipEntryToChunks(ZipArchiveHandle handle, const std::string& entry_name,
- ZipEntry64* entry) {
- if (entry->compressed_length > std::numeric_limits<size_t>::max()) {
- LOG(ERROR) << "Failed to add " << entry_name
- << " because's compressed size exceeds size of address space. "
- << entry->compressed_length;
- return false;
- }
+ ZipEntry* entry) {
size_t compressed_len = entry->compressed_length;
if (compressed_len == 0) return true;
@@ -795,12 +775,6 @@
}
} else if (entry->method == kCompressDeflated) {
size_t uncompressed_len = entry->uncompressed_length;
- if (uncompressed_len > std::numeric_limits<size_t>::max()) {
- LOG(ERROR) << "Failed to add " << entry_name
- << " because's compressed size exceeds size of address space. "
- << uncompressed_len;
- return false;
- }
std::vector<uint8_t> uncompressed_data(uncompressed_len);
int ret = ExtractToMemory(handle, entry, uncompressed_data.data(), uncompressed_len);
if (ret != 0) {
@@ -991,7 +965,7 @@
used_src_ranges.Insert(src_ranges);
split_src_ranges->push_back(std::move(src_ranges));
}
- src_ranges = {};
+ src_ranges.Clear();
// We don't have enough space for the current chunk; start a new split image and handle
// this chunk there.
@@ -1061,24 +1035,23 @@
}
ZipModeImage split_tgt_image(false);
- split_tgt_image.Initialize(aligned_tgt_chunks, {});
+ split_tgt_image.Initialize(std::move(aligned_tgt_chunks), {});
split_tgt_image.MergeAdjacentNormalChunks();
- // Construct the split source file based on the split src ranges.
- std::vector<uint8_t> split_src_content;
+ // Construct the dummy source file based on the src_ranges.
+ std::vector<uint8_t> src_content;
for (const auto& r : split_src_ranges) {
size_t end = std::min(src_image.file_content_.size(), r.second * BLOCK_SIZE);
- split_src_content.insert(split_src_content.end(),
- src_image.file_content_.begin() + r.first * BLOCK_SIZE,
- src_image.file_content_.begin() + end);
+ src_content.insert(src_content.end(), src_image.file_content_.begin() + r.first * BLOCK_SIZE,
+ src_image.file_content_.begin() + end);
}
// We should not have an empty src in our design; otherwise we will encounter an error in
- // bsdiff since split_src_content.data() == nullptr.
- CHECK(!split_src_content.empty());
+ // bsdiff since src_content.data() == nullptr.
+ CHECK(!src_content.empty());
ZipModeImage split_src_image(true);
- split_src_image.Initialize(split_src_chunks, split_src_content);
+ split_src_image.Initialize(split_src_chunks, std::move(src_content));
split_tgt_images->push_back(std::move(split_tgt_image));
split_src_images->push_back(std::move(split_src_image));
diff --git a/applypatch/include/applypatch/imgdiff_image.h b/applypatch/include/applypatch/imgdiff_image.h
index b579e56..6716051 100644
--- a/applypatch/include/applypatch/imgdiff_image.h
+++ b/applypatch/include/applypatch/imgdiff_image.h
@@ -211,7 +211,7 @@
bool Initialize(const std::string& filename) override;
- // Initialize a fake ZipModeImage from an existing ImageChunk vector. For src img pieces, we
+ // Initialize a dummy ZipModeImage from an existing ImageChunk vector. For src img pieces, we
// reconstruct a new file_content based on the source ranges; but it's not needed for the tgt img
// pieces; because for each chunk both the data and their offset within the file are unchanged.
void Initialize(const std::vector<ImageChunk>& chunks, const std::vector<uint8_t>& file_content) {
@@ -257,8 +257,7 @@
// Initialize image chunks based on the zip entries.
bool InitializeChunks(const std::string& filename, ZipArchiveHandle handle);
// Add the a zip entry to the list.
- bool AddZipEntryToChunks(ZipArchiveHandle handle, const std::string& entry_name,
- ZipEntry64* entry);
+ bool AddZipEntryToChunks(ZipArchiveHandle handle, const std::string& entry_name, ZipEntry* entry);
// Return the real size of the zip file. (omit the trailing zeros that used for alignment)
bool GetZipFileSize(size_t* input_file_size);
@@ -266,7 +265,7 @@
const std::vector<ZipModeImage>& split_src_images,
std::vector<SortedRangeSet>& split_src_ranges,
size_t total_tgt_size);
- // Construct the fake split images based on the chunks info and source ranges; and move them into
+ // Construct the dummy split images based on the chunks info and source ranges; and move them into
// the given vectors. Return true if we add a new split image into |split_tgt_images|, and
// false otherwise.
static bool AddSplitImageFromChunkList(const ZipModeImage& tgt_image,
diff --git a/bootloader_message/Android.bp b/bootloader_message/Android.bp
index 778fdb9..6443a07 100644
--- a/bootloader_message/Android.bp
+++ b/bootloader_message/Android.bp
@@ -14,15 +14,6 @@
// limitations under the License.
//
-package {
- // See: http://go/android-license-faq
- // A large-scale-change added 'default_applicable_licenses' to import
- // all of the 'license_kinds' from "bootable_recovery_license"
- // to get the below license kinds:
- // SPDX-license-identifier-Apache-2.0
- default_applicable_licenses: ["bootable_recovery_license"],
-}
-
cc_defaults {
name: "libbootloader_message_defaults",
srcs: ["bootloader_message.cpp"],
diff --git a/edify/Android.bp b/edify/Android.bp
index 62ff911..0ab53d6 100644
--- a/edify/Android.bp
+++ b/edify/Android.bp
@@ -12,15 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package {
- // See: http://go/android-license-faq
- // A large-scale-change added 'default_applicable_licenses' to import
- // all of the 'license_kinds' from "bootable_recovery_license"
- // to get the below license kinds:
- // SPDX-license-identifier-Apache-2.0
- default_applicable_licenses: ["bootable_recovery_license"],
-}
-
cc_library_static {
name: "libedify",
diff --git a/edify/include/edify/expr.h b/edify/include/edify/expr.h
index 3ddf7f5..cd9c701 100644
--- a/edify/include/edify/expr.h
+++ b/edify/include/edify/expr.h
@@ -60,7 +60,7 @@
BLOB = 2,
};
- Value(Type type, std::string str) : type(type), data(std::move(str)) {}
+ Value(Type type, const std::string& str) : type(type), data(str) {}
Type type;
std::string data;
diff --git a/etc/init.rc b/etc/init.rc
index 5cacb8b..3ec45db 100644
--- a/etc/init.rc
+++ b/etc/init.rc
@@ -24,6 +24,9 @@
symlink /system/bin /bin
symlink /system/etc /etc
+ mount cgroup none /acct cpuacct
+ mkdir /acct/uid
+
mkdir /sdcard
mkdir /system
mkdir /data
diff --git a/fuse_sideload/Android.bp b/fuse_sideload/Android.bp
index 4eb21dc..9bf19eb 100644
--- a/fuse_sideload/Android.bp
+++ b/fuse_sideload/Android.bp
@@ -12,15 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package {
- // See: http://go/android-license-faq
- // A large-scale-change added 'default_applicable_licenses' to import
- // all of the 'license_kinds' from "bootable_recovery_license"
- // to get the below license kinds:
- // SPDX-license-identifier-Apache-2.0
- default_applicable_licenses: ["bootable_recovery_license"],
-}
-
cc_library {
name: "libfusesideload",
recovery_available: true,
diff --git a/install/Android.bp b/install/Android.bp
index e239ddc..bed3bc5 100644
--- a/install/Android.bp
+++ b/install/Android.bp
@@ -12,21 +12,11 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package {
- // See: http://go/android-license-faq
- // A large-scale-change added 'default_applicable_licenses' to import
- // all of the 'license_kinds' from "bootable_recovery_license"
- // to get the below license kinds:
- // SPDX-license-identifier-Apache-2.0
- default_applicable_licenses: ["bootable_recovery_license"],
-}
-
cc_defaults {
name: "libinstall_defaults",
defaults: [
"recovery_defaults",
- "libspl_check_defaults",
],
shared_libs: [
@@ -50,51 +40,12 @@
"librecovery_utils",
"libotautil",
"libsnapshot_nobinder",
- "ota_metadata_proto_cc",
// external dependencies
"libvintf",
],
}
-cc_test_host {
- name: "libinstall_host_unittests",
- defaults: [
- "libspl_check_defaults"
- ],
- srcs: [
- "spl_check_unittests.cpp",
- ],
- static_libs: [
- "libspl_check",
- ],
-}
-
-cc_defaults {
- name: "libspl_check_defaults",
- static_libs: [
- "libbase",
- "ota_metadata_proto_cc",
- "liblog",
- "libziparchive",
- "libz",
- "libprotobuf-cpp-lite",
- ],
-}
-
-cc_library_static {
- name: "libspl_check",
- recovery_available: true,
- host_supported: true,
- defaults: [
- "libspl_check_defaults",
- ],
- srcs: ["spl_check.cpp"],
- export_include_dirs: [
- "include",
- ],
-}
-
cc_library_static {
name: "libinstall",
recovery_available: true,
@@ -113,7 +64,6 @@
"verifier.cpp",
"wipe_data.cpp",
"wipe_device.cpp",
- "spl_check.cpp",
],
header_libs: [
diff --git a/install/include/install/spl_check.h b/install/include/install/spl_check.h
deleted file mode 100644
index e0bfc62..0000000
--- a/install/include/install/spl_check.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * Copyright (C) 2021 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.
- */
-
-#include <string_view>
-
-#include <android-base/logging.h>
-#include <ota_metadata.pb.h>
-#include <ziparchive/zip_archive.h>
-
-bool ViolatesSPLDowngrade(const build::tools::releasetools::OtaMetadata& metadata,
- std::string_view current_spl);
-
-bool ViolatesSPLDowngrade(ZipArchiveHandle zip, std::string_view current_spl);
diff --git a/install/install.cpp b/install/install.cpp
index 6e74f80..d404997 100644
--- a/install/install.cpp
+++ b/install/install.cpp
@@ -47,7 +47,6 @@
#include <android-base/unique_fd.h>
#include "install/package.h"
-#include "install/spl_check.h"
#include "install/verifier.h"
#include "install/wipe_data.h"
#include "otautil/error_code.h"
@@ -68,17 +67,14 @@
// Default allocation of progress bar segments to operations
static constexpr int VERIFICATION_PROGRESS_TIME = 60;
static constexpr float VERIFICATION_PROGRESS_FRACTION = 0.25;
-// The charater used to separate dynamic fingerprints. e.x. sargo|aosp-sargo
-static const char* FINGERPRING_SEPARATOR = "|";
+
static std::condition_variable finish_log_temperature;
-static bool isInStringList(const std::string& target_token, const std::string& str_list,
- const std::string& deliminator);
bool ReadMetadataFromPackage(ZipArchiveHandle zip, std::map<std::string, std::string>* metadata) {
CHECK(metadata != nullptr);
static constexpr const char* METADATA_PATH = "META-INF/com/android/metadata";
- ZipEntry64 entry;
+ ZipEntry entry;
if (FindEntry(zip, METADATA_PATH, &entry) != 0) {
LOG(ERROR) << "Failed to find " << METADATA_PATH;
return false;
@@ -155,8 +151,7 @@
auto device_fingerprint = android::base::GetProperty("ro.build.fingerprint", "");
auto pkg_pre_build_fingerprint = get_value(metadata, "pre-build");
- if (!pkg_pre_build_fingerprint.empty() &&
- !isInStringList(device_fingerprint, pkg_pre_build_fingerprint, FINGERPRING_SEPARATOR)) {
+ if (!pkg_pre_build_fingerprint.empty() && pkg_pre_build_fingerprint != device_fingerprint) {
LOG(ERROR) << "Package is for source build " << pkg_pre_build_fingerprint << " but expected "
<< device_fingerprint;
return false;
@@ -204,8 +199,7 @@
auto device = android::base::GetProperty("ro.product.device", "");
auto pkg_device = get_value(metadata, "pre-device");
- // device name can be a | separated list, so need to check
- if (pkg_device.empty() || !isInStringList(device, pkg_device, FINGERPRING_SEPARATOR)) {
+ if (pkg_device != device || pkg_device.empty()) {
LOG(ERROR) << "Package is for product " << pkg_device << " but expected " << device;
return false;
}
@@ -242,18 +236,12 @@
// For A/B updates we extract the payload properties to a buffer and obtain the RAW payload offset
// in the zip file.
static constexpr const char* AB_OTA_PAYLOAD_PROPERTIES = "payload_properties.txt";
- ZipEntry64 properties_entry;
+ ZipEntry properties_entry;
if (FindEntry(zip, AB_OTA_PAYLOAD_PROPERTIES, &properties_entry) != 0) {
LOG(ERROR) << "Failed to find " << AB_OTA_PAYLOAD_PROPERTIES;
return false;
}
- auto properties_entry_length = properties_entry.uncompressed_length;
- if (properties_entry_length > std::numeric_limits<size_t>::max()) {
- LOG(ERROR) << "Failed to extract " << AB_OTA_PAYLOAD_PROPERTIES
- << " because's uncompressed size exceeds size of address space. "
- << properties_entry_length;
- return false;
- }
+ uint32_t properties_entry_length = properties_entry.uncompressed_length;
std::vector<uint8_t> payload_properties(properties_entry_length);
int32_t err =
ExtractToMemory(zip, &properties_entry, payload_properties.data(), properties_entry_length);
@@ -263,7 +251,7 @@
}
static constexpr const char* AB_OTA_PAYLOAD = "payload.bin";
- ZipEntry64 payload_entry;
+ ZipEntry payload_entry;
if (FindEntry(zip, AB_OTA_PAYLOAD, &payload_entry) != 0) {
LOG(ERROR) << "Failed to find " << AB_OTA_PAYLOAD;
return false;
@@ -285,7 +273,7 @@
// 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";
- ZipEntry64 binary_entry;
+ ZipEntry binary_entry;
if (FindEntry(zip, UPDATE_BINARY_NAME, &binary_entry) != 0) {
LOG(ERROR) << "Failed to find update binary " << UPDATE_BINARY_NAME;
return false;
@@ -349,12 +337,6 @@
android::base::GetBoolProperty("ro.virtual_ab.allow_non_ab", false);
bool device_only_supports_ab = device_supports_ab && !ab_device_supports_nonab;
- const auto current_spl = android::base::GetProperty("ro.build.version.security_patch", "");
- if (ViolatesSPLDowngrade(zip, current_spl)) {
- LOG(ERROR) << "Denying OTA because it's SPL downgrade";
- return INSTALL_ERROR;
- }
-
if (package_is_ab) {
CHECK(package->GetType() == PackageType::kFile);
}
@@ -717,18 +699,3 @@
}
return true;
}
-
-// Check if `target_token` is in string `str_list`, where `str_list` is expected to be a
-// list delimited by `deliminator`
-// E.X. isInStringList("a", "a|b|c|d", "|") => true
-// E.X. isInStringList("abc", "abc", "|") => true
-static bool isInStringList(const std::string& target_token, const std::string& str_list,
- const std::string& deliminator) {
- if (target_token.length() > str_list.length()) {
- return false;
- } else if (target_token.length() == str_list.length() || deliminator.length() == 0) {
- return target_token == str_list;
- }
- auto&& list = android::base::Split(str_list, deliminator);
- return std::find(list.begin(), list.end(), target_token) != list.end();
-}
diff --git a/install/snapshot_utils.cpp b/install/snapshot_utils.cpp
index 336e50f..7235e67 100644
--- a/install/snapshot_utils.cpp
+++ b/install/snapshot_utils.cpp
@@ -32,7 +32,7 @@
}
RecoveryUI* ui = device->GetUI();
- auto sm = SnapshotManager::New();
+ auto sm = SnapshotManager::NewForFirstStageMount();
if (!sm) {
ui->Print("Could not create SnapshotManager.\n");
return false;
@@ -57,7 +57,7 @@
return true;
}
- auto sm = SnapshotManager::New();
+ auto sm = SnapshotManager::NewForFirstStageMount();
if (!sm) {
// SnapshotManager could not be created. The device is still in a
// consistent state and can continue with the mounting of the existing
diff --git a/install/spl_check.cpp b/install/spl_check.cpp
deleted file mode 100644
index c26ab82..0000000
--- a/install/spl_check.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright (C) 2021 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.
- */
-
-#include "install/spl_check.h"
-
-bool ViolatesSPLDowngrade(const build::tools::releasetools::OtaMetadata& metadata,
- std::string_view current_spl) {
- const auto& post_spl = metadata.postcondition().security_patch_level();
- if (current_spl.empty()) {
- LOG(WARNING) << "Failed to get device's current security patch level. Target SPL is "
- << post_spl << " permitting OTA install";
- return false;
- }
- // SPL(security patch level) is expected to be in format yyyy-mm-dd, e.g. 2018-05-29. Given this
- // specific format, comparing two SPL can be done by just regular string comparison. If the format
- // must lay out year/month/date in the exact order, and must properly prepend dates with 0(for
- // example, 05 for May). Otherwise this comparison doesn't work. We don't expect SPL date formats
- // to change, leave this as is.
- if (post_spl < current_spl) {
- LOG(ERROR) << "Current SPL: " << current_spl << " Target SPL: " << post_spl
- << " this is considered a downgrade";
- if (metadata.spl_downgrade() || metadata.downgrade()) {
- LOG(WARNING)
- << "SPL downgrade detected, but OTA package explicitly permitts this(OtaMetadata has "
- "spl_downgrade / downgrade bit set).Permitting update anyway.Installing a SPL "
- "downgrade OTA can cause /data fail to decrypt and device fails to boot.";
- return false;
- }
- return true;
- } else {
- LOG(INFO) << "old spl: " << current_spl << " new spl: " << post_spl << " CHECK passes";
- }
- return false;
-}
-
-bool ViolatesSPLDowngrade(ZipArchiveHandle zip, std::string_view current_spl) {
- static constexpr auto&& OTA_OTA_METADATA = "META-INF/com/android/metadata.pb";
- ZipEntry64 metadata_entry;
- if (FindEntry(zip, OTA_OTA_METADATA, &metadata_entry) != 0) {
- LOG(WARNING) << "Failed to find " << OTA_OTA_METADATA
- << " treating this as non-spl-downgrade, permit OTA install. If device bricks "
- "after installing, check kernel log to see if /data failed to decrypt";
- return false;
- }
- const auto metadata_entry_length = metadata_entry.uncompressed_length;
- if (metadata_entry_length > std::numeric_limits<size_t>::max()) {
- LOG(ERROR) << "Failed to extract " << OTA_OTA_METADATA
- << " because's uncompressed size exceeds size of address space. "
- << metadata_entry_length;
- return false;
- }
- std::vector<uint8_t> ota_metadata(metadata_entry_length);
- int32_t err = ExtractToMemory(zip, &metadata_entry, ota_metadata.data(), metadata_entry_length);
- if (err != 0) {
- LOG(ERROR) << "Failed to extract " << OTA_OTA_METADATA << ": " << ErrorCodeString(err);
- return false;
- }
- using build::tools::releasetools::OtaMetadata;
- OtaMetadata metadata;
- if (!metadata.ParseFromArray(ota_metadata.data(), ota_metadata.size())) {
- LOG(ERROR) << "Failed to parse ota_medata";
- return false;
- }
- return ViolatesSPLDowngrade(metadata, current_spl);
-}
diff --git a/install/spl_check_unittests.cpp b/install/spl_check_unittests.cpp
deleted file mode 100644
index 709b69c..0000000
--- a/install/spl_check_unittests.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (C) 2021 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.
- */
-
-#include <gtest/gtest.h>
-
-#include "install/spl_check.h"
-#include "ota_metadata.pb.h"
-
-using build::tools::releasetools::OtaMetadata;
-class SplCheckUnittest : public ::testing::Test {
- public:
- OtaMetadata metadata;
-};
-
-TEST_F(SplCheckUnittest, OlderSPL) {
- metadata.set_spl_downgrade(false);
- metadata.mutable_postcondition()->set_security_patch_level("2021-04-25");
- ASSERT_TRUE(ViolatesSPLDowngrade(metadata, "2021-05-01"));
-}
-
-TEST_F(SplCheckUnittest, NewerSPL) {
- metadata.set_spl_downgrade(false);
- metadata.mutable_postcondition()->set_security_patch_level("2021-06-01");
- ASSERT_FALSE(ViolatesSPLDowngrade(metadata, "2021-05-05"));
-}
-
-TEST_F(SplCheckUnittest, OlderSPLPermit) {
- // If spl_downgrade is set to true, OTA should be permitted
- metadata.set_spl_downgrade(true);
- metadata.mutable_postcondition()->set_security_patch_level("2021-04-11");
- ASSERT_FALSE(ViolatesSPLDowngrade(metadata, "2021-05-11"));
-}
\ No newline at end of file
diff --git a/install/verifier.cpp b/install/verifier.cpp
index 3f02601..ab75044 100644
--- a/install/verifier.cpp
+++ b/install/verifier.cpp
@@ -321,14 +321,8 @@
std::vector<Certificate> result;
std::string_view name;
- ZipEntry64 entry;
+ ZipEntry entry;
while ((iter_status = Next(cookie, &entry, &name)) == 0) {
- if (entry.uncompressed_length > std::numeric_limits<size_t>::max()) {
- LOG(ERROR) << "Failed to extract " << name
- << " because's uncompressed size exceeds size of address space. "
- << entry.uncompressed_length;
- return {};
- }
std::vector<uint8_t> pem_content(entry.uncompressed_length);
if (int32_t extract_status =
ExtractToMemory(handle, &entry, pem_content.data(), pem_content.size());
diff --git a/install/wipe_data.cpp b/install/wipe_data.cpp
index 4eecf72..2872085 100644
--- a/install/wipe_data.cpp
+++ b/install/wipe_data.cpp
@@ -41,6 +41,9 @@
bool is_cache = (strcmp(volume, CACHE_ROOT) == 0);
bool is_data = (strcmp(volume, DATA_ROOT) == 0);
+ ui->SetBackground(RecoveryUI::ERASING);
+ ui->SetProgressType(RecoveryUI::INDETERMINATE);
+
std::vector<saved_log_file> log_files;
if (is_cache) {
// If we're reformatting /cache, we load any past logs (i.e. "/cache/recovery/last_*") and the
@@ -94,9 +97,6 @@
}
ui->Print("\n-- Wiping cache...\n");
- ui->SetBackground(RecoveryUI::ERASING);
- ui->SetProgressType(RecoveryUI::INDETERMINATE);
-
bool success = EraseVolume("/cache", ui, false);
ui->Print("Cache wipe %s.\n", success ? "complete" : "failed");
return success;
@@ -105,8 +105,6 @@
bool WipeData(Device* device, bool convert_fbe) {
RecoveryUI* ui = device->GetUI();
ui->Print("\n-- Wiping data...\n");
- ui->SetBackground(RecoveryUI::ERASING);
- ui->SetProgressType(RecoveryUI::INDETERMINATE);
if (!FinishPendingSnapshotMerges(device)) {
ui->Print("Unable to check update status or complete merge, cannot wipe partitions.\n");
diff --git a/install/wipe_device.cpp b/install/wipe_device.cpp
index 915c87b..89d5d31 100644
--- a/install/wipe_device.cpp
+++ b/install/wipe_device.cpp
@@ -49,14 +49,9 @@
constexpr char RECOVERY_WIPE_ENTRY_NAME[] = "recovery.wipe";
std::string partition_list_content;
- ZipEntry64 entry;
+ ZipEntry entry;
if (FindEntry(zip, RECOVERY_WIPE_ENTRY_NAME, &entry) == 0) {
- auto length = entry.uncompressed_length;
- if (length > std::numeric_limits<size_t>::max()) {
- LOG(ERROR) << "Failed to extract " << RECOVERY_WIPE_ENTRY_NAME
- << " because's uncompressed size exceeds size of address space. " << length;
- return {};
- }
+ uint32_t length = entry.uncompressed_length;
partition_list_content = std::string(length, '\0');
if (auto err = ExtractToMemory(
zip, &entry, reinterpret_cast<uint8_t*>(partition_list_content.data()), length);
diff --git a/minadbd/Android.bp b/minadbd/Android.bp
index 2bcfece..fb51a79 100644
--- a/minadbd/Android.bp
+++ b/minadbd/Android.bp
@@ -12,15 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package {
- // See: http://go/android-license-faq
- // A large-scale-change added 'default_applicable_licenses' to import
- // all of the 'license_kinds' from "bootable_recovery_license"
- // to get the below license kinds:
- // SPDX-license-identifier-Apache-2.0
- default_applicable_licenses: ["bootable_recovery_license"],
-}
-
cc_defaults {
name: "minadbd_defaults",
diff --git a/minadbd/minadbd_services.cpp b/minadbd/minadbd_services.cpp
index 0abe867..ff91ba9 100644
--- a/minadbd/minadbd_services.cpp
+++ b/minadbd/minadbd_services.cpp
@@ -23,7 +23,6 @@
#include <string.h>
#include <unistd.h>
-#include <chrono>
#include <functional>
#include <memory>
#include <set>
@@ -143,48 +142,10 @@
return kMinadbdSuccess;
}
-static bool WaitForSocketClose(int fd, std::chrono::milliseconds timeout) {
- const auto begin = std::chrono::steady_clock::now();
- const auto end = begin + timeout;
- while (std::chrono::steady_clock::now() < end) {
- // We don't care about reading the socket, we just want to wait until
- // socket closes. In this case .events = 0 will tell the kernel to wait
- // for close events.
- struct pollfd pfd = { .fd = fd, .events = 0 };
- auto timeout_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
- end - std::chrono::steady_clock::now())
- .count();
- int rc = TEMP_FAILURE_RETRY(adb_poll(&pfd, 1, timeout_ms));
- if (rc == 1) {
- LOG(INFO) << "revents: " << pfd.revents;
- if (pfd.revents & (POLLHUP | POLLRDHUP)) {
- return true;
- }
- } else {
- PLOG(ERROR) << "poll() failed";
- // poll failed, almost definitely due to timeout
- // If not, you're screwed anyway, because it probably means the kernel ran
- // out of memory.
- return false;
- }
- }
- return false;
-}
-
// Sideload service always exits after serving an install command.
static void SideloadHostService(unique_fd sfd, const std::string& args) {
- using namespace std::chrono_literals;
MinadbdCommandStatus status;
- auto error = RunAdbFuseSideload(sfd.get(), args, &status);
- // No need to wait if the socket is already closed, meaning the other end
- // already exited for some reason.
- if (error != kMinadbdHostSocketIOError) {
- // We sleep for a little bit just to wait for the host to receive last
- // "DONEDONE" message. However minadbd process is likely to get terminated
- // early due to exit_on_close
- WaitForSocketClose(sfd, 3000ms);
- }
- exit(error);
+ exit(RunAdbFuseSideload(sfd.get(), args, &status));
}
// Rescue service waits for the next command after an install command.
diff --git a/minui/Android.bp b/minui/Android.bp
index f68f6c8..fff3a8e 100644
--- a/minui/Android.bp
+++ b/minui/Android.bp
@@ -12,15 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package {
- // See: http://go/android-license-faq
- // A large-scale-change added 'default_applicable_licenses' to import
- // all of the 'license_kinds' from "bootable_recovery_license"
- // to get the below license kinds:
- // SPDX-license-identifier-Apache-2.0
- default_applicable_licenses: ["bootable_recovery_license"],
-}
-
cc_library {
name: "libminui",
recovery_available: true,
@@ -36,12 +27,14 @@
srcs: [
"events.cpp",
"graphics.cpp",
+ "graphics_adf.cpp",
"graphics_drm.cpp",
"graphics_fbdev.cpp",
"resources.cpp",
],
whole_static_libs: [
+ "libadf",
"libdrm",
"libsync",
],
diff --git a/minui/events.cpp b/minui/events.cpp
index 87f8112..863ac74 100644
--- a/minui/events.cpp
+++ b/minui/events.cpp
@@ -29,7 +29,9 @@
#include <functional>
#include <memory>
+#include <string>
+#include <android-base/strings.h>
#include <android-base/unique_fd.h>
#include "minui/minui.h"
@@ -118,12 +120,12 @@
}
offset += sizeof(inotify_event) + pevent->len;
- pevent->name[pevent->len] = '\0';
- if (strncmp(pevent->name, "event", 5)) {
+ std::string event_name(pevent->name, pevent->len);
+ if (!android::base::StartsWith(event_name, "event")) {
continue;
}
- android::base::unique_fd dfd(openat(dirfd(dir.get()), pevent->name, O_RDONLY));
+ android::base::unique_fd dfd(openat(dirfd(dir.get()), event_name.c_str(), O_RDONLY));
if (dfd == -1) {
break;
}
diff --git a/minui/graphics.cpp b/minui/graphics.cpp
index dce1e61..d34da56 100644
--- a/minui/graphics.cpp
+++ b/minui/graphics.cpp
@@ -25,6 +25,7 @@
#include <android-base/properties.h>
+#include "graphics_adf.h"
#include "graphics_drm.h"
#include "graphics_fbdev.h"
#include "minui/minui.h"
@@ -361,10 +362,15 @@
ret);
}
- auto backend = std::unique_ptr<MinuiBackend>{ std::make_unique<MinuiBackendDrm>() };
+ auto backend = std::unique_ptr<MinuiBackend>{ std::make_unique<MinuiBackendAdf>() };
gr_draw = backend->Init();
if (!gr_draw) {
+ backend = std::make_unique<MinuiBackendDrm>();
+ gr_draw = backend->Init();
+ }
+
+ if (!gr_draw) {
backend = std::make_unique<MinuiBackendFbdev>();
gr_draw = backend->Init();
}
diff --git a/minui/graphics_adf.cpp b/minui/graphics_adf.cpp
new file mode 100644
index 0000000..10cd607
--- /dev/null
+++ b/minui/graphics_adf.cpp
@@ -0,0 +1,200 @@
+/*
+ * Copyright (C) 2014 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.
+ */
+
+#include "graphics_adf.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+#include <adf/adf.h>
+#include <sync/sync.h>
+
+#include "minui/minui.h"
+
+GRSurfaceAdf::~GRSurfaceAdf() {
+ if (mmapped_buffer_) {
+ munmap(mmapped_buffer_, pitch * height);
+ }
+ if (fence_fd != -1) {
+ close(fence_fd);
+ }
+ if (fd != -1) {
+ close(fd);
+ }
+}
+
+std::unique_ptr<GRSurfaceAdf> GRSurfaceAdf::Create(int intf_fd, const drm_mode_modeinfo* mode,
+ __u32 format, int* err) {
+ __u32 offset;
+ __u32 pitch;
+ auto fd = adf_interface_simple_buffer_alloc(intf_fd, mode->hdisplay, mode->vdisplay, format,
+ &offset, &pitch);
+
+ if (fd < 0) {
+ *err = fd;
+ return nullptr;
+ }
+
+ std::unique_ptr<GRSurfaceAdf> surf = std::unique_ptr<GRSurfaceAdf>(
+ new GRSurfaceAdf(mode->hdisplay, mode->vdisplay, pitch, (format == DRM_FORMAT_RGB565 ? 2 : 4),
+ offset, pitch, fd));
+
+ auto mmapped =
+ mmap(nullptr, surf->pitch * surf->height, PROT_WRITE, MAP_SHARED, surf->fd, surf->offset);
+ if (mmapped == MAP_FAILED) {
+ *err = -errno;
+ return nullptr;
+ }
+ surf->mmapped_buffer_ = static_cast<uint8_t*>(mmapped);
+ return surf;
+}
+
+MinuiBackendAdf::MinuiBackendAdf() : intf_fd(-1), dev(), current_surface(0), n_surfaces(0) {}
+
+int MinuiBackendAdf::InterfaceInit() {
+ adf_interface_data intf_data;
+ if (int err = adf_get_interface_data(intf_fd, &intf_data); err < 0) return err;
+
+ int result = 0;
+ surfaces[0] = GRSurfaceAdf::Create(intf_fd, &intf_data.current_mode, format, &result);
+ if (!surfaces[0]) {
+ fprintf(stderr, "Failed to allocate surface 0: %s\n", strerror(-result));
+ goto done;
+ }
+
+ surfaces[1] = GRSurfaceAdf::Create(intf_fd, &intf_data.current_mode, format, &result);
+ if (!surfaces[1]) {
+ fprintf(stderr, "Failed to allocate surface 1: %s\n", strerror(-result));
+ n_surfaces = 1;
+ } else {
+ n_surfaces = 2;
+ }
+
+done:
+ adf_free_interface_data(&intf_data);
+ return result;
+}
+
+int MinuiBackendAdf::DeviceInit(adf_device* dev) {
+ adf_id_t intf_id;
+ int err = adf_find_simple_post_configuration(dev, &format, 1, &intf_id, &eng_id);
+ if (err < 0) return err;
+
+ err = adf_device_attach(dev, eng_id, intf_id);
+ if (err < 0 && err != -EALREADY) return err;
+
+ intf_fd = adf_interface_open(dev, intf_id, O_RDWR | O_CLOEXEC);
+ if (intf_fd < 0) return intf_fd;
+
+ err = InterfaceInit();
+ if (err < 0) {
+ close(intf_fd);
+ intf_fd = -1;
+ }
+
+ return err;
+}
+
+GRSurface* MinuiBackendAdf::Init() {
+ PixelFormat pixel_format = gr_pixel_format();
+ if (pixel_format == PixelFormat::ABGR) {
+ format = DRM_FORMAT_ABGR8888;
+ } else if (pixel_format == PixelFormat::BGRA) {
+ format = DRM_FORMAT_BGRA8888;
+ } else if (pixel_format == PixelFormat::RGBX) {
+ format = DRM_FORMAT_RGBX8888;
+ } else {
+ format = DRM_FORMAT_RGB565;
+ }
+
+ adf_id_t* dev_ids = nullptr;
+ ssize_t n_dev_ids = adf_devices(&dev_ids);
+ if (n_dev_ids == 0) {
+ return nullptr;
+ } else if (n_dev_ids < 0) {
+ fprintf(stderr, "enumerating adf devices failed: %s\n", strerror(-n_dev_ids));
+ return nullptr;
+ }
+
+ intf_fd = -1;
+
+ for (ssize_t i = 0; i < n_dev_ids && intf_fd < 0; i++) {
+ int err = adf_device_open(dev_ids[i], O_RDWR, &dev);
+ if (err < 0) {
+ fprintf(stderr, "opening adf device %u failed: %s\n", dev_ids[i], strerror(-err));
+ continue;
+ }
+
+ err = DeviceInit(&dev);
+ if (err < 0) {
+ fprintf(stderr, "initializing adf device %u failed: %s\n", dev_ids[i], strerror(-err));
+ adf_device_close(&dev);
+ }
+ }
+
+ free(dev_ids);
+
+ if (intf_fd < 0) return nullptr;
+
+ GRSurface* ret = Flip();
+
+ Blank(true);
+ Blank(false);
+
+ return ret;
+}
+
+void MinuiBackendAdf::Sync(GRSurfaceAdf* surf) {
+ static constexpr unsigned int kWarningTimeout = 3000;
+
+ if (surf == nullptr) return;
+
+ if (surf->fence_fd >= 0) {
+ int err = sync_wait(surf->fence_fd, kWarningTimeout);
+ if (err < 0) {
+ perror("adf sync fence wait error\n");
+ }
+
+ close(surf->fence_fd);
+ surf->fence_fd = -1;
+ }
+}
+
+GRSurface* MinuiBackendAdf::Flip() {
+ const auto& surf = surfaces[current_surface];
+
+ int fence_fd = adf_interface_simple_post(intf_fd, eng_id, surf->width, surf->height, format,
+ surf->fd, surf->offset, surf->pitch, -1);
+ if (fence_fd >= 0) surf->fence_fd = fence_fd;
+
+ current_surface = (current_surface + 1) % n_surfaces;
+ Sync(surfaces[current_surface].get());
+ return surfaces[current_surface].get();
+}
+
+void MinuiBackendAdf::Blank(bool blank) {
+ adf_interface_blank(intf_fd, blank ? DRM_MODE_DPMS_OFF : DRM_MODE_DPMS_ON);
+}
+
+MinuiBackendAdf::~MinuiBackendAdf() {
+ adf_device_close(&dev);
+ if (intf_fd >= 0) close(intf_fd);
+}
diff --git a/minui/graphics_adf.h b/minui/graphics_adf.h
new file mode 100644
index 0000000..79d8d2a
--- /dev/null
+++ b/minui/graphics_adf.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>
+#include <sys/types.h>
+
+#include <memory>
+
+#include <adf/adf.h>
+
+#include "graphics.h"
+#include "minui/minui.h"
+
+class GRSurfaceAdf : public GRSurface {
+ public:
+ ~GRSurfaceAdf() override;
+
+ static std::unique_ptr<GRSurfaceAdf> Create(int intf_fd, const drm_mode_modeinfo* mode,
+ __u32 format, int* err);
+
+ uint8_t* data() override {
+ return mmapped_buffer_;
+ }
+
+ private:
+ friend class MinuiBackendAdf;
+
+ GRSurfaceAdf(size_t width, size_t height, size_t row_bytes, size_t pixel_bytes, __u32 offset,
+ __u32 pitch, int fd)
+ : GRSurface(width, height, row_bytes, pixel_bytes), offset(offset), pitch(pitch), fd(fd) {}
+
+ const __u32 offset;
+ const __u32 pitch;
+
+ int fd;
+ int fence_fd{ -1 };
+ uint8_t* mmapped_buffer_{ nullptr };
+};
+
+class MinuiBackendAdf : public MinuiBackend {
+ public:
+ MinuiBackendAdf();
+ ~MinuiBackendAdf() override;
+ GRSurface* Init() override;
+ GRSurface* Flip() override;
+ void Blank(bool) override;
+
+ private:
+ int InterfaceInit();
+ int DeviceInit(adf_device* dev);
+ void Sync(GRSurfaceAdf* surf);
+
+ int intf_fd;
+ adf_id_t eng_id;
+ __u32 format;
+ adf_device dev;
+ size_t current_surface;
+ size_t n_surfaces;
+ std::unique_ptr<GRSurfaceAdf> surfaces[2];
+};
diff --git a/minui/resources.cpp b/minui/resources.cpp
index d7b9277..f635acd 100644
--- a/minui/resources.cpp
+++ b/minui/resources.cpp
@@ -450,5 +450,5 @@
}
void res_free_surface(GRSurface* surface) {
- delete(surface);
+ free(surface);
}
diff --git a/otautil/Android.bp b/otautil/Android.bp
index 557b8a3..3b3f9cb 100644
--- a/otautil/Android.bp
+++ b/otautil/Android.bp
@@ -12,15 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package {
- // See: http://go/android-license-faq
- // A large-scale-change added 'default_applicable_licenses' to import
- // all of the 'license_kinds' from "bootable_recovery_license"
- // to get the below license kinds:
- // SPDX-license-identifier-Apache-2.0
- default_applicable_licenses: ["bootable_recovery_license"],
-}
-
cc_library_static {
name: "libotautil",
diff --git a/otautil/include/otautil/error_code.h b/otautil/include/otautil/error_code.h
index 7b52ce5..2b73c13 100644
--- a/otautil/include/otautil/error_code.h
+++ b/otautil/include/otautil/error_code.h
@@ -22,7 +22,7 @@
kLowBattery = 20,
kZipVerificationFailure,
kZipOpenFailure,
- kBootreasonInBlocklist,
+ kBootreasonInBlacklist,
kPackageCompatibilityFailure,
kScriptExecutionFailure,
kMapFileFailure,
diff --git a/recovery.cpp b/recovery.cpp
index 36924fb..7675121 100644
--- a/recovery.cpp
+++ b/recovery.cpp
@@ -421,15 +421,15 @@
case Device::REBOOT:
case Device::SHUTDOWN:
if (!ui->IsTextVisible()) {
- return chosen_action;
+ return Device::REBOOT;
}
// okay to reboot; no need to ask.
if (!update_in_progress) {
- return chosen_action;
+ return Device::REBOOT;
}
// An update might have been failed. Ask if user really wants to reboot.
if (AskToReboot(device, chosen_action)) {
- return chosen_action;
+ return Device::REBOOT;
}
break;
@@ -559,15 +559,15 @@
}
}
-static bool bootreason_in_blocklist() {
+static bool bootreason_in_blacklist() {
std::string bootreason = android::base::GetProperty("ro.boot.bootreason", "");
if (!bootreason.empty()) {
// More bootreasons can be found in "system/core/bootstat/bootstat.cpp".
- static const std::vector<std::string> kBootreasonBlocklist{
+ static const std::vector<std::string> kBootreasonBlacklist{
"kernel_panic",
"Panic",
};
- for (const auto& str : kBootreasonBlocklist) {
+ for (const auto& str : kBootreasonBlacklist) {
if (android::base::EqualsIgnoreCase(str, bootreason)) return true;
}
}
@@ -702,7 +702,7 @@
}
std::vector<std::string> title_lines =
- android::base::Split(android::base::GetProperty("ro.build.fingerprint", ""), ":");
+ android::base::Split(android::base::GetProperty("ro.bootimage.build.fingerprint", ""), ":");
title_lines.insert(std::begin(title_lines), "Android Recovery");
ui->SetTitle(title_lines);
@@ -734,10 +734,10 @@
// Log the error code to last_install when installation skips due to low battery.
log_failure_code(kLowBattery, update_package);
status = INSTALL_SKIPPED;
- } else if (retry_count == 0 && bootreason_in_blocklist()) {
+ } else if (retry_count == 0 && bootreason_in_blacklist()) {
// Skip update-on-reboot when bootreason is kernel_panic or similar
- ui->Print("bootreason is in the blocklist; skip OTA installation\n");
- log_failure_code(kBootreasonInBlocklist, update_package);
+ ui->Print("bootreason is in the blacklist; skip OTA installation\n");
+ log_failure_code(kBootreasonInBlacklist, update_package);
status = INSTALL_SKIPPED;
} else {
// It's a fresh update. Initialize the retry_count in the BCB to 1; therefore we can later
diff --git a/recovery_ui/Android.bp b/recovery_ui/Android.bp
index f64b0d1..9dfee5f 100644
--- a/recovery_ui/Android.bp
+++ b/recovery_ui/Android.bp
@@ -12,15 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package {
- // See: http://go/android-license-faq
- // A large-scale-change added 'default_applicable_licenses' to import
- // all of the 'license_kinds' from "bootable_recovery_license"
- // to get the below license kinds:
- // SPDX-license-identifier-Apache-2.0
- default_applicable_licenses: ["bootable_recovery_license"],
-}
-
cc_library {
name: "librecovery_ui",
recovery_available: true,
@@ -31,7 +22,6 @@
srcs: [
"device.cpp",
- "ethernet_device.cpp",
"ethernet_ui.cpp",
"screen_ui.cpp",
"stub_ui.cpp",
@@ -112,7 +102,7 @@
],
srcs: [
- "default_ethernet_device.cpp",
+ "ethernet_device.cpp",
],
shared_libs: [
diff --git a/recovery_ui/default_ethernet_device.cpp b/recovery_ui/default_ethernet_device.cpp
deleted file mode 100644
index 1fdff0d..0000000
--- a/recovery_ui/default_ethernet_device.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (C) 2020 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.
- */
-
-#include "recovery_ui/device.h"
-#include "recovery_ui/ethernet_device.h"
-#include "recovery_ui/ethernet_ui.h"
-
-Device* make_device() {
- return new EthernetDevice(new EthernetRecoveryUI);
-}
diff --git a/recovery_ui/ethernet_device.cpp b/recovery_ui/ethernet_device.cpp
index d79f41d..39ec65d 100644
--- a/recovery_ui/ethernet_device.cpp
+++ b/recovery_ui/ethernet_device.cpp
@@ -27,9 +27,23 @@
#include <sys/types.h>
#include "recovery_ui/device.h"
-#include "recovery_ui/ethernet_device.h"
#include "recovery_ui/ethernet_ui.h"
+class EthernetDevice : public Device {
+ public:
+ explicit EthernetDevice(EthernetRecoveryUI* ui);
+
+ void PreRecovery() override;
+ void PreFastboot() override;
+
+ private:
+ int SetInterfaceFlags(const unsigned set, const unsigned clr);
+ void SetTitleIPv6LinkLocalAddress(const bool interface_up);
+
+ android::base::unique_fd ctl_sock_;
+ static const std::string interface;
+};
+
const std::string EthernetDevice::interface = "eth0";
EthernetDevice::EthernetDevice(EthernetRecoveryUI* ui)
@@ -115,3 +129,8 @@
recovery_ui->SetIPv6LinkLocalAddress();
}
+
+// -----------------------------------------------------------------------------------------
+Device* make_device() {
+ return new EthernetDevice(new EthernetRecoveryUI);
+}
diff --git a/recovery_ui/include/recovery_ui/ethernet_device.h b/recovery_ui/include/recovery_ui/ethernet_device.h
deleted file mode 100644
index ea710ab..0000000
--- a/recovery_ui/include/recovery_ui/ethernet_device.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2020 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 _ETHERNET_RECOVERY_DEVICE_H
-#define _ETHERNET_RECOVERY_DEVICE_H
-
-#include "device.h"
-
-#include <android-base/unique_fd.h>
-
-// Forward declaration to avoid including "ethernet_ui.h".
-class EthernetRecoveryUI;
-
-class EthernetDevice : public Device {
- public:
- explicit EthernetDevice(EthernetRecoveryUI* ui);
-
- void PreRecovery() override;
- void PreFastboot() override;
-
- private:
- int SetInterfaceFlags(const unsigned set, const unsigned clr);
- void SetTitleIPv6LinkLocalAddress(const bool interface_up);
-
- android::base::unique_fd ctl_sock_;
- static const std::string interface;
-};
-
-#endif // _ETHERNET_RECOVERY_DEVICE_H
diff --git a/recovery_ui/include/recovery_ui/ui.h b/recovery_ui/include/recovery_ui/ui.h
index 512732f..08ec1d7 100644
--- a/recovery_ui/include/recovery_ui/ui.h
+++ b/recovery_ui/include/recovery_ui/ui.h
@@ -192,8 +192,6 @@
return key_interrupted_;
}
- virtual bool IsUsbConnected();
-
protected:
void EnqueueKey(int key_code);
@@ -228,6 +226,8 @@
void ProcessKey(int key_code, int updown);
void TimeKey(int key_code, int count);
+ bool IsUsbConnected();
+
bool InitScreensaver();
void SetScreensaverState(ScreensaverState state);
diff --git a/recovery_ui/screen_ui.cpp b/recovery_ui/screen_ui.cpp
index b2c828f..087fc0e 100644
--- a/recovery_ui/screen_ui.cpp
+++ b/recovery_ui/screen_ui.cpp
@@ -37,7 +37,6 @@
#include <unordered_map>
#include <vector>
-#include <android-base/chrono_utils.h>
#include <android-base/logging.h>
#include <android-base/properties.h>
#include <android-base/stringprintf.h>
@@ -449,9 +448,7 @@
int frame_height = gr_get_height(frame);
int frame_x = (ScreenWidth() - frame_width) / 2;
int frame_y = GetAnimationBaseline();
- if (frame_x >= 0 && frame_y >= 0 && (frame_x + frame_width) < ScreenWidth() &&
- (frame_y + frame_height) < ScreenHeight())
- DrawSurface(frame, 0, 0, frame_width, frame_height, frame_x, frame_y);
+ DrawSurface(frame, 0, 0, frame_width, frame_height, frame_x, frame_y);
}
if (progressBarType != EMPTY) {
@@ -882,28 +879,10 @@
return true;
}
-static bool InitGraphics() {
- // Timeout is same as init wait for file default of 5 seconds and is arbitrary
- const unsigned timeout = 500; // 10ms increments
- for (auto retry = timeout; retry > 0; --retry) {
- if (gr_init() == 0) {
- if (retry < timeout) {
- // Log message like init wait for file completion log for consistency.
- LOG(WARNING) << "wait for 'graphics' took " << ((timeout - retry) * 10) << "ms";
- }
- return true;
- }
- std::this_thread::sleep_for(10ms);
- }
- // Log message like init wait for file timeout log for consistency.
- LOG(ERROR) << "timeout wait for 'graphics' took " << (timeout * 10) << "ms";
- return false;
-}
-
bool ScreenRecoveryUI::Init(const std::string& locale) {
RecoveryUI::Init(locale);
- if (!InitGraphics()) {
+ if (gr_init() == -1) {
return false;
}
diff --git a/recovery_ui/ui.cpp b/recovery_ui/ui.cpp
index 6e67b1d..3307217 100644
--- a/recovery_ui/ui.cpp
+++ b/recovery_ui/ui.cpp
@@ -48,10 +48,6 @@
constexpr const char* BRIGHTNESS_FILE_SDM = "/sys/class/backlight/panel0-backlight/brightness";
constexpr const char* MAX_BRIGHTNESS_FILE_SDM =
"/sys/class/backlight/panel0-backlight/max_brightness";
-constexpr const char* BRIGHTNESS_FILE_PWM =
- "/sys/class/backlight/pwm-backlight.0/brightness";
-constexpr const char* MAX_BRIGHTNESS_FILE_PWM =
- "/sys/class/backlight/pwm-backlight.0/max_brightness";
constexpr int kDefaultTouchLowThreshold = 50;
constexpr int kDefaultTouchHighThreshold = 90;
@@ -110,19 +106,10 @@
return false;
}
if (access(brightness_file_.c_str(), R_OK | W_OK)) {
- if (!access(BRIGHTNESS_FILE_SDM, R_OK | W_OK)) {
- brightness_file_ = BRIGHTNESS_FILE_SDM;
- } else {
- brightness_file_ = BRIGHTNESS_FILE_PWM;
- }
+ brightness_file_ = BRIGHTNESS_FILE_SDM;
}
-
if (access(max_brightness_file_.c_str(), R_OK)) {
- if (!access(MAX_BRIGHTNESS_FILE_SDM, R_OK)) {
- max_brightness_file_ = MAX_BRIGHTNESS_FILE_SDM;
- } else {
- max_brightness_file_ = MAX_BRIGHTNESS_FILE_PWM;
- }
+ max_brightness_file_ = MAX_BRIGHTNESS_FILE_SDM;
}
// Set the initial brightness level based on the max brightness. Note that reading the initial
// value from BRIGHTNESS_FILE doesn't give the actual brightness value (bullhead, sailfish), so
diff --git a/recovery_utils/Android.bp b/recovery_utils/Android.bp
index e0e9ec0..bf79a2e 100644
--- a/recovery_utils/Android.bp
+++ b/recovery_utils/Android.bp
@@ -12,15 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package {
- // See: http://go/android-license-faq
- // A large-scale-change added 'default_applicable_licenses' to import
- // all of the 'license_kinds' from "bootable_recovery_license"
- // to get the below license kinds:
- // SPDX-license-identifier-Apache-2.0
- default_applicable_licenses: ["bootable_recovery_license"],
-}
-
cc_defaults {
name: "librecovery_utils_defaults",
diff --git a/recovery_utils/roots.cpp b/recovery_utils/roots.cpp
index 1948447..99f3c5d 100644
--- a/recovery_utils/roots.cpp
+++ b/recovery_utils/roots.cpp
@@ -259,12 +259,6 @@
make_f2fs_cmd.push_back("-C");
make_f2fs_cmd.push_back("utf8");
}
- if (v->fs_mgr_flags.fs_compress) {
- make_f2fs_cmd.push_back("-O");
- make_f2fs_cmd.push_back("compression");
- make_f2fs_cmd.push_back("-O");
- make_f2fs_cmd.push_back("extra_attr");
- }
make_f2fs_cmd.push_back(v->blk_device);
if (length >= kSectorSize) {
make_f2fs_cmd.push_back(std::to_string(length / kSectorSize));
diff --git a/tests/Android.bp b/tests/Android.bp
index 5ef4d58..4c23255 100644
--- a/tests/Android.bp
+++ b/tests/Android.bp
@@ -12,15 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package {
- // See: http://go/android-license-faq
- // A large-scale-change added 'default_applicable_licenses' to import
- // all of the 'license_kinds' from "bootable_recovery_license"
- // to get the below license kinds:
- // SPDX-license-identifier-Apache-2.0
- default_applicable_licenses: ["bootable_recovery_license"],
-}
-
cc_defaults {
name: "recovery_test_defaults",
@@ -40,6 +31,7 @@
"libpng",
"libprocessgroup",
"libselinux",
+ "libz",
"libziparchive",
],
@@ -73,7 +65,7 @@
"libbase",
"libbrotli",
"libbz",
- "libz_stable",
+ "libz",
"libziparchive",
]
@@ -103,24 +95,6 @@
"libc++fs",
]
-// recovery image for unittests.
-// ========================================================
-genrule {
- name: "recovery_image",
- cmd: "cat $(location testdata/recovery_head) <(cat $(location testdata/recovery_body) | $(location minigzip)) $(location testdata/recovery_tail) > $(out)",
- srcs: [
- "testdata/recovery_head",
- "testdata/recovery_body",
- "testdata/recovery_tail",
- ],
- tools: [
- "minigzip",
- ],
- out: [
- "testdata/recovery.img",
- ],
-}
-
cc_test {
name: "recovery_unit_test",
isolated: true,
@@ -148,15 +122,12 @@
"libupdater_core",
"libupdate_verifier",
+ "libgtest_prod",
"libprotobuf-cpp-lite",
],
- header_libs: [
- "libgtest_prod_headers",
- ],
data: [
"testdata/*",
- ":recovery_image",
":res-testdata",
],
}
@@ -211,23 +182,3 @@
},
},
}
-
-cc_fuzz {
- name: "libinstall_verify_package_fuzzer",
- defaults: [
- "recovery_test_defaults",
- ],
-
- srcs: ["fuzz/verify_package_fuzzer.cpp"],
-
- corpus: [
- "testdata/otasigned*.zip",
- ],
-
- static_libs: [
- "libotautil",
- "libinstall",
- "librecovery_ui",
- "libminui",
- ],
-}
diff --git a/tests/AndroidTest.xml b/tests/AndroidTest.xml
deleted file mode 100644
index 0ac75e4..0000000
--- a/tests/AndroidTest.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2020 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.
--->
-<configuration description="Runs recovery_host_test.">
- <option name="null-device" value="true" />
-
- <target_preparer class="com.android.tradefed.targetprep.RootTargetPreparer">
- <option name="force-root" value="false" />
- </target_preparer>
- <option name="not-shardable" value="true" />
-
- <test class="com.android.tradefed.testtype.HostGTest" >
- <option name="module-name" value="recovery_host_test" />
- <option name="native-test-timeout" value="5m"/>
- </test>
-</configuration>
diff --git a/tests/fuzz/verify_package_fuzzer.cpp b/tests/fuzz/verify_package_fuzzer.cpp
deleted file mode 100644
index baa44e0..0000000
--- a/tests/fuzz/verify_package_fuzzer.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (C) 2020 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.
- */
-
-#include "fuzzer/FuzzedDataProvider.h"
-
-#include "install/install.h"
-#include "install/package.h"
-#include "recovery_ui/stub_ui.h"
-
-std::unique_ptr<Package> CreatePackage(std::vector<uint8_t>& content) {
- return Package::CreateMemoryPackage(content, [](float) -> void {});
-}
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
- FuzzedDataProvider data_provider(data, size);
- auto package_contents = data_provider.ConsumeRemainingBytes<uint8_t>();
- if (package_contents.size() == 0) {
- return 0;
- }
- auto package = CreatePackage(package_contents);
- StubRecoveryUI ui;
- verify_package(package.get(), &ui);
- return 0;
-}
diff --git a/tests/testdata/recovery-from-boot.p b/tests/testdata/recovery-from-boot.p
index 81738ed..06f6c29 100644
--- a/tests/testdata/recovery-from-boot.p
+++ b/tests/testdata/recovery-from-boot.p
Binary files differ
diff --git a/tests/testdata/recovery.img b/tests/testdata/recovery.img
new file mode 100644
index 0000000..b862e6f
--- /dev/null
+++ b/tests/testdata/recovery.img
Binary files differ
diff --git a/tests/testdata/recovery_body b/tests/testdata/recovery_body
deleted file mode 100644
index 48d7c10..0000000
--- a/tests/testdata/recovery_body
+++ /dev/null
Binary files differ
diff --git a/tests/testdata/recovery_head b/tests/testdata/recovery_head
deleted file mode 100644
index 7f494d0..0000000
--- a/tests/testdata/recovery_head
+++ /dev/null
Binary files differ
diff --git a/tests/testdata/recovery_tail b/tests/testdata/recovery_tail
deleted file mode 100644
index 7fe2c6c..0000000
--- a/tests/testdata/recovery_tail
+++ /dev/null
Binary files differ
diff --git a/tests/testdata/ziptest_fake-update.zip b/tests/testdata/ziptest_dummy-update.zip
similarity index 100%
rename from tests/testdata/ziptest_fake-update.zip
rename to tests/testdata/ziptest_dummy-update.zip
Binary files differ
diff --git a/tests/unit/host/imgdiff_test.cpp b/tests/unit/host/imgdiff_test.cpp
index 978ac7c..e76ccbd 100644
--- a/tests/unit/host/imgdiff_test.cpp
+++ b/tests/unit/host/imgdiff_test.cpp
@@ -35,6 +35,7 @@
using android::base::get_unaligned;
+// Sanity check for the given imgdiff patch header.
static void verify_patch_header(const std::string& patch, size_t* num_normal, size_t* num_raw,
size_t* num_deflate) {
const size_t size = patch.size();
diff --git a/tests/unit/install_test.cpp b/tests/unit/install_test.cpp
index c341547..ee75349 100644
--- a/tests/unit/install_test.cpp
+++ b/tests/unit/install_test.cpp
@@ -76,7 +76,7 @@
TEST(InstallTest, read_metadata_from_package_no_entry) {
TemporaryFile temp_file;
- BuildZipArchive({ { "fake_entry", "" } }, temp_file.release(), kCompressStored);
+ BuildZipArchive({ { "dummy_entry", "" } }, temp_file.release(), kCompressStored);
ZipArchiveHandle zip;
ASSERT_EQ(0, OpenArchive(temp_file.path, &zip));
@@ -153,7 +153,7 @@
TEST(InstallTest, SetUpNonAbUpdateCommands_MissingUpdateBinary) {
TemporaryFile temp_file;
// The archive must have something to be opened correctly.
- BuildZipArchive({ { "fake_entry", "" } }, temp_file.release(), kCompressStored);
+ BuildZipArchive({ { "dummy_entry", "" } }, temp_file.release(), kCompressStored);
// Missing update binary.
ZipArchiveHandle zip;
@@ -190,7 +190,7 @@
ZipArchiveHandle zip;
ASSERT_EQ(0, OpenArchive(temp_file.path, &zip));
- ZipEntry64 payload_entry;
+ ZipEntry payload_entry;
ASSERT_EQ(0, FindEntry(zip, "payload.bin", &payload_entry));
std::map<std::string, std::string> metadata;
@@ -334,7 +334,7 @@
metadata = android::base::Join(
std::vector<std::string>{
"ota-type=BRICK",
- "pre-device=fake_device_type",
+ "pre-device=dummy_device_type",
},
"\n");
TestCheckPackageMetadata(metadata, OtaType::BRICK, false);
@@ -358,7 +358,7 @@
std::vector<std::string>{
"ota-type=BRICK",
"pre-device=" + device,
- "serialno=fake_serial",
+ "serialno=dummy_serial",
},
"\n");
TestCheckPackageMetadata(metadata, OtaType::BRICK, false);
@@ -383,7 +383,7 @@
ASSERT_NE("", serialno);
std::vector<std::string> serial_numbers;
- // Creates a fake serial number string.
+ // Creates a dummy serial number string.
for (char c = 'a'; c <= 'z'; c++) {
serial_numbers.emplace_back(serialno.size(), c);
}
@@ -431,7 +431,7 @@
std::vector<std::string>{
"ota-type=AB",
"pre-device=" + device,
- "pre-build-incremental=fake_build",
+ "pre-build-incremental=dummy_build",
"post-timestamp=" + std::to_string(std::numeric_limits<int64_t>::max()),
},
"\n");
@@ -459,35 +459,7 @@
std::vector<std::string>{
"ota-type=AB",
"pre-device=" + device,
- "pre-build=fake_build_fingerprint",
- "post-timestamp=" + std::to_string(std::numeric_limits<int64_t>::max()),
- },
- "\n");
- TestCheckPackageMetadata(metadata, OtaType::AB, false);
-}
-
-TEST(InstallTest, CheckPackageMetadata_dynamic_fingerprint) {
- std::string device = android::base::GetProperty("ro.product.device", "");
- ASSERT_FALSE(device.empty());
-
- std::string finger_print = android::base::GetProperty("ro.build.fingerprint", "");
- ASSERT_FALSE(finger_print.empty());
-
- std::string metadata = android::base::Join(
- std::vector<std::string>{
- "ota-type=AB",
- "pre-device=please|work|" + device + "|please|work",
- "pre-build=" + finger_print = "pass|this|test",
- "post-timestamp=" + std::to_string(std::numeric_limits<int64_t>::max()),
- },
- "\n");
- TestCheckPackageMetadata(metadata, OtaType::AB, true);
-
- metadata = android::base::Join(
- std::vector<std::string>{
- "ota-type=AB",
- "pre-device=" + device,
- "pre-build=fake_build_fingerprint",
+ "pre-build=dummy_build_fingerprint",
"post-timestamp=" + std::to_string(std::numeric_limits<int64_t>::max()),
},
"\n");
diff --git a/tests/unit/package_test.cpp b/tests/unit/package_test.cpp
index 164a93d..5e31f7f 100644
--- a/tests/unit/package_test.cpp
+++ b/tests/unit/package_test.cpp
@@ -106,7 +106,7 @@
// Check that we can extract one zip entry.
std::string_view entry_name = "dir1/file3.txt";
- ZipEntry64 entry;
+ ZipEntry entry;
ASSERT_EQ(0, FindEntry(zip, entry_name, &entry));
std::vector<uint8_t> extracted(entry_name.size());
diff --git a/tests/unit/zip_test.cpp b/tests/unit/zip_test.cpp
index e065bb8..0753d64 100644
--- a/tests/unit/zip_test.cpp
+++ b/tests/unit/zip_test.cpp
@@ -28,7 +28,7 @@
#include "otautil/sysutil.h"
TEST(ZipTest, OpenFromMemory) {
- std::string zip_path = from_testdata_base("ziptest_fake-update.zip");
+ std::string zip_path = from_testdata_base("ziptest_dummy-update.zip");
MemMapping map;
ASSERT_TRUE(map.MapFile(zip_path));
@@ -37,7 +37,7 @@
ASSERT_EQ(0, OpenArchiveFromMemory(map.addr, map.length, zip_path.c_str(), &handle));
static constexpr const char* BINARY_PATH = "META-INF/com/google/android/update-binary";
- ZipEntry64 binary_entry;
+ ZipEntry binary_entry;
// Make sure the package opens correctly and its entry can be read.
ASSERT_EQ(0, FindEntry(handle, BINARY_PATH, &binary_entry));
diff --git a/tools/image_generator/Android.bp b/tools/image_generator/Android.bp
index c9748fa..8300040 100644
--- a/tools/image_generator/Android.bp
+++ b/tools/image_generator/Android.bp
@@ -12,15 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package {
- // See: http://go/android-license-faq
- // A large-scale-change added 'default_applicable_licenses' to import
- // all of the 'license_kinds' from "bootable_recovery_license"
- // to get the below license kinds:
- // SPDX-license-identifier-Apache-2.0
- default_applicable_licenses: ["bootable_recovery_license"],
-}
-
java_library_host {
name: "RecoveryImageGenerator",
diff --git a/tools/image_generator/ImageGenerator.java b/tools/image_generator/ImageGenerator.java
index 6c5ea4b..1da43e5 100644
--- a/tools/image_generator/ImageGenerator.java
+++ b/tools/image_generator/ImageGenerator.java
@@ -113,30 +113,30 @@
private static final Map<String, String> LANGUAGE_TO_FONT_MAP =
new TreeMap<String, String>() {
{
- put("am", "NotoSansEthiopic-VF");
+ put("am", "NotoSansEthiopic-Regular");
put("ar", "NotoNaskhArabicUI-Regular");
- put("as", "NotoSansBengaliUI-VF");
- put("bn", "NotoSansBengaliUI-VF");
+ put("as", "NotoSansBengaliUI-Regular");
+ put("bn", "NotoSansBengaliUI-Regular");
put("fa", "NotoNaskhArabicUI-Regular");
put("gu", "NotoSansGujaratiUI-Regular");
- put("hi", "NotoSansDevanagariUI-VF");
- put("hy", "NotoSansArmenian-VF");
+ put("hi", "NotoSansDevanagariUI-Regular");
+ put("hy", "NotoSansArmenian-Regular");
put("iw", "NotoSansHebrew-Regular");
put("ja", "NotoSansCJK-Regular");
put("ka", "NotoSansGeorgian-VF");
put("ko", "NotoSansCJK-Regular");
put("km", "NotoSansKhmerUI-Regular");
- put("kn", "NotoSansKannadaUI-VF");
+ put("kn", "NotoSansKannadaUI-Regular");
put("lo", "NotoSansLaoUI-Regular");
- put("ml", "NotoSansMalayalamUI-VF");
- put("mr", "NotoSansDevanagariUI-VF");
+ put("ml", "NotoSansMalayalamUI-Regular");
+ put("mr", "NotoSansDevanagariUI-Regular");
put("my", "NotoSansMyanmarUI-Regular");
- put("ne", "NotoSansDevanagariUI-VF");
+ put("ne", "NotoSansDevanagariUI-Regular");
put("or", "NotoSansOriya-Regular");
- put("pa", "NotoSansGurmukhiUI-VF");
- put("si", "NotoSansSinhalaUI-VF");
- put("ta", "NotoSansTamilUI-VF");
- put("te", "NotoSansTeluguUI-VF");
+ put("pa", "NotoSansGurmukhiUI-Regular");
+ put("si", "NotoSansSinhala-Regular");
+ put("ta", "NotoSansTamilUI-Regular");
+ put("te", "NotoSansTeluguUI-Regular");
put("th", "NotoSansThaiUI-Regular");
put("ur", "NotoNaskhArabicUI-Regular");
put("zh", "NotoSansCJK-Regular");
diff --git a/tools/image_generator/README.md b/tools/image_generator/README.md
index 1230ad5..5d70354 100644
--- a/tools/image_generator/README.md
+++ b/tools/image_generator/README.md
@@ -19,13 +19,3 @@
4. `resourceDirectory`: The resource directory that contains all the translated
strings in xml format, e.g. bootable/recovery/tools/recovery_l10n/res/
5. `outputFilename`: Path to the generated image.
-
-# Locales
-Supported locales and background texts are located in
-[tools/recovery_l10n/res/](../recovery_l10n/res/values). For each background text, the tool renders
-a localized image for every supported locale.
-
-Each individual localized image contains an encoded locale header string, and the rendered
-background text. The locale header string is generated by `Locale.forLanguageTag`. And sample
-result include `en-US`, `zh-CN`, etc. These individual images are then concatenated together to
-form the final resource image that locates in res/images, e.g. `install_text.png`
diff --git a/tools/recovery_l10n/Android.bp b/tools/recovery_l10n/Android.bp
index ac08e1a..d0a6d4b 100644
--- a/tools/recovery_l10n/Android.bp
+++ b/tools/recovery_l10n/Android.bp
@@ -12,15 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package {
- // See: http://go/android-license-faq
- // A large-scale-change added 'default_applicable_licenses' to import
- // all of the 'license_kinds' from "bootable_recovery_license"
- // to get the below license kinds:
- // SPDX-license-identifier-Apache-2.0
- default_applicable_licenses: ["bootable_recovery_license"],
-}
-
android_app {
name: "RecoveryLocalizer",
diff --git a/uncrypt/Android.bp b/uncrypt/Android.bp
index fbb4c1f..107a7f0 100644
--- a/uncrypt/Android.bp
+++ b/uncrypt/Android.bp
@@ -12,15 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package {
- // See: http://go/android-license-faq
- // A large-scale-change added 'default_applicable_licenses' to import
- // all of the 'license_kinds' from "bootable_recovery_license"
- // to get the below license kinds:
- // SPDX-license-identifier-Apache-2.0
- default_applicable_licenses: ["bootable_recovery_license"],
-}
-
cc_binary {
name: "uncrypt",
diff --git a/uncrypt/uncrypt.cpp b/uncrypt/uncrypt.cpp
index c798e31..f1f4f69 100644
--- a/uncrypt/uncrypt.cpp
+++ b/uncrypt/uncrypt.cpp
@@ -477,9 +477,9 @@
return kUncryptRealpathFindError;
}
- bool encryptable = false;
- bool encrypted = false;
- bool f2fs_fs = false;
+ bool encryptable;
+ bool encrypted;
+ bool f2fs_fs;
const std::string blk_dev = FindBlockDevice(path, &encryptable, &encrypted, &f2fs_fs);
if (blk_dev.empty()) {
LOG(ERROR) << "Failed to find block device for " << path;
diff --git a/update_verifier/Android.bp b/update_verifier/Android.bp
index ff2eff9..f656713 100644
--- a/update_verifier/Android.bp
+++ b/update_verifier/Android.bp
@@ -12,15 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package {
- // See: http://go/android-license-faq
- // A large-scale-change added 'default_applicable_licenses' to import
- // all of the 'license_kinds' from "bootable_recovery_license"
- // to get the below license kinds:
- // SPDX-license-identifier-Apache-2.0
- default_applicable_licenses: ["bootable_recovery_license"],
-}
-
cc_defaults {
name: "update_verifier_defaults",
@@ -121,12 +112,12 @@
version: {
py2: {
- enabled: false,
- embedded_launcher: false,
- },
- py3: {
enabled: true,
embedded_launcher: true,
},
+ py3: {
+ enabled: false,
+ embedded_launcher: false,
+ },
},
}
diff --git a/update_verifier/care_map_generator.py b/update_verifier/care_map_generator.py
index c6f2dad..051d98d 100644
--- a/update_verifier/care_map_generator.py
+++ b/update_verifier/care_map_generator.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+#!/usr/bin/env python
#
# Copyright (C) 2018 The Android Open Source Project
#
@@ -115,13 +115,13 @@
content = input_care_map.read()
if args.parse_proto:
- result = ParseProtoMessage(content, args.fingerprint_enabled).encode()
+ result = ParseProtoMessage(content, args.fingerprint_enabled)
else:
care_map_proto = GenerateCareMapProtoFromLegacyFormat(
content.rstrip().splitlines(), args.fingerprint_enabled)
result = care_map_proto.SerializeToString()
- with open(args.output_file, 'wb') as output:
+ with open(args.output_file, 'w') as output:
output.write(result)
diff --git a/updater/Android.bp b/updater/Android.bp
index 35debaa..f00a192 100644
--- a/updater/Android.bp
+++ b/updater/Android.bp
@@ -12,15 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package {
- // See: http://go/android-license-faq
- // A large-scale-change added 'default_applicable_licenses' to import
- // all of the 'license_kinds' from "bootable_recovery_license"
- // to get the below license kinds:
- // SPDX-license-identifier-Apache-2.0
- default_applicable_licenses: ["bootable_recovery_license"],
-}
-
cc_defaults {
name: "libupdater_static_libs",
@@ -36,6 +27,7 @@
"libfec_rs",
"libavb",
"libverity_tree",
+ "libgtest_prod",
"liblog",
"liblp",
"libselinux",
@@ -50,9 +42,6 @@
"libcutils",
"libutils",
],
- header_libs: [
- "libgtest_prod_headers",
- ],
}
cc_defaults {
diff --git a/updater/Android.mk b/updater/Android.mk
index bb1c07d..46300d9 100644
--- a/updater/Android.mk
+++ b/updater/Android.mk
@@ -34,6 +34,7 @@
libfec_rs \
libavb \
libverity_tree \
+ libgtest_prod \
liblog \
liblp \
libselinux \
@@ -71,9 +72,6 @@
include $(CLEAR_VARS)
LOCAL_MODULE := updater
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/../NOTICE
LOCAL_SRC_FILES := \
updater_main.cpp
@@ -95,8 +93,6 @@
libtune2fs \
$(tune2fs_static_libraries)
-LOCAL_HEADER_LIBRARIES := libgtest_prod_headers
-
LOCAL_MODULE_CLASS := EXECUTABLES
inc := $(call local-generated-sources-dir)/register.inc
diff --git a/updater/blockimg.cpp b/updater/blockimg.cpp
index b29aa8c..2d41f61 100644
--- a/updater/blockimg.cpp
+++ b/updater/blockimg.cpp
@@ -348,7 +348,7 @@
*/
struct NewThreadInfo {
ZipArchiveHandle za;
- ZipEntry64 entry{};
+ ZipEntry entry;
bool brotli_compressed;
std::unique_ptr<RangeSinkWriter> writer;
@@ -1626,7 +1626,7 @@
static Value* PerformBlockImageUpdate(const char* name, State* state,
const std::vector<std::unique_ptr<Expr>>& argv,
const CommandMap& command_map, bool dryrun) {
- CommandParameters params{};
+ CommandParameters params = {};
stash_map.clear();
params.canwrite = !dryrun;
@@ -1687,7 +1687,7 @@
}
std::string_view path_data(patch_data_fn->data);
- ZipEntry64 patch_entry;
+ ZipEntry patch_entry;
if (FindEntry(za, path_data, &patch_entry) != 0) {
LOG(ERROR) << name << "(): no file \"" << patch_data_fn->data << "\" in package";
return StringValue("");
@@ -1695,7 +1695,7 @@
params.patch_start = updater->GetMappedPackageAddress() + patch_entry.offset;
std::string_view new_data(new_data_fn->data);
- ZipEntry64 new_entry;
+ ZipEntry new_entry;
if (FindEntry(za, new_data, &new_entry) != 0) {
LOG(ERROR) << name << "(): no file \"" << new_data_fn->data << "\" in package";
return StringValue("");
diff --git a/updater/commands.cpp b/updater/commands.cpp
index 1a7c272..aed6336 100644
--- a/updater/commands.cpp
+++ b/updater/commands.cpp
@@ -128,6 +128,7 @@
// No stashes, only source ranges.
SourceInfo result(src_hash, src_ranges, {}, {});
+ // Sanity check the block count.
if (result.blocks() != src_blocks) {
*err =
android::base::StringPrintf("mismatching block count: %zu (%s) vs %zu", result.blocks(),
@@ -261,7 +262,7 @@
return {};
}
} else if (op == Type::ABORT) {
- // Abort takes no arguments, so there's nothing else to check.
+ // No-op, other than sanity checking the input args.
if (pos != tokens.size()) {
*err = android::base::StringPrintf("invalid number of args: %zu (expected 0)",
tokens.size() - pos);
diff --git a/updater/include/private/commands.h b/updater/include/private/commands.h
index 7a23bb7..79f9154 100644
--- a/updater/include/private/commands.h
+++ b/updater/include/private/commands.h
@@ -307,7 +307,7 @@
: type_(type),
index_(index),
cmdline_(std::move(cmdline)),
- patch_(patch),
+ patch_(std::move(patch)),
target_(std::move(target)),
source_(std::move(source)),
stash_(std::move(stash)) {}
diff --git a/updater/install.cpp b/updater/install.cpp
index 2959650..afa5195 100644
--- a/updater/install.cpp
+++ b/updater/install.cpp
@@ -35,7 +35,6 @@
#include <unistd.h>
#include <utime.h>
-#include <limits>
#include <memory>
#include <string>
#include <vector>
@@ -116,7 +115,7 @@
std::string dest_path = args[1];
ZipArchiveHandle za = state->updater->GetPackageHandle();
- ZipEntry64 entry;
+ ZipEntry entry;
if (FindEntry(za, zip_path, &entry) != 0) {
LOG(ERROR) << name << ": no " << zip_path << " in package";
return StringValue("");
@@ -166,18 +165,13 @@
const std::string& zip_path = args[0];
ZipArchiveHandle za = state->updater->GetPackageHandle();
- ZipEntry64 entry;
+ ZipEntry entry;
if (FindEntry(za, zip_path, &entry) != 0) {
return ErrorAbort(state, kPackageExtractFileFailure, "%s(): no %s in package", name,
zip_path.c_str());
}
std::string buffer;
- if (entry.uncompressed_length > std::numeric_limits<size_t>::max()) {
- return ErrorAbort(state, kPackageExtractFileFailure,
- "%s(): Entry `%s` Uncompressed size exceeds size of address space.", name,
- zip_path.c_str());
- }
buffer.resize(entry.uncompressed_length);
int32_t ret =
diff --git a/updater/target_files.cpp b/updater/target_files.cpp
index 207146f..919ec4e 100644
--- a/updater/target_files.cpp
+++ b/updater/target_files.cpp
@@ -115,7 +115,7 @@
}
CHECK(handle_);
- ZipEntry64 img_entry;
+ ZipEntry img_entry;
return FindEntry(handle_, name, &img_entry) == 0;
}
@@ -126,7 +126,7 @@
}
CHECK(handle_);
- ZipEntry64 entry;
+ ZipEntry entry;
if (auto find_err = FindEntry(handle_, name, &entry); find_err != 0) {
LOG(ERROR) << "failed to find " << name << " in the package: " << ErrorCodeString(find_err);
return false;
@@ -137,13 +137,6 @@
return true;
}
- if (entry.uncompressed_length > std::numeric_limits<size_t>::max()) {
- LOG(ERROR) << "Failed to extract " << name
- << " because's uncompressed size exceeds size of address space. "
- << entry.uncompressed_length;
- return false;
- }
-
content->resize(entry.uncompressed_length);
if (auto extract_err = ExtractToMemory(
handle_, &entry, reinterpret_cast<uint8_t*>(&content->at(0)), entry.uncompressed_length);
@@ -164,7 +157,7 @@
}
CHECK(handle_);
- ZipEntry64 entry;
+ ZipEntry entry;
if (auto find_err = FindEntry(handle_, name, &entry); find_err != 0) {
LOG(ERROR) << "failed to find " << name << " in the package: " << ErrorCodeString(find_err);
return false;
diff --git a/updater/updater.cpp b/updater/updater.cpp
index c526734..8f4a6ed 100644
--- a/updater/updater.cpp
+++ b/updater/updater.cpp
@@ -163,19 +163,14 @@
bool Updater::ReadEntryToString(ZipArchiveHandle za, const std::string& entry_name,
std::string* content) {
- ZipEntry64 entry;
+ ZipEntry entry;
int find_err = FindEntry(za, entry_name, &entry);
if (find_err != 0) {
LOG(ERROR) << "failed to find " << entry_name
<< " in the package: " << ErrorCodeString(find_err);
return false;
}
- if (entry.uncompressed_length > std::numeric_limits<size_t>::max()) {
- LOG(ERROR) << "Failed to extract " << entry_name
- << " because's uncompressed size exceeds size of address space. "
- << entry.uncompressed_length;
- return false;
- }
+
content->resize(entry.uncompressed_length);
int extract_err = ExtractToMemory(za, &entry, reinterpret_cast<uint8_t*>(&content->at(0)),
entry.uncompressed_length);
diff --git a/updater/updater_runtime.cpp b/updater/updater_runtime.cpp
index bac078c..e938305 100644
--- a/updater/updater_runtime.cpp
+++ b/updater/updater_runtime.cpp
@@ -44,25 +44,29 @@
return std::string(name);
}
-static bool setMountFlag(const std::string& flag, unsigned* mount_flags) {
- static constexpr std::pair<const char*, unsigned> mount_flags_list[] = {
- { "noatime", MS_NOATIME },
- { "noexec", MS_NOEXEC },
- { "nosuid", MS_NOSUID },
- { "nodev", MS_NODEV },
- { "nodiratime", MS_NODIRATIME },
- { "ro", MS_RDONLY },
- { "rw", 0 },
- { "remount", MS_REMOUNT },
- { "bind", MS_BIND },
- { "rec", MS_REC },
- { "unbindable", MS_UNBINDABLE },
- { "private", MS_PRIVATE },
- { "slave", MS_SLAVE },
- { "shared", MS_SHARED },
- { "defaults", 0 },
- };
+static struct {
+ const char* name;
+ unsigned flag;
+} mount_flags_list[] = {
+ { "noatime", MS_NOATIME },
+ { "noexec", MS_NOEXEC },
+ { "nosuid", MS_NOSUID },
+ { "nodev", MS_NODEV },
+ { "nodiratime", MS_NODIRATIME },
+ { "ro", MS_RDONLY },
+ { "rw", 0 },
+ { "remount", MS_REMOUNT },
+ { "bind", MS_BIND },
+ { "rec", MS_REC },
+ { "unbindable", MS_UNBINDABLE },
+ { "private", MS_PRIVATE },
+ { "slave", MS_SLAVE },
+ { "shared", MS_SHARED },
+ { "defaults", 0 },
+ { 0, 0 },
+};
+static bool setMountFlag(const std::string& flag, unsigned* mount_flags) {
for (const auto& [name, value] : mount_flags_list) {
if (flag == name) {
*mount_flags |= value;
diff --git a/updater_sample/Android.bp b/updater_sample/Android.bp
index 9222d06..a014248 100644
--- a/updater_sample/Android.bp
+++ b/updater_sample/Android.bp
@@ -12,15 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package {
- // See: http://go/android-license-faq
- // A large-scale-change added 'default_applicable_licenses' to import
- // all of the 'license_kinds' from "bootable_recovery_license"
- // to get the below license kinds:
- // SPDX-license-identifier-Apache-2.0
- default_applicable_licenses: ["bootable_recovery_license"],
-}
-
android_app {
name: "SystemUpdaterSample",
sdk_version: "system_current",
diff --git a/updater_sample/tests/Android.bp b/updater_sample/tests/Android.bp
index 4bdfe2c..806babd 100644
--- a/updater_sample/tests/Android.bp
+++ b/updater_sample/tests/Android.bp
@@ -12,15 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package {
- // See: http://go/android-license-faq
- // A large-scale-change added 'default_applicable_licenses' to import
- // all of the 'license_kinds' from "bootable_recovery_license"
- // to get the below license kinds:
- // SPDX-license-identifier-Apache-2.0
- default_applicable_licenses: ["bootable_recovery_license"],
-}
-
android_test {
name: "SystemUpdaterSampleTests",
sdk_version: "system_current",
