Merge changes Iccfe3bd4,I6380245b,I20d9f2fe
* changes:
adb: Remove most C-style allocations
adb: Modernize the service creation
adb: Preserve the original mount flags when remounting
diff --git a/.clang-format-2 b/.clang-format-2
index 41591ce..ede5d7e 100644
--- a/.clang-format-2
+++ b/.clang-format-2
@@ -7,4 +7,3 @@
PointerAlignment: Left
TabWidth: 2
UseTab: Never
-PenaltyExcessCharacter: 32
diff --git a/.clang-format-4 b/.clang-format-4
index 9127163..55773a2 100644
--- a/.clang-format-4
+++ b/.clang-format-4
@@ -9,4 +9,3 @@
PointerAlignment: Left
TabWidth: 4
UseTab: Never
-PenaltyExcessCharacter: 32
diff --git a/adb/adb.bash b/adb/adb.bash
index d36bec3..b1b3957 100644
--- a/adb/adb.bash
+++ b/adb/adb.bash
@@ -16,11 +16,11 @@
#
_adb() {
- if ! type -t "$1" >/dev/null; then
+ if ! check_type "$1" >/dev/null; then
return
fi
- if type -t _init_completion >/dev/null; then
+ if check_type _init_completion >/dev/null; then
_init_completion || return
fi
@@ -435,7 +435,7 @@
fi
# Since we're probably doing file completion here, don't add a space after.
- if [[ $(type -t compopt) = "builtin" ]]; then
+ if [[ $(check_type compopt) == "builtin" ]]; then
compopt -o nospace
fi
@@ -451,7 +451,7 @@
xspec=$2
# Since we're probably doing file completion here, don't add a space after.
- if [[ $(type -t compopt) = "builtin" ]]; then
+ if [[ $(check_type compopt) == "builtin" ]]; then
compopt -o plusdirs
if [[ "${xspec}" == "" ]]; then
COMPREPLY=( ${COMPREPLY[@]:-} $(compgen -f -- "${cur}") )
@@ -492,7 +492,7 @@
}
-if [[ $(type -t compopt) = "builtin" ]]; then
+if [[ $(check_type compopt) == "builtin" ]]; then
complete -F _adb adb
else
complete -o nospace -F _adb adb
diff --git a/base/include/android-base/unique_fd.h b/base/include/android-base/unique_fd.h
index 6cfcd3f..c733081 100644
--- a/base/include/android-base/unique_fd.h
+++ b/base/include/android-base/unique_fd.h
@@ -97,7 +97,8 @@
#if !defined(_WIN32)
// Inline functions, so that they can be used header-only.
-inline bool Pipe(unique_fd* read, unique_fd* write) {
+template <typename Closer>
+inline bool Pipe(unique_fd_impl<Closer>* read, unique_fd_impl<Closer>* write) {
int pipefd[2];
#if defined(__linux__)
@@ -121,7 +122,9 @@
return true;
}
-inline bool Socketpair(int domain, int type, int protocol, unique_fd* left, unique_fd* right) {
+template <typename Closer>
+inline bool Socketpair(int domain, int type, int protocol, unique_fd_impl<Closer>* left,
+ unique_fd_impl<Closer>* right) {
int sockfd[2];
if (socketpair(domain, type, protocol, sockfd) != 0) {
return false;
@@ -131,7 +134,8 @@
return true;
}
-inline bool Socketpair(int type, unique_fd* left, unique_fd* right) {
+template <typename Closer>
+inline bool Socketpair(int type, unique_fd_impl<Closer>* left, unique_fd_impl<Closer>* right) {
return Socketpair(AF_UNIX, type, 0, left, right);
}
diff --git a/debuggerd/crasher/crasher.cpp b/debuggerd/crasher/crasher.cpp
index f31337d..f0fe1d0 100644
--- a/debuggerd/crasher/crasher.cpp
+++ b/debuggerd/crasher/crasher.cpp
@@ -183,6 +183,8 @@
fprintf(stderr, " exit call exit(1)\n");
fprintf(stderr, "\n");
fprintf(stderr, " fortify fail a _FORTIFY_SOURCE check\n");
+ fprintf(stderr, " fdsan_file close a file descriptor that's owned by a FILE*\n");
+ fprintf(stderr, " fdsan_dir close a file descriptor that's owned by a DIR*\n");
fprintf(stderr, " seccomp fail a seccomp check\n");
#if defined(__arm__)
fprintf(stderr, " kuser_helper_version call kuser_helper_version\n");
@@ -236,39 +238,45 @@
// Actions.
if (!strcasecmp(arg, "SIGSEGV-non-null")) {
- sigsegv_non_null();
+ sigsegv_non_null();
} else if (!strcasecmp(arg, "smash-stack")) {
- volatile int len = 128;
- return smash_stack(&len);
+ volatile int len = 128;
+ return smash_stack(&len);
} else if (!strcasecmp(arg, "stack-overflow")) {
- overflow_stack(nullptr);
+ overflow_stack(nullptr);
} else if (!strcasecmp(arg, "nostack")) {
- crashnostack();
+ crashnostack();
} else if (!strcasecmp(arg, "exit")) {
- exit(1);
+ exit(1);
} else if (!strcasecmp(arg, "call-null")) {
return crash_null();
} else if (!strcasecmp(arg, "crash") || !strcmp(arg, "SIGSEGV")) {
- return crash(42);
+ return crash(42);
} else if (!strcasecmp(arg, "abort")) {
- maybe_abort();
+ maybe_abort();
} else if (!strcasecmp(arg, "assert")) {
- __assert("some_file.c", 123, "false");
+ __assert("some_file.c", 123, "false");
} else if (!strcasecmp(arg, "assert2")) {
- __assert2("some_file.c", 123, "some_function", "false");
+ __assert2("some_file.c", 123, "some_function", "false");
} else if (!strcasecmp(arg, "fortify")) {
- char buf[10];
- __read_chk(-1, buf, 32, 10);
- while (true) pause();
+ char buf[10];
+ __read_chk(-1, buf, 32, 10);
+ while (true) pause();
+ } else if (!strcasecmp(arg, "fdsan_file")) {
+ FILE* f = fopen("/dev/null", "r");
+ close(fileno(f));
+ } else if (!strcasecmp(arg, "fdsan_dir")) {
+ DIR* d = opendir("/dev/");
+ close(dirfd(d));
} else if (!strcasecmp(arg, "LOG(FATAL)")) {
- LOG(FATAL) << "hello " << 123;
+ LOG(FATAL) << "hello " << 123;
} else if (!strcasecmp(arg, "LOG_ALWAYS_FATAL")) {
- LOG_ALWAYS_FATAL("hello %s", "world");
+ LOG_ALWAYS_FATAL("hello %s", "world");
} else if (!strcasecmp(arg, "LOG_ALWAYS_FATAL_IF")) {
- LOG_ALWAYS_FATAL_IF(true, "hello %s", "world");
+ LOG_ALWAYS_FATAL_IF(true, "hello %s", "world");
} else if (!strcasecmp(arg, "SIGFPE")) {
- raise(SIGFPE);
- return EXIT_SUCCESS;
+ raise(SIGFPE);
+ return EXIT_SUCCESS;
} else if (!strcasecmp(arg, "SIGILL")) {
#if defined(__aarch64__)
__asm__ volatile(".word 0\n");
@@ -280,28 +288,28 @@
#error
#endif
} else if (!strcasecmp(arg, "SIGTRAP")) {
- raise(SIGTRAP);
- return EXIT_SUCCESS;
+ raise(SIGTRAP);
+ return EXIT_SUCCESS;
} else if (!strcasecmp(arg, "fprintf-NULL")) {
- fprintf_null();
+ fprintf_null();
} else if (!strcasecmp(arg, "readdir-NULL")) {
- readdir_null();
+ readdir_null();
} else if (!strcasecmp(arg, "strlen-NULL")) {
- return strlen_null();
+ return strlen_null();
} else if (!strcasecmp(arg, "pthread_join-NULL")) {
- return pthread_join(0, nullptr);
+ return pthread_join(0, nullptr);
} else if (!strcasecmp(arg, "heap-usage")) {
- abuse_heap();
+ abuse_heap();
} else if (!strcasecmp(arg, "leak")) {
- leak();
+ leak();
} else if (!strcasecmp(arg, "SIGSEGV-unmapped")) {
- char* map = reinterpret_cast<char*>(mmap(nullptr, sizeof(int), PROT_READ | PROT_WRITE,
- MAP_SHARED | MAP_ANONYMOUS, -1, 0));
- munmap(map, sizeof(int));
- map[0] = '8';
+ char* map = reinterpret_cast<char*>(
+ mmap(nullptr, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0));
+ munmap(map, sizeof(int));
+ map[0] = '8';
} else if (!strcasecmp(arg, "seccomp")) {
- set_system_seccomp_filter();
- syscall(99999);
+ set_system_seccomp_filter();
+ syscall(99999);
#if defined(__arm__)
} else if (!strcasecmp(arg, "kuser_helper_version")) {
return __kuser_helper_version;
diff --git a/debuggerd/handler/debuggerd_handler.cpp b/debuggerd/handler/debuggerd_handler.cpp
index c07a34a..615fb46 100644
--- a/debuggerd/handler/debuggerd_handler.cpp
+++ b/debuggerd/handler/debuggerd_handler.cpp
@@ -59,7 +59,16 @@
#include "protocol.h"
using android::base::Pipe;
-using android::base::unique_fd;
+
+// We muck with our fds in a 'thread' that doesn't share the same fd table.
+// Close fds in that thread with a raw close syscall instead of going through libc.
+struct FdsanBypassCloser {
+ static void Close(int fd) {
+ syscall(__NR_close, fd);
+ }
+};
+
+using unique_fd = android::base::unique_fd_impl<FdsanBypassCloser>;
// see man(2) prctl, specifically the section about PR_GET_NAME
#define MAX_TASK_NAME_LEN (16)
@@ -299,7 +308,8 @@
debugger_thread_info* thread_info = static_cast<debugger_thread_info*>(arg);
for (int i = 0; i < 1024; ++i) {
- close(i);
+ // Don't use close to avoid bionic's file descriptor ownership checks.
+ syscall(__NR_close, i);
}
int devnull = TEMP_FAILURE_RETRY(open("/dev/null", O_RDWR));
diff --git a/fastboot/fastboot.bash b/fastboot/fastboot.bash
index dca3b4e..cb1d354 100644
--- a/fastboot/fastboot.bash
+++ b/fastboot/fastboot.bash
@@ -16,11 +16,11 @@
#
_fastboot() {
- if ! type -t "$1" >/dev/null; then
+ if ! check_type "$1" >/dev/null; then
return
fi
- if type -t _init_completion >/dev/null; then
+ if check_type _init_completion >/dev/null; then
_init_completion || return
fi
@@ -135,7 +135,7 @@
xspec=$2
# Since we're probably doing file completion here, don't add a space after.
- if [[ $(type -t compopt) = "builtin" ]]; then
+ if [[ $(check_type compopt) == "builtin" ]]; then
compopt -o plusdirs
if [[ "${xspec}" == "" ]]; then
COMPREPLY=( ${COMPREPLY[@]:-} $(compgen -f -- "${cur}") )
@@ -175,7 +175,7 @@
fi
}
-if [[ $(type -t compopt) = "builtin" ]]; then
+if [[ $(check_type compopt) == "builtin" ]]; then
complete -F _fastboot fastboot
else
complete -o nospace -F _fastboot fastboot
diff --git a/fs_mgr/fs_mgr_dm_linear.cpp b/fs_mgr/fs_mgr_dm_linear.cpp
index 5159b4c..28e910b 100644
--- a/fs_mgr/fs_mgr_dm_linear.cpp
+++ b/fs_mgr/fs_mgr_dm_linear.cpp
@@ -50,33 +50,6 @@
using DmTargetZero = android::dm::DmTargetZero;
using DmTargetLinear = android::dm::DmTargetLinear;
-static bool CreateDmDeviceForPartition(DeviceMapper& dm, const LogicalPartition& partition) {
- DmTable table;
- for (const auto& extent : partition.extents) {
- table.AddTarget(std::make_unique<DmTargetLinear>(extent));
- }
- if (!dm.CreateDevice(partition.name, table)) {
- return false;
- }
- LINFO << "Created device-mapper device: " << partition.name;
- return true;
-}
-
-bool CreateLogicalPartitions(const LogicalPartitionTable& table) {
- DeviceMapper& dm = DeviceMapper::Instance();
- for (const auto& partition : table.partitions) {
- if (!CreateDmDeviceForPartition(dm, partition)) {
- LOG(ERROR) << "could not create dm-linear device for partition: " << partition.name;
- return false;
- }
- }
- return true;
-}
-
-std::unique_ptr<LogicalPartitionTable> LoadPartitionsFromDeviceTree() {
- return nullptr;
-}
-
static bool CreateDmTable(const std::string& block_device, const LpMetadata& metadata,
const LpMetadataPartition& partition, DmTable* table) {
uint64_t sector = 0;
diff --git a/fs_mgr/include/fs_mgr_dm_linear.h b/fs_mgr/include/fs_mgr_dm_linear.h
index 3b0c791..42af9d0 100644
--- a/fs_mgr/include/fs_mgr_dm_linear.h
+++ b/fs_mgr/include/fs_mgr_dm_linear.h
@@ -37,28 +37,6 @@
namespace android {
namespace fs_mgr {
-struct LogicalPartition {
- std::string name;
- std::vector<android::dm::DmTargetLinear> extents;
-};
-
-struct LogicalPartitionTable {
- // List of partitions in the partition table.
- std::vector<LogicalPartition> partitions;
-};
-
-// Load a dm-linear table from the device tree if one is available; otherwise,
-// return null.
-std::unique_ptr<LogicalPartitionTable> LoadPartitionsFromDeviceTree();
-
-// Create device-mapper devices for the given partition table.
-//
-// On success, two devices nodes will be created for each partition, both
-// pointing to the same device:
-// /dev/block/dm-<N> where N is a sequential ID assigned by device-mapper.
-// /dev/block/dm-<name> where |name| is the partition name.
-//
-bool CreateLogicalPartitions(const LogicalPartitionTable& table);
bool CreateLogicalPartitions(const std::string& block_device);
} // namespace fs_mgr
diff --git a/fs_mgr/liblp/images.cpp b/fs_mgr/liblp/images.cpp
index aeb339b..a361a5d 100644
--- a/fs_mgr/liblp/images.cpp
+++ b/fs_mgr/liblp/images.cpp
@@ -82,7 +82,8 @@
// to do this when the data pointers are all in one place.
class SparseBuilder {
public:
- SparseBuilder(const LpMetadata& metadata, uint32_t block_size);
+ SparseBuilder(const LpMetadata& metadata, uint32_t block_size,
+ const std::map<std::string, std::string>& images);
bool Build();
bool Export(const char* file);
@@ -90,6 +91,8 @@
private:
bool AddData(const std::string& blob, uint64_t sector);
+ bool AddPartitionImage(const LpMetadataPartition& partition, const std::string& file);
+ int OpenImageFile(const std::string& file);
bool SectorToBlock(uint64_t sector, uint32_t* block);
const LpMetadata& metadata_;
@@ -98,13 +101,17 @@
std::unique_ptr<sparse_file, decltype(&sparse_file_destroy)> file_;
std::string primary_blob_;
std::string backup_blob_;
+ std::map<std::string, std::string> images_;
+ std::vector<android::base::unique_fd> temp_fds_;
};
-SparseBuilder::SparseBuilder(const LpMetadata& metadata, uint32_t block_size)
+SparseBuilder::SparseBuilder(const LpMetadata& metadata, uint32_t block_size,
+ const std::map<std::string, std::string>& images)
: metadata_(metadata),
geometry_(metadata.geometry),
block_size_(block_size),
- file_(sparse_file_new(block_size_, geometry_.block_device_size), sparse_file_destroy) {}
+ file_(sparse_file_new(block_size_, geometry_.block_device_size), sparse_file_destroy),
+ images_(images) {}
bool SparseBuilder::Export(const char* file) {
android::base::unique_fd fd(open(file, O_CREAT | O_RDWR | O_TRUNC, 0644));
@@ -168,6 +175,22 @@
return false;
}
+ for (const auto& partition : metadata_.partitions) {
+ auto iter = images_.find(GetPartitionName(partition));
+ if (iter == images_.end()) {
+ continue;
+ }
+ if (!AddPartitionImage(partition, iter->second)) {
+ return false;
+ }
+ images_.erase(iter);
+ }
+
+ if (!images_.empty()) {
+ LERROR << "Partition image was specified but no partition was found.";
+ return false;
+ }
+
// The backup area contains all metadata slots, and then geometry. Similar
// to before we write the metadata to every slot.
int64_t backup_offset = GetBackupMetadataOffset(geometry_, 0);
@@ -181,7 +204,126 @@
return true;
}
-bool WriteToSparseFile(const char* file, const LpMetadata& metadata, uint32_t block_size) {
+static inline bool HasFillValue(uint32_t* buffer, size_t count) {
+ uint32_t fill_value = buffer[0];
+ for (size_t i = 1; i < count; i++) {
+ if (fill_value != buffer[i]) {
+ return false;
+ }
+ }
+ return true;
+}
+
+bool SparseBuilder::AddPartitionImage(const LpMetadataPartition& partition,
+ const std::string& file) {
+ if (partition.num_extents != 1) {
+ LERROR << "Partition for new tables should not have more than one extent: "
+ << GetPartitionName(partition);
+ return false;
+ }
+
+ const LpMetadataExtent& extent = metadata_.extents[partition.first_extent_index];
+ if (extent.target_type != LP_TARGET_TYPE_LINEAR) {
+ LERROR << "Partition should only have linear extents: " << GetPartitionName(partition);
+ return false;
+ }
+
+ int fd = OpenImageFile(file);
+ if (fd < 0) {
+ LERROR << "Could not open image for partition: " << GetPartitionName(partition);
+ return false;
+ }
+
+ // Make sure the image does not exceed the partition size.
+ uint64_t file_length;
+ if (!GetDescriptorSize(fd, &file_length)) {
+ LERROR << "Could not compute image size";
+ return false;
+ }
+ if (file_length > extent.num_sectors * LP_SECTOR_SIZE) {
+ LERROR << "Image for partition '" << GetPartitionName(partition)
+ << "' is greater than its size";
+ return false;
+ }
+ if (SeekFile64(fd, 0, SEEK_SET)) {
+ PERROR << "lseek failed";
+ return false;
+ }
+
+ uint32_t output_block;
+ if (!SectorToBlock(extent.target_data, &output_block)) {
+ return false;
+ }
+
+ uint64_t pos = 0;
+ uint64_t remaining = file_length;
+ while (remaining) {
+ uint32_t buffer[block_size_ / sizeof(uint32_t)];
+ size_t read_size = remaining >= sizeof(buffer) ? sizeof(buffer) : size_t(remaining);
+ if (!android::base::ReadFully(fd, buffer, sizeof(buffer))) {
+ PERROR << "read failed";
+ return false;
+ }
+ if (read_size != sizeof(buffer) || !HasFillValue(buffer, read_size / sizeof(uint32_t))) {
+ int rv = sparse_file_add_fd(file_.get(), fd, pos, read_size, output_block);
+ if (rv) {
+ LERROR << "sparse_file_add_fd failed with code: " << rv;
+ return false;
+ }
+ } else {
+ int rv = sparse_file_add_fill(file_.get(), buffer[0], read_size, output_block);
+ if (rv) {
+ LERROR << "sparse_file_add_fill failed with code: " << rv;
+ return false;
+ }
+ }
+ pos += read_size;
+ remaining -= read_size;
+ output_block++;
+ }
+
+ return true;
+}
+
+int SparseBuilder::OpenImageFile(const std::string& file) {
+ android::base::unique_fd source_fd(open(file.c_str(), O_RDONLY));
+ if (source_fd < 0) {
+ PERROR << "open image file failed: " << file;
+ return -1;
+ }
+
+ std::unique_ptr<sparse_file, decltype(&sparse_file_destroy)> source(
+ sparse_file_import(source_fd, true, true), sparse_file_destroy);
+ if (!source) {
+ int fd = source_fd.get();
+ temp_fds_.push_back(std::move(source_fd));
+ return fd;
+ }
+
+ char temp_file[PATH_MAX];
+ snprintf(temp_file, sizeof(temp_file), "%s/imageXXXXXX", P_tmpdir);
+ android::base::unique_fd temp_fd(mkstemp(temp_file));
+ if (temp_fd < 0) {
+ PERROR << "mkstemp failed";
+ return -1;
+ }
+ if (unlink(temp_file) < 0) {
+ PERROR << "unlink failed";
+ return -1;
+ }
+
+ // We temporarily unsparse the file, rather than try to merge its chunks.
+ int rv = sparse_file_write(source.get(), temp_fd, false, false, false);
+ if (rv) {
+ LERROR << "sparse_file_write failed with code: " << rv;
+ return -1;
+ }
+ temp_fds_.push_back(std::move(temp_fd));
+ return temp_fds_.back().get();
+}
+
+bool WriteToSparseFile(const char* file, const LpMetadata& metadata, uint32_t block_size,
+ const std::map<std::string, std::string>& images) {
if (block_size % LP_SECTOR_SIZE != 0) {
LERROR << "Block size must be a multiple of the sector size, " << LP_SECTOR_SIZE;
return false;
@@ -198,7 +340,7 @@
return false;
}
- SparseBuilder builder(metadata, block_size);
+ SparseBuilder builder(metadata, block_size, images);
if (!builder.IsValid()) {
LERROR << "Could not allocate sparse file of size " << metadata.geometry.block_device_size;
return false;
@@ -206,7 +348,6 @@
if (!builder.Build()) {
return false;
}
-
return builder.Export(file);
}
diff --git a/fs_mgr/liblp/include/liblp/liblp.h b/fs_mgr/liblp/include/liblp/liblp.h
index a9f01c6..627aa8c 100644
--- a/fs_mgr/liblp/include/liblp/liblp.h
+++ b/fs_mgr/liblp/include/liblp/liblp.h
@@ -20,6 +20,7 @@
#include <stddef.h>
#include <stdint.h>
+#include <map>
#include <memory>
#include <string>
@@ -59,7 +60,8 @@
// Read/Write logical partition metadata to an image file, for diagnostics or
// flashing.
-bool WriteToSparseFile(const char* file, const LpMetadata& metadata, uint32_t block_size);
+bool WriteToSparseFile(const char* file, const LpMetadata& metadata, uint32_t block_size,
+ const std::map<std::string, std::string>& images);
bool WriteToImageFile(const char* file, const LpMetadata& metadata);
std::unique_ptr<LpMetadata> ReadFromImageFile(const char* file);
diff --git a/init/init_first_stage.cpp b/init/init_first_stage.cpp
index 2bc9f3a..0ee0203 100644
--- a/init/init_first_stage.cpp
+++ b/init/init_first_stage.cpp
@@ -40,7 +40,6 @@
#include "util.h"
using android::base::Timer;
-using android::fs_mgr::LogicalPartitionTable;
namespace android {
namespace init {
@@ -75,7 +74,6 @@
bool need_dm_verity_;
std::unique_ptr<fstab, decltype(&fs_mgr_free_fstab)> device_tree_fstab_;
- std::unique_ptr<LogicalPartitionTable> dm_linear_table_;
std::string lp_metadata_partition_;
std::vector<fstab_rec*> mount_fstab_recs_;
std::set<std::string> required_devices_partition_names_;
@@ -150,10 +148,6 @@
LOG(INFO) << "Failed to read fstab from device tree";
}
- if (IsDmLinearEnabled()) {
- dm_linear_table_ = android::fs_mgr::LoadPartitionsFromDeviceTree();
- }
-
auto boot_devices = fs_mgr_get_boot_devices();
device_handler_ =
std::make_unique<DeviceHandler>(std::vector<Permissions>{}, std::vector<SysfsPermissions>{},
@@ -195,15 +189,6 @@
}
required_devices_partition_names_.emplace(LP_METADATA_PARTITION_NAME);
-
- if (dm_linear_table_) {
- for (const auto& partition : dm_linear_table_->partitions) {
- for (const auto& extent : partition.extents) {
- const std::string& partition_name = android::base::Basename(extent.block_device());
- required_devices_partition_names_.emplace(partition_name);
- }
- }
- }
return true;
}
@@ -272,11 +257,6 @@
<< LP_METADATA_PARTITION_NAME;
return false;
}
- if (dm_linear_table_) {
- if (!android::fs_mgr::CreateLogicalPartitions(*dm_linear_table_.get())) {
- return false;
- }
- }
return android::fs_mgr::CreateLogicalPartitions(lp_metadata_partition_);
}
@@ -456,12 +436,19 @@
bool FirstStageMountVBootV2::GetDmVerityDevices() {
need_dm_verity_ = false;
+ std::set<std::string> logical_partitions;
+
// fstab_rec->blk_device has A/B suffix.
for (auto fstab_rec : mount_fstab_recs_) {
if (fs_mgr_is_avb(fstab_rec)) {
need_dm_verity_ = true;
}
- required_devices_partition_names_.emplace(basename(fstab_rec->blk_device));
+ if (fs_mgr_is_logical(fstab_rec)) {
+ // Don't try to find logical partitions via uevent regeneration.
+ logical_partitions.emplace(basename(fstab_rec->blk_device));
+ } else {
+ required_devices_partition_names_.emplace(basename(fstab_rec->blk_device));
+ }
}
// libavb verifies AVB metadata on all verified partitions at once.
@@ -476,11 +463,15 @@
std::vector<std::string> partitions = android::base::Split(device_tree_vbmeta_parts_, ",");
std::string ab_suffix = fs_mgr_get_slot_suffix();
for (const auto& partition : partitions) {
+ std::string partition_name = partition + ab_suffix;
+ if (logical_partitions.count(partition_name)) {
+ continue;
+ }
// required_devices_partition_names_ is of type std::set so it's not an issue
// to emplace a partition twice. e.g., /vendor might be in both places:
// - device_tree_vbmeta_parts_ = "vbmeta,boot,system,vendor"
// - mount_fstab_recs_: /vendor_a
- required_devices_partition_names_.emplace(partition + ab_suffix);
+ required_devices_partition_names_.emplace(partition_name);
}
}
return true;
diff --git a/init/ueventd.cpp b/init/ueventd.cpp
index 6809445..b42a4c6 100644
--- a/init/ueventd.cpp
+++ b/init/ueventd.cpp
@@ -240,7 +240,8 @@
auto hardware = android::base::GetProperty("ro.hardware", "");
auto ueventd_configuration =
- ParseConfig({"/ueventd.rc", "/vendor/ueventd.rc", "/odm/ueventd.rc", hardware});
+ ParseConfig({"/ueventd.rc", "/vendor/ueventd.rc", "/odm/ueventd.rc",
+ "/ueventd." + hardware + ".rc"});
device_handler = DeviceHandler{std::move(ueventd_configuration.dev_permissions),
std::move(ueventd_configuration.sysfs_permissions),
diff --git a/liblog/include/log/log_main.h b/liblog/include/log/log_main.h
index 21fc7cc..f1ff31a 100644
--- a/liblog/include/log/log_main.h
+++ b/liblog/include/log/log_main.h
@@ -40,6 +40,17 @@
#endif
#endif
+/*
+ * Use __VA_ARGS__ if running a static analyzer,
+ * to avoid warnings of unused variables in __VA_ARGS__.
+ */
+
+#ifdef __clang_analyzer__
+#define __FAKE_USE_VA_ARGS(...) ((void)(__VA_ARGS__))
+#else
+#define __FAKE_USE_VA_ARGS(...) ((void)(0))
+#endif
+
/* --------------------------------------------------------------------- */
/*
@@ -112,7 +123,7 @@
#define LOG_ALWAYS_FATAL_IF(cond, ...) \
((__predict_false(cond)) \
? ((void)android_printAssert(#cond, LOG_TAG, ##__VA_ARGS__)) \
- : (void)0)
+ : __FAKE_USE_VA_ARGS(__VA_ARGS__))
#endif
#ifndef LOG_ALWAYS_FATAL
@@ -128,10 +139,10 @@
#if LOG_NDEBUG
#ifndef LOG_FATAL_IF
-#define LOG_FATAL_IF(cond, ...) ((void)0)
+#define LOG_FATAL_IF(cond, ...) __FAKE_USE_VA_ARGS(__VA_ARGS__)
#endif
#ifndef LOG_FATAL
-#define LOG_FATAL(...) ((void)0)
+#define LOG_FATAL(...) __FAKE_USE_VA_ARGS(__VA_ARGS__)
#endif
#else
@@ -175,11 +186,12 @@
#ifndef ALOGV
#define __ALOGV(...) ((void)ALOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__))
#if LOG_NDEBUG
-#define ALOGV(...) \
- do { \
- if (false) { \
- __ALOGV(__VA_ARGS__); \
- } \
+#define ALOGV(...) \
+ do { \
+ __FAKE_USE_VA_ARGS(__VA_ARGS__); \
+ if (false) { \
+ __ALOGV(__VA_ARGS__); \
+ } \
} while (false)
#else
#define ALOGV(...) __ALOGV(__VA_ARGS__)
@@ -188,11 +200,11 @@
#ifndef ALOGV_IF
#if LOG_NDEBUG
-#define ALOGV_IF(cond, ...) ((void)0)
+#define ALOGV_IF(cond, ...) __FAKE_USE_VA_ARGS(__VA_ARGS__)
#else
#define ALOGV_IF(cond, ...) \
((__predict_false(cond)) ? ((void)ALOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__)) \
- : (void)0)
+ : __FAKE_USE_VA_ARGS(__VA_ARGS__))
#endif
#endif
@@ -206,7 +218,7 @@
#ifndef ALOGD_IF
#define ALOGD_IF(cond, ...) \
((__predict_false(cond)) ? ((void)ALOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__)) \
- : (void)0)
+ : __FAKE_USE_VA_ARGS(__VA_ARGS__))
#endif
/*
@@ -219,7 +231,7 @@
#ifndef ALOGI_IF
#define ALOGI_IF(cond, ...) \
((__predict_false(cond)) ? ((void)ALOG(LOG_INFO, LOG_TAG, __VA_ARGS__)) \
- : (void)0)
+ : __FAKE_USE_VA_ARGS(__VA_ARGS__))
#endif
/*
@@ -232,7 +244,7 @@
#ifndef ALOGW_IF
#define ALOGW_IF(cond, ...) \
((__predict_false(cond)) ? ((void)ALOG(LOG_WARN, LOG_TAG, __VA_ARGS__)) \
- : (void)0)
+ : __FAKE_USE_VA_ARGS(__VA_ARGS__))
#endif
/*
@@ -245,7 +257,7 @@
#ifndef ALOGE_IF
#define ALOGE_IF(cond, ...) \
((__predict_false(cond)) ? ((void)ALOG(LOG_ERROR, LOG_TAG, __VA_ARGS__)) \
- : (void)0)
+ : __FAKE_USE_VA_ARGS(__VA_ARGS__))
#endif
/* --------------------------------------------------------------------- */