Merge changes from topics "crashapi2", "crashapi3" into main
* changes:
use new location of crash_detail API
Add tests for android_replace_crash_detail_[name|data]
diff --git a/debuggerd/client/debuggerd_client.cpp b/debuggerd/client/debuggerd_client.cpp
index bd1e91d..af1bb81 100644
--- a/debuggerd/client/debuggerd_client.cpp
+++ b/debuggerd/client/debuggerd_client.cpp
@@ -116,7 +116,6 @@
bool debuggerd_trigger_dump(pid_t tid, DebuggerdDumpType dump_type, unsigned int timeout_ms,
unique_fd output_fd) {
- pid_t pid = tid;
if (dump_type == kDebuggerdJavaBacktrace) {
// Java dumps always get sent to the tgid, so we need to resolve our tid to a tgid.
android::procinfo::ProcessInfo procinfo;
@@ -125,10 +124,10 @@
log_error(output_fd, 0, "failed to get process info: %s", error.c_str());
return false;
}
- pid = procinfo.pid;
+ tid = procinfo.pid;
}
- LOG(INFO) << TAG "started dumping process " << pid;
+ LOG(INFO) << TAG "started dumping process " << tid;
// Rather than try to deal with poll() all the way through the flow, we update
// the socket timeout between each step (and only use poll() during the final
@@ -172,7 +171,7 @@
InterceptRequest req = {
.dump_type = dump_type,
- .pid = pid,
+ .pid = tid,
};
// Create an intermediate pipe to pass to the other end.
@@ -235,8 +234,8 @@
// Send the signal.
const int signal = (dump_type == kDebuggerdJavaBacktrace) ? SIGQUIT : BIONIC_SIGNAL_DEBUGGER;
sigval val = {.sival_int = (dump_type == kDebuggerdNativeBacktrace) ? 1 : 0};
- if (sigqueue(pid, signal, val) != 0) {
- log_error(output_fd, errno, "failed to send signal to pid %d", pid);
+ if (sigqueue(tid, signal, val) != 0) {
+ log_error(output_fd, errno, "failed to send signal to pid %d", tid);
return false;
}
@@ -299,7 +298,7 @@
}
}
- LOG(INFO) << TAG "done dumping process " << pid;
+ LOG(INFO) << TAG "done dumping process " << tid;
return true;
}
diff --git a/debuggerd/include/debuggerd/client.h b/debuggerd/include/debuggerd/client.h
index b7284b0..e7401cc 100644
--- a/debuggerd/include/debuggerd/client.h
+++ b/debuggerd/include/debuggerd/client.h
@@ -26,7 +26,7 @@
// Trigger a dump of specified process to output_fd.
// output_fd is consumed, timeout of 0 will wait forever.
-bool debuggerd_trigger_dump(pid_t pid, enum DebuggerdDumpType dump_type, unsigned int timeout_ms,
+bool debuggerd_trigger_dump(pid_t tid, enum DebuggerdDumpType dump_type, unsigned int timeout_ms,
android::base::unique_fd output_fd);
int dump_backtrace_to_file(pid_t tid, enum DebuggerdDumpType dump_type, int output_fd);
diff --git a/debuggerd/libdebuggerd/tombstone_proto.cpp b/debuggerd/libdebuggerd/tombstone_proto.cpp
index 4fe4403..74f9a8c 100644
--- a/debuggerd/libdebuggerd/tombstone_proto.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto.cpp
@@ -96,6 +96,11 @@
static std::optional<std::string> get_stack_overflow_cause(uint64_t fault_addr, uint64_t sp,
unwindstack::Maps* maps) {
+ // Under stack MTE the stack pointer and/or the fault address can be tagged.
+ // In order to calculate deltas between them, strip off the tags off both
+ // addresses.
+ fault_addr = untag_address(fault_addr);
+ sp = untag_address(sp);
static constexpr uint64_t kMaxDifferenceBytes = 256;
uint64_t difference;
if (sp >= fault_addr) {
diff --git a/debuggerd/seccomp_policy/crash_dump.arm64.policy b/debuggerd/seccomp_policy/crash_dump.arm64.policy
index adf8738..c5d10d6 100644
--- a/debuggerd/seccomp_policy/crash_dump.arm64.policy
+++ b/debuggerd/seccomp_policy/crash_dump.arm64.policy
@@ -28,11 +28,11 @@
rt_tgsigqueueinfo: 1
prctl: arg0 == PR_GET_NO_NEW_PRIVS || arg0 == 0x53564d41 || arg0 == PR_PAC_RESET_KEYS || arg0 == 56 || arg0 == 61
madvise: 1
-mprotect: arg2 in 0x1|0x2
+mprotect: arg2 in 0x1|0x2|0x20
munmap: 1
getuid: 1
fstat: 1
-mmap: arg2 in 0x1|0x2
+mmap: arg2 in 0x1|0x2|0x20
geteuid: 1
getgid: 1
getegid: 1
diff --git a/fastboot/usb_linux.cpp b/fastboot/usb_linux.cpp
index 72e326a..03af8f7 100644
--- a/fastboot/usb_linux.cpp
+++ b/fastboot/usb_linux.cpp
@@ -83,7 +83,18 @@
// be reliable.
// 256KiB seems to work, but 1MiB bulk transfers lock up my z620 with a 3.13
// kernel.
-#define MAX_USBFS_BULK_SIZE (16 * 1024)
+// 128KiB was experimentally found to be enough to saturate the bus at
+// SuperSpeed+, so we first try double that for writes. If the operation fails
+// due to a lack of contiguous regions (or an ancient kernel), try smaller sizes
+// until we find one that works (see LinuxUsbTransport::Write). Reads are less
+// performance critical so for now just use a known good size.
+#define MAX_USBFS_BULK_WRITE_SIZE (256 * 1024)
+#define MAX_USBFS_BULK_READ_SIZE (16 * 1024)
+
+// This size should pretty much always work (it's compatible with pre-3.3
+// kernels and it's what we used to use historically), so if it doesn't work
+// something has gone badly wrong.
+#define MIN_USBFS_BULK_WRITE_SIZE (16 * 1024)
struct usb_handle
{
@@ -108,6 +119,7 @@
private:
std::unique_ptr<usb_handle> handle_;
const uint32_t ms_timeout_;
+ size_t max_usbfs_bulk_write_size_ = MAX_USBFS_BULK_WRITE_SIZE;
DISALLOW_COPY_AND_ASSIGN(LinuxUsbTransport);
};
@@ -415,26 +427,32 @@
}
auto submit_urb = [&](size_t i) {
- int xfer = (len > MAX_USBFS_BULK_SIZE) ? MAX_USBFS_BULK_SIZE : len;
+ while (true) {
+ int xfer = (len > max_usbfs_bulk_write_size_) ? max_usbfs_bulk_write_size_ : len;
- urb[i].type = USBDEVFS_URB_TYPE_BULK;
- urb[i].endpoint = handle_->ep_out;
- urb[i].buffer_length = xfer;
- urb[i].buffer = data;
- urb[i].usercontext = (void *)i;
+ urb[i].type = USBDEVFS_URB_TYPE_BULK;
+ urb[i].endpoint = handle_->ep_out;
+ urb[i].buffer_length = xfer;
+ urb[i].buffer = data;
+ urb[i].usercontext = (void *)i;
- int n = ioctl(handle_->desc, USBDEVFS_SUBMITURB, &urb[i]);
- if (n != 0) {
- DBG("ioctl(USBDEVFS_SUBMITURB) failed\n");
- return false;
+ int n = ioctl(handle_->desc, USBDEVFS_SUBMITURB, &urb[i]);
+ if (n != 0) {
+ if (errno == ENOMEM && max_usbfs_bulk_write_size_ > MIN_USBFS_BULK_WRITE_SIZE) {
+ max_usbfs_bulk_write_size_ /= 2;
+ continue;
+ }
+ DBG("ioctl(USBDEVFS_SUBMITURB) failed\n");
+ return false;
+ }
+
+ pending[i] = true;
+ count += xfer;
+ len -= xfer;
+ data += xfer;
+
+ return true;
}
-
- pending[i] = true;
- count += xfer;
- len -= xfer;
- data += xfer;
-
- return true;
};
auto reap_urb = [&](size_t i) {
@@ -500,7 +518,7 @@
}
while (len > 0) {
- int xfer = (len > MAX_USBFS_BULK_SIZE) ? MAX_USBFS_BULK_SIZE : len;
+ int xfer = (len > MAX_USBFS_BULK_READ_SIZE) ? MAX_USBFS_BULK_READ_SIZE : len;
bulk.ep = handle_->ep_in;
bulk.len = xfer;
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
index 8191d61..ac04245 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
@@ -17,6 +17,7 @@
#pragma once
#include <memory>
+#include <vector>
#include "libsnapshot/cow_format.h"
namespace android {
@@ -40,8 +41,7 @@
uint32_t GetCompressionLevel() const { return compression_level_; }
uint32_t GetBlockSize() const { return block_size_; }
- [[nodiscard]] virtual std::basic_string<uint8_t> Compress(const void* data,
- size_t length) const = 0;
+ [[nodiscard]] virtual std::vector<uint8_t> Compress(const void* data, size_t length) const = 0;
private:
uint32_t compression_level_;
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
index 89699dc..651083f 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
@@ -122,13 +122,13 @@
CompressWorker(std::unique_ptr<ICompressor>&& compressor);
bool RunThread();
void EnqueueCompressBlocks(const void* buffer, size_t block_size, size_t num_blocks);
- bool GetCompressedBuffers(std::vector<std::basic_string<uint8_t>>* compressed_buf);
+ bool GetCompressedBuffers(std::vector<std::vector<uint8_t>>* compressed_buf);
void Finalize();
static uint32_t GetDefaultCompressionLevel(CowCompressionAlgorithm compression);
static bool CompressBlocks(ICompressor* compressor, size_t block_size, const void* buffer,
size_t num_blocks,
- std::vector<std::basic_string<uint8_t>>* compressed_data);
+ std::vector<std::vector<uint8_t>>* compressed_data);
private:
struct CompressWork {
@@ -136,7 +136,7 @@
size_t num_blocks;
size_t block_size;
bool compression_status = false;
- std::vector<std::basic_string<uint8_t>> compressed_data;
+ std::vector<std::vector<uint8_t>> compressed_data;
};
std::unique_ptr<ICompressor> compressor_;
@@ -150,7 +150,7 @@
size_t total_processed_ = 0;
bool CompressBlocks(const void* buffer, size_t num_blocks, size_t block_size,
- std::vector<std::basic_string<uint8_t>>* compressed_data);
+ std::vector<std::vector<uint8_t>>* compressed_data);
};
// Create an ICowWriter not backed by any file. This is useful for estimating
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
index 577cdbd..0205f50 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
@@ -20,6 +20,7 @@
#include <limits>
#include <memory>
#include <queue>
+#include <vector>
#include <android-base/file.h>
#include <android-base/logging.h>
@@ -103,9 +104,9 @@
GzCompressor(uint32_t compression_level, const uint32_t block_size)
: ICompressor(compression_level, block_size){};
- std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {
+ std::vector<uint8_t> Compress(const void* data, size_t length) const override {
const auto bound = compressBound(length);
- std::basic_string<uint8_t> buffer(bound, '\0');
+ std::vector<uint8_t> buffer(bound, '\0');
uLongf dest_len = bound;
auto rv = compress2(buffer.data(), &dest_len, reinterpret_cast<const Bytef*>(data), length,
@@ -124,13 +125,13 @@
Lz4Compressor(uint32_t compression_level, const uint32_t block_size)
: ICompressor(compression_level, block_size){};
- std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {
+ std::vector<uint8_t> Compress(const void* data, size_t length) const override {
const auto bound = LZ4_compressBound(length);
if (!bound) {
LOG(ERROR) << "LZ4_compressBound returned 0";
return {};
}
- std::basic_string<uint8_t> buffer(bound, '\0');
+ std::vector<uint8_t> buffer(bound, '\0');
const auto compressed_size =
LZ4_compress_default(static_cast<const char*>(data),
@@ -156,13 +157,13 @@
BrotliCompressor(uint32_t compression_level, const uint32_t block_size)
: ICompressor(compression_level, block_size){};
- std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {
+ std::vector<uint8_t> Compress(const void* data, size_t length) const override {
const auto bound = BrotliEncoderMaxCompressedSize(length);
if (!bound) {
LOG(ERROR) << "BrotliEncoderMaxCompressedSize returned 0";
return {};
}
- std::basic_string<uint8_t> buffer(bound, '\0');
+ std::vector<uint8_t> buffer(bound, '\0');
size_t encoded_size = bound;
auto rv = BrotliEncoderCompress(
@@ -186,8 +187,8 @@
ZSTD_CCtx_setParameter(zstd_context_.get(), ZSTD_c_windowLog, log2(GetBlockSize()));
};
- std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {
- std::basic_string<uint8_t> buffer(ZSTD_compressBound(length), '\0');
+ std::vector<uint8_t> Compress(const void* data, size_t length) const override {
+ std::vector<uint8_t> buffer(ZSTD_compressBound(length), '\0');
const auto compressed_size =
ZSTD_compress2(zstd_context_.get(), buffer.data(), buffer.size(), data, length);
if (compressed_size <= 0) {
@@ -209,13 +210,13 @@
};
bool CompressWorker::CompressBlocks(const void* buffer, size_t num_blocks, size_t block_size,
- std::vector<std::basic_string<uint8_t>>* compressed_data) {
+ std::vector<std::vector<uint8_t>>* compressed_data) {
return CompressBlocks(compressor_.get(), block_size, buffer, num_blocks, compressed_data);
}
bool CompressWorker::CompressBlocks(ICompressor* compressor, size_t block_size, const void* buffer,
size_t num_blocks,
- std::vector<std::basic_string<uint8_t>>* compressed_data) {
+ std::vector<std::vector<uint8_t>>* compressed_data) {
const uint8_t* iter = reinterpret_cast<const uint8_t*>(buffer);
while (num_blocks) {
auto data = compressor->Compress(iter, block_size);
@@ -289,7 +290,7 @@
cv_.notify_all();
}
-bool CompressWorker::GetCompressedBuffers(std::vector<std::basic_string<uint8_t>>* compressed_buf) {
+bool CompressWorker::GetCompressedBuffers(std::vector<std::vector<uint8_t>>* compressed_buf) {
while (true) {
std::unique_lock<std::mutex> lock(lock_);
while ((total_submitted_ != total_processed_) && compressed_queue_.empty() && !stopped_) {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
index efb1035..5497b72 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
@@ -71,6 +71,8 @@
const int kNumThreads = 6;
const size_t kBlockSizeToRead = 1_MiB;
+ const size_t compression_factor_ = 64_KiB;
+ size_t replace_ops_ = 0, copy_ops_ = 0, zero_ops_ = 0, in_place_ops_ = 0;
std::unordered_map<std::string, int> source_block_hash_;
std::mutex source_block_hash_lock_;
@@ -81,7 +83,12 @@
std::unique_ptr<uint8_t[]> zblock_;
std::string compression_ = "lz4";
- unique_fd fd_;
+ unique_fd cow_fd_;
+ unique_fd target_fd_;
+
+ std::vector<uint64_t> zero_blocks_;
+ std::vector<uint64_t> replace_blocks_;
+ std::unordered_map<uint64_t, uint64_t> copy_blocks_;
const int BLOCK_SZ = 4_KiB;
void SHA256(const void* data, size_t length, uint8_t out[32]);
@@ -93,7 +100,14 @@
bool FindSourceBlockHash();
bool PrepareParse(std::string& parsing_file, const bool createSnapshot);
bool ParsePartition();
- bool WriteSnapshot(const void* buffer, uint64_t block, std::string& block_hash);
+ void PrepareMergeBlock(const void* buffer, uint64_t block, std::string& block_hash);
+ bool WriteV3Snapshots();
+ size_t PrepareWrite(size_t* pending_ops, size_t start_index);
+
+ bool CreateSnapshotWriter();
+ bool WriteOrderedSnapshots();
+ bool WriteNonOrderedSnapshots();
+ bool VerifyMergeOrder();
};
void CreateSnapshotLogger(android::base::LogId, android::base::LogSeverity severity, const char*,
@@ -118,21 +132,19 @@
create_snapshot_patch_ = createSnapshot;
if (createSnapshot) {
- fd_.reset(open(patch_file_.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0666));
- if (fd_ < 0) {
+ cow_fd_.reset(open(patch_file_.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0666));
+ if (cow_fd_ < 0) {
PLOG(ERROR) << "Failed to open the snapshot-patch file: " << patch_file_;
return false;
}
+ target_fd_.reset((open(parsing_file_.c_str(), O_RDONLY)));
+ if (target_fd_ < 0) {
+ LOG(ERROR) << "open failed: " << parsing_file_;
+ return false;
+ }
zblock_ = std::make_unique<uint8_t[]>(BLOCK_SZ);
std::memset(zblock_.get(), 0, BLOCK_SZ);
-
- CowOptions options;
- options.compression = compression_;
- options.num_compress_threads = 2;
- options.batch_write = true;
- options.cluster_ops = 600;
- writer_ = CreateCowWriter(2, options, std::move(fd_));
}
return true;
}
@@ -187,19 +199,158 @@
return out;
}
-bool CreateSnapshot::WriteSnapshot(const void* buffer, uint64_t block, std::string& block_hash) {
+void CreateSnapshot::PrepareMergeBlock(const void* buffer, uint64_t block,
+ std::string& block_hash) {
if (std::memcmp(zblock_.get(), buffer, BLOCK_SZ) == 0) {
std::lock_guard<std::mutex> lock(write_lock_);
- return writer_->AddZeroBlocks(block, 1);
+ zero_blocks_.push_back(block);
+ return;
}
auto iter = source_block_hash_.find(block_hash);
if (iter != source_block_hash_.end()) {
std::lock_guard<std::mutex> lock(write_lock_);
- return writer_->AddCopy(block, iter->second, 1);
+ // In-place copy is skipped
+ if (block != iter->second) {
+ copy_blocks_[block] = iter->second;
+ } else {
+ in_place_ops_ += 1;
+ }
+ return;
}
std::lock_guard<std::mutex> lock(write_lock_);
- return writer_->AddRawBlocks(block, buffer, BLOCK_SZ);
+ replace_blocks_.push_back(block);
+}
+
+size_t CreateSnapshot::PrepareWrite(size_t* pending_ops, size_t start_index) {
+ size_t num_ops = *pending_ops;
+ uint64_t start_block = replace_blocks_[start_index];
+ size_t nr_consecutive = 1;
+ num_ops -= 1;
+ while (num_ops) {
+ uint64_t next_block = replace_blocks_[start_index + nr_consecutive];
+ if (next_block != start_block + nr_consecutive) {
+ break;
+ }
+ nr_consecutive += 1;
+ num_ops -= 1;
+ }
+ return nr_consecutive;
+}
+
+bool CreateSnapshot::CreateSnapshotWriter() {
+ uint64_t dev_sz = lseek(target_fd_.get(), 0, SEEK_END);
+ CowOptions options;
+ options.compression = compression_;
+ options.num_compress_threads = 2;
+ options.batch_write = true;
+ options.cluster_ops = 600;
+ options.compression_factor = compression_factor_;
+ options.max_blocks = {dev_sz / options.block_size};
+ writer_ = CreateCowWriter(3, options, std::move(cow_fd_));
+ return true;
+}
+
+bool CreateSnapshot::WriteNonOrderedSnapshots() {
+ zero_ops_ = zero_blocks_.size();
+ for (auto it = zero_blocks_.begin(); it != zero_blocks_.end(); it++) {
+ if (!writer_->AddZeroBlocks(*it, 1)) {
+ return false;
+ }
+ }
+ std::string buffer(compression_factor_, '\0');
+
+ replace_ops_ = replace_blocks_.size();
+ size_t blocks_to_compress = replace_blocks_.size();
+ size_t num_ops = 0;
+ size_t block_index = 0;
+ while (blocks_to_compress) {
+ num_ops = std::min((compression_factor_ / BLOCK_SZ), blocks_to_compress);
+ auto linear_blocks = PrepareWrite(&num_ops, block_index);
+ if (!android::base::ReadFullyAtOffset(target_fd_.get(), buffer.data(),
+ (linear_blocks * BLOCK_SZ),
+ replace_blocks_[block_index] * BLOCK_SZ)) {
+ LOG(ERROR) << "Failed to read at offset: " << replace_blocks_[block_index] * BLOCK_SZ
+ << " size: " << linear_blocks * BLOCK_SZ;
+ return false;
+ }
+ if (!writer_->AddRawBlocks(replace_blocks_[block_index], buffer.data(),
+ linear_blocks * BLOCK_SZ)) {
+ LOG(ERROR) << "AddRawBlocks failed";
+ return false;
+ }
+
+ block_index += linear_blocks;
+ blocks_to_compress -= linear_blocks;
+ }
+ if (!writer_->Finalize()) {
+ return false;
+ }
+ return true;
+}
+
+bool CreateSnapshot::WriteOrderedSnapshots() {
+ std::unordered_map<uint64_t, uint64_t> overwritten_blocks;
+ std::vector<std::pair<uint64_t, uint64_t>> merge_sequence;
+ for (auto it = copy_blocks_.begin(); it != copy_blocks_.end(); it++) {
+ if (overwritten_blocks.count(it->second)) {
+ replace_blocks_.push_back(it->first);
+ continue;
+ }
+ overwritten_blocks[it->first] = it->second;
+ merge_sequence.emplace_back(std::make_pair(it->first, it->second));
+ }
+ // Sort the blocks so that if the blocks are contiguous, it would help
+ // compress multiple blocks in one shot based on the compression factor.
+ std::sort(replace_blocks_.begin(), replace_blocks_.end());
+
+ copy_ops_ = merge_sequence.size();
+ for (auto it = merge_sequence.begin(); it != merge_sequence.end(); it++) {
+ if (!writer_->AddCopy(it->first, it->second, 1)) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+bool CreateSnapshot::VerifyMergeOrder() {
+ unique_fd read_fd;
+ read_fd.reset(open(patch_file_.c_str(), O_RDONLY));
+ if (read_fd < 0) {
+ PLOG(ERROR) << "Failed to open the snapshot-patch file: " << patch_file_;
+ return false;
+ }
+ CowReader reader;
+ if (!reader.Parse(read_fd)) {
+ LOG(ERROR) << "Parse failed";
+ return false;
+ }
+
+ if (!reader.VerifyMergeOps()) {
+ LOG(ERROR) << "MergeOps Order is wrong";
+ return false;
+ }
+ return true;
+}
+
+bool CreateSnapshot::WriteV3Snapshots() {
+ if (!CreateSnapshotWriter()) {
+ return false;
+ }
+ if (!WriteOrderedSnapshots()) {
+ return false;
+ }
+ if (!WriteNonOrderedSnapshots()) {
+ return false;
+ }
+ if (!VerifyMergeOrder()) {
+ return false;
+ }
+
+ LOG(INFO) << "In-place: " << in_place_ops_ << " Zero: " << zero_ops_
+ << " Replace: " << replace_ops_ << " copy: " << copy_ops_;
+ return true;
}
bool CreateSnapshot::ReadBlocks(off_t offset, const int skip_blocks, const uint64_t dev_sz) {
@@ -241,10 +392,7 @@
std::string hash = ToHexString(checksum, sizeof(checksum));
if (create_snapshot_patch_) {
- if (!WriteSnapshot(bufptr, blkindex, hash)) {
- LOG(ERROR) << "WriteSnapshot failed for block: " << blkindex;
- return false;
- }
+ PrepareMergeBlock(bufptr, blkindex, hash);
} else {
std::lock_guard<std::mutex> lock(source_block_hash_lock_);
{
@@ -306,8 +454,8 @@
ret = t.get() && ret;
}
- if (ret && create_snapshot_patch_ && !writer_->Finalize()) {
- LOG(ERROR) << "Finzalize failed";
+ if (ret && create_snapshot_patch_ && !WriteV3Snapshots()) {
+ LOG(ERROR) << "Snapshot Write failed";
return false;
}
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
index 1d1d24c..ce80cd7 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
@@ -18,6 +18,7 @@
#include <iostream>
#include <memory>
#include <string_view>
+#include <vector>
#include <android-base/file.h>
#include <android-base/logging.h>
@@ -429,7 +430,7 @@
template <typename T>
class HorribleStream : public IByteStream {
public:
- HorribleStream(const std::basic_string<T>& input) : input_(input) {}
+ HorribleStream(const std::vector<T>& input) : input_(input) {}
ssize_t Read(void* buffer, size_t length) override {
if (pos_ >= input_.size()) {
@@ -444,16 +445,17 @@
size_t Size() const override { return input_.size(); }
private:
- std::basic_string<T> input_;
+ std::vector<T> input_;
size_t pos_ = 0;
};
TEST(HorribleStream, ReadFully) {
- std::string expected = "this is some data";
+ std::string expected_str = "this is some data";
+ std::vector<char> expected{expected_str.begin(), expected_str.end()};
HorribleStream<char> stream(expected);
- std::string buffer(expected.size(), '\0');
+ std::vector<char> buffer(expected.size(), '\0');
ASSERT_TRUE(stream.ReadFully(buffer.data(), buffer.size()));
ASSERT_EQ(buffer, expected);
}
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
index 05de2ad..6a37aa7 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
@@ -81,8 +81,8 @@
int num_compress_threads_ = 1;
std::vector<std::unique_ptr<CompressWorker>> compress_threads_;
std::vector<std::future<bool>> threads_;
- std::vector<std::basic_string<uint8_t>> compressed_buf_;
- std::vector<std::basic_string<uint8_t>>::iterator buf_iter_;
+ std::vector<std::vector<uint8_t>> compressed_buf_;
+ std::vector<std::vector<uint8_t>>::iterator buf_iter_;
std::vector<std::unique_ptr<CowOperationV2>> opbuffer_vec_;
std::vector<std::unique_ptr<uint8_t[]>> databuffer_vec_;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index c92460a..22e6f2c 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -512,8 +512,7 @@
}
bytes_written += op.data_length;
}
- if (!WriteOperation({cached_ops_.data(), cached_ops_.size()},
- {data_vec_.data(), data_vec_.size()})) {
+ if (!WriteOperation(cached_ops_, data_vec_)) {
LOG(ERROR) << "Failed to flush " << cached_ops_.size() << " ops to disk";
return false;
}
@@ -632,7 +631,7 @@
}
// Fetch compressed buffers from the threads
- std::vector<std::basic_string<uint8_t>> compressed_buf;
+ std::vector<std::vector<uint8_t>> compressed_buf;
compressed_buf.clear();
for (size_t i = 0; i < num_threads; i++) {
CompressWorker* worker = compress_threads_[i].get();
@@ -684,8 +683,8 @@
return ProcessBlocksWithThreadedCompression(num_blocks, data, type);
}
-bool CowWriterV3::WriteOperation(std::basic_string_view<CowOperationV3> ops,
- std::basic_string_view<struct iovec> data) {
+bool CowWriterV3::WriteOperation(std::span<const CowOperationV3> ops,
+ std::span<const struct iovec> data) {
const auto total_data_size =
std::transform_reduce(data.begin(), data.end(), 0, std::plus<size_t>{},
[](const struct iovec& a) { return a.iov_len; });
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index 4915e9c..48eb67b 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -15,6 +15,7 @@
#pragma once
#include <android-base/logging.h>
+#include <span>
#include <string_view>
#include <thread>
#include <vector>
@@ -49,15 +50,14 @@
private:
struct CompressedBuffer {
size_t compression_factor;
- std::basic_string<uint8_t> compressed_data;
+ std::vector<uint8_t> compressed_data;
};
void SetupHeaders();
bool NeedsFlush() const;
bool ParseOptions();
bool OpenForWrite();
bool OpenForAppend(uint64_t label);
- bool WriteOperation(std::basic_string_view<CowOperationV3> op,
- std::basic_string_view<struct iovec> data);
+ bool WriteOperation(std::span<const CowOperationV3> op, std::span<const struct iovec> data);
bool EmitBlocks(uint64_t new_block_start, const void* data, size_t size, uint64_t old_block,
uint16_t offset, CowOperationType type);
bool ConstructCowOpCompressedBuffers(uint64_t new_block_start, const void* data,
@@ -111,7 +111,7 @@
int num_compress_threads_ = 1;
size_t batch_size_ = 1;
std::vector<CowOperationV3> cached_ops_;
- std::vector<std::basic_string<uint8_t>> cached_data_;
+ std::vector<std::vector<uint8_t>> cached_data_;
std::vector<struct iovec> data_vec_;
std::vector<std::thread> threads_;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
index 43e896a..04b2736 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
@@ -69,7 +69,7 @@
std::shared_ptr<IBlockServerOpener> block_server_opener_;
std::unique_ptr<IBlockServer> block_server_;
- std::basic_string<uint8_t> xor_buffer_;
+ std::vector<uint8_t> xor_buffer_;
std::unique_ptr<void, decltype(&::free)> aligned_buffer_;
std::unique_ptr<uint8_t[]> decompressed_buffer_;
};
diff --git a/fs_mgr/libsnapshot/tools/cow_benchmark.cpp b/fs_mgr/libsnapshot/tools/cow_benchmark.cpp
index 4d5e346..fb463c8 100644
--- a/fs_mgr/libsnapshot/tools/cow_benchmark.cpp
+++ b/fs_mgr/libsnapshot/tools/cow_benchmark.cpp
@@ -78,7 +78,7 @@
for (size_t i = 0; i < compressors.size(); i++) {
const auto start = std::chrono::steady_clock::now();
- std::basic_string<uint8_t> compressed_data =
+ std::vector<uint8_t> compressed_data =
compressors[i]->Compress(buffer.data(), buffer.size());
const auto end = std::chrono::steady_clock::now();
const auto latency =
@@ -141,13 +141,13 @@
std::vector<std::pair<double, std::string>> ratios;
for (size_t i = 0; i < compressors.size(); i++) {
- std::vector<std::basic_string<uint8_t>> compressed_data_vec;
+ std::vector<std::vector<uint8_t>> compressed_data_vec;
int num_blocks = buffer.size() / BLOCK_SZ;
const uint8_t* iter = reinterpret_cast<const uint8_t*>(buffer.data());
const auto start = std::chrono::steady_clock::now();
while (num_blocks > 0) {
- std::basic_string<uint8_t> compressed_data = compressors[i]->Compress(iter, BLOCK_SZ);
+ std::vector<uint8_t> compressed_data = compressors[i]->Compress(iter, BLOCK_SZ);
compressed_data_vec.emplace_back(compressed_data);
num_blocks--;
iter += BLOCK_SZ;
diff --git a/healthd/BatteryMonitor.cpp b/healthd/BatteryMonitor.cpp
index fbdf5fe..b8bb586 100644
--- a/healthd/BatteryMonitor.cpp
+++ b/healthd/BatteryMonitor.cpp
@@ -530,7 +530,7 @@
props.chargerAcOnline ? "a" : "", props.chargerUsbOnline ? "u" : "",
props.chargerWirelessOnline ? "w" : "", props.chargerDockOnline ? "d" : "");
- KLOG_DEBUG(LOG_TAG, "%s\n", dmesgline);
+ KLOG_WARNING(LOG_TAG, "%s\n", dmesgline);
}
void BatteryMonitor::logValues(const HealthInfo_2_1& health_info,
diff --git a/init/Android.bp b/init/Android.bp
index 181de2e..2d16f60 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -88,7 +88,6 @@
init_host_sources = [
"check_builtins.cpp",
"host_import_parser.cpp",
- "host_init_verifier.cpp",
]
soong_config_module_type {
@@ -321,7 +320,6 @@
visibility: ["//packages/modules/Virtualization/microdroid"],
}
-
soong_config_module_type {
name: "init_first_stage_cc_defaults",
module_type: "cc_defaults",
@@ -614,13 +612,13 @@
cc_binary {
name: "host_init_verifier",
defaults: ["init_host_defaults"],
- srcs: init_common_sources + init_host_sources,
+ srcs: ["host_init_verifier.cpp"] + init_common_sources + init_host_sources,
}
cc_library_host_static {
name: "libinit_host",
defaults: ["init_host_defaults"],
- srcs: init_common_sources,
+ srcs: init_common_sources + init_host_sources,
export_include_dirs: ["."],
proto: {
export_proto_headers: true,
diff --git a/init/check_builtins.cpp b/init/check_builtins.cpp
index 461ed22..9725458 100644
--- a/init/check_builtins.cpp
+++ b/init/check_builtins.cpp
@@ -28,9 +28,9 @@
#include <android-base/parsedouble.h>
#include <android-base/parseint.h>
#include <android-base/strings.h>
+#include <property_info_parser/property_info_parser.h>
#include "builtin_arguments.h"
-#include "host_init_verifier.h"
#include "interface_utils.h"
#include "property_type.h"
#include "rlimit_parser.h"
@@ -39,6 +39,9 @@
using android::base::ParseInt;
using android::base::StartsWith;
+using android::properties::BuildTrie;
+using android::properties::PropertyInfoArea;
+using android::properties::PropertyInfoEntry;
#define ReturnIfAnyArgsEmpty() \
for (const auto& arg : args) { \
@@ -50,6 +53,26 @@
namespace android {
namespace init {
+const PropertyInfoArea* property_info_area;
+
+Result<void> InitializeHostPropertyInfoArea(const std::vector<PropertyInfoEntry>& property_infos) {
+ static std::string serialized_contexts;
+ std::string trie_error;
+ if (!BuildTrie(property_infos, "u:object_r:default_prop:s0", "string", &serialized_contexts,
+ &trie_error)) {
+ return Error() << "Unable to serialize property contexts: " << trie_error;
+ }
+
+ property_info_area = reinterpret_cast<const PropertyInfoArea*>(serialized_contexts.c_str());
+ return {};
+}
+
+static Result<void> check_stub(const BuiltinArguments& args) {
+ return {};
+}
+
+#include "generated_stub_builtin_function_map.h"
+
Result<void> check_chown(const BuiltinArguments& args) {
if (!args[1].empty()) {
auto uid = DecodeUid(args[1]);
diff --git a/init/check_builtins.h b/init/check_builtins.h
index dc1b752..9b00a7c 100644
--- a/init/check_builtins.h
+++ b/init/check_builtins.h
@@ -19,6 +19,10 @@
#include "builtin_arguments.h"
#include "result.h"
+#include <vector>
+
+#include <property_info_serializer/property_info_serializer.h>
+
namespace android {
namespace init {
@@ -43,5 +47,8 @@
Result<void> check_wait(const BuiltinArguments& args);
Result<void> check_wait_for_prop(const BuiltinArguments& args);
+Result<void> InitializeHostPropertyInfoArea(
+ const std::vector<properties::PropertyInfoEntry>& property_infos);
+
} // namespace init
} // namespace android
diff --git a/init/first_stage_console.cpp b/init/first_stage_console.cpp
index 67cac19..0076764 100644
--- a/init/first_stage_console.cpp
+++ b/init/first_stage_console.cpp
@@ -78,6 +78,7 @@
const char* args[] = {path, "/first_stage.sh", nullptr};
int rv = execv(path, const_cast<char**>(args));
LOG(ERROR) << "unable to execv /first_stage.sh, returned " << rv << " errno " << errno;
+ _exit(127);
}
namespace android {
@@ -86,7 +87,9 @@
void StartConsole(const std::string& cmdline) {
bool console = KernelConsolePresent(cmdline);
// Use a simple sigchld handler -- first_stage_console doesn't need to track or log zombies
- const struct sigaction chld_act { .sa_handler = SIG_DFL, .sa_flags = SA_NOCLDWAIT };
+ const struct sigaction chld_act {
+ .sa_flags = SA_NOCLDWAIT, .sa_handler = SIG_DFL
+ };
sigaction(SIGCHLD, &chld_act, nullptr);
pid_t pid = fork();
diff --git a/init/host_init_verifier.cpp b/init/host_init_verifier.cpp
index 662185c..f746ab9 100644
--- a/init/host_init_verifier.cpp
+++ b/init/host_init_verifier.cpp
@@ -14,8 +14,6 @@
// limitations under the License.
//
-#include "host_init_verifier.h"
-
#include <errno.h>
#include <getopt.h>
#include <pwd.h>
@@ -36,6 +34,7 @@
#include <android-base/strings.h>
#include <generated_android_ids.h>
#include <hidl/metadata.h>
+#include <property_info_parser/property_info_parser.h>
#include <property_info_serializer/property_info_serializer.h>
#include "action.h"
@@ -57,9 +56,7 @@
using android::base::ParseInt;
using android::base::ReadFileToString;
using android::base::Split;
-using android::properties::BuildTrie;
using android::properties::ParsePropertyInfoFile;
-using android::properties::PropertyInfoArea;
using android::properties::PropertyInfoEntry;
static std::vector<std::string> passwd_files;
@@ -148,12 +145,6 @@
namespace android {
namespace init {
-static Result<void> check_stub(const BuiltinArguments& args) {
- return {};
-}
-
-#include "generated_stub_builtin_function_map.h"
-
void PrintUsage() {
fprintf(stdout, R"(usage: host_init_verifier [options]
@@ -196,8 +187,6 @@
return result;
}
-const PropertyInfoArea* property_info_area;
-
void HandlePropertyContexts(const std::string& filename,
std::vector<PropertyInfoEntry>* property_infos) {
auto file_contents = std::string();
@@ -288,16 +277,11 @@
}
SetKnownInterfaces(*interface_inheritance_hierarchy_map);
- std::string serialized_contexts;
- std::string trie_error;
- if (!BuildTrie(property_infos, "u:object_r:default_prop:s0", "string", &serialized_contexts,
- &trie_error)) {
- LOG(ERROR) << "Unable to serialize property contexts: " << trie_error;
+ if (auto result = InitializeHostPropertyInfoArea(property_infos); !result.ok()) {
+ LOG(ERROR) << result.error();
return EXIT_FAILURE;
}
- property_info_area = reinterpret_cast<const PropertyInfoArea*>(serialized_contexts.c_str());
-
if (!partition_map.empty()) {
std::vector<std::string> vendor_prefixes;
for (const auto& partition : {"vendor", "odm"}) {
diff --git a/init/host_init_verifier.h b/init/host_init_verifier.h
deleted file mode 100644
index 5d24f2a..0000000
--- a/init/host_init_verifier.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (C) 2019 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 <property_info_parser/property_info_parser.h>
-
-namespace android {
-namespace init {
-
-extern const android::properties::PropertyInfoArea* property_info_area;
-
-} // namespace init
-} // namespace android
diff --git a/init/property_service.cpp b/init/property_service.cpp
index 30ad800..bc4ef42 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -1104,7 +1104,8 @@
product_first_api_level = GetIntProperty("ro.build.version.sdk", __ANDROID_API_FUTURE__);
}
- vendor_api_level = std::min(vendor_api_level_of(product_first_api_level), vendor_api_level);
+ vendor_api_level =
+ std::min(AVendorSupport_getVendorApiLevelOf(product_first_api_level), vendor_api_level);
if (vendor_api_level < 0) {
LOG(ERROR) << "Unexpected vendor api level for " << VENDOR_API_LEVEL_PROP << ". Check "
diff --git a/libcutils/ashmem_test.cpp b/libcutils/ashmem_test.cpp
index d158427..571b410 100644
--- a/libcutils/ashmem_test.cpp
+++ b/libcutils/ashmem_test.cpp
@@ -22,6 +22,8 @@
#include <sys/types.h>
#include <unistd.h>
+#include <vector>
+
#include <android-base/macros.h>
#include <android-base/unique_fd.h>
#include <cutils/ashmem.h>
@@ -61,16 +63,16 @@
EXPECT_EQ(prot, ioctl(fd, ASHMEM_GET_PROT_MASK));
}
-void FillData(uint8_t* data, size_t dataLen) {
- for (size_t i = 0; i < dataLen; i++) {
+void FillData(std::vector<uint8_t>& data) {
+ for (size_t i = 0; i < data.size(); i++) {
data[i] = i & 0xFF;
}
}
TEST(AshmemTest, BasicTest) {
- constexpr size_t size = PAGE_SIZE;
- uint8_t data[size];
- FillData(data, size);
+ const size_t size = getpagesize();
+ std::vector<uint8_t> data(size);
+ FillData(data);
unique_fd fd;
ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
@@ -78,21 +80,21 @@
void* region1 = nullptr;
ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_READ | PROT_WRITE, ®ion1));
- memcpy(region1, &data, size);
- ASSERT_EQ(0, memcmp(region1, &data, size));
+ memcpy(region1, data.data(), size);
+ ASSERT_EQ(0, memcmp(region1, data.data(), size));
EXPECT_EQ(0, munmap(region1, size));
void *region2;
ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_READ, ®ion2));
- ASSERT_EQ(0, memcmp(region2, &data, size));
+ ASSERT_EQ(0, memcmp(region2, data.data(), size));
EXPECT_EQ(0, munmap(region2, size));
}
TEST(AshmemTest, ForkTest) {
- constexpr size_t size = PAGE_SIZE;
- uint8_t data[size];
- FillData(data, size);
+ const size_t size = getpagesize();
+ std::vector<uint8_t> data(size);
+ FillData(data);
unique_fd fd;
ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
@@ -100,8 +102,8 @@
void* region1 = nullptr;
ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_READ | PROT_WRITE, ®ion1));
- memcpy(region1, &data, size);
- ASSERT_EQ(0, memcmp(region1, &data, size));
+ memcpy(region1, data.data(), size);
+ ASSERT_EQ(0, memcmp(region1, data.data(), size));
EXPECT_EQ(0, munmap(region1, size));
ASSERT_EXIT(
@@ -113,7 +115,7 @@
if (region2 == MAP_FAILED) {
_exit(1);
}
- if (memcmp(region2, &data, size) != 0) {
+ if (memcmp(region2, data.data(), size) != 0) {
_exit(2);
}
memset(region2, 0, size);
@@ -122,10 +124,10 @@
},
::testing::ExitedWithCode(0), "");
- memset(&data, 0, size);
+ memset(data.data(), 0, size);
void *region2;
ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_READ | PROT_WRITE, ®ion2));
- ASSERT_EQ(0, memcmp(region2, &data, size));
+ ASSERT_EQ(0, memcmp(region2, data.data(), size));
EXPECT_EQ(0, munmap(region2, size));
}
@@ -134,18 +136,19 @@
void* region = nullptr;
// Allocate a 4-page buffer, but leave page-sized holes on either side
- constexpr size_t size = PAGE_SIZE * 4;
- constexpr size_t dataSize = PAGE_SIZE * 2;
- constexpr size_t holeSize = PAGE_SIZE;
+ const size_t pageSize = getpagesize();
+ const size_t size = pageSize * 4;
+ const size_t dataSize = pageSize * 2;
+ const size_t holeSize = pageSize;
ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
ASSERT_NO_FATAL_FAILURE(TestMmap(fd, dataSize, PROT_READ | PROT_WRITE, ®ion, holeSize));
- uint8_t data[dataSize];
- FillData(data, dataSize);
- memcpy(region, data, dataSize);
+ std::vector<uint8_t> data(dataSize);
+ FillData(data);
+ memcpy(region, data.data(), dataSize);
- constexpr off_t dataStart = holeSize;
- constexpr off_t dataEnd = dataStart + dataSize;
+ const off_t dataStart = holeSize;
+ const off_t dataEnd = dataStart + dataSize;
// The sequence of seeks below looks something like this:
//
@@ -163,9 +166,12 @@
// Expected lseek() return value
off_t ret;
} seeks[] = {
- {99, SEEK_SET, 99}, {dataStart, SEEK_CUR, dataStart + 99},
- {0, SEEK_DATA, dataStart}, {dataStart, SEEK_HOLE, dataEnd},
- {-99, SEEK_END, size - 99}, {-dataStart, SEEK_CUR, dataEnd - 99},
+ {99, SEEK_SET, 99},
+ {dataStart, SEEK_CUR, dataStart + 99},
+ {0, SEEK_DATA, dataStart},
+ {dataStart, SEEK_HOLE, dataEnd},
+ {-99, SEEK_END, static_cast<off_t>(size) - 99},
+ {-dataStart, SEEK_CUR, dataEnd - 99},
};
for (const auto& cfg : seeks) {
errno = 0;
@@ -180,7 +186,7 @@
uint8_t buf[readSize];
ASSERT_EQ(readSize, TEMP_FAILURE_RETRY(read(fd, buf, readSize)));
- EXPECT_EQ(0, memcmp(buf, data + dataOff, readSize));
+ EXPECT_EQ(0, memcmp(buf, &data[dataOff], readSize));
}
}
@@ -189,7 +195,7 @@
TEST(AshmemTest, ProtTest) {
unique_fd fd;
- constexpr size_t size = PAGE_SIZE;
+ const size_t size = getpagesize();
void *region;
ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ));
@@ -217,7 +223,7 @@
TEST(AshmemTest, ForkProtTest) {
unique_fd fd;
- constexpr size_t size = PAGE_SIZE;
+ const size_t size = getpagesize();
int protFlags[] = { PROT_READ, PROT_WRITE };
for (size_t i = 0; i < arraysize(protFlags); i++) {
@@ -238,9 +244,9 @@
}
TEST(AshmemTest, ForkMultiRegionTest) {
- constexpr size_t size = PAGE_SIZE;
- uint8_t data[size];
- FillData(data, size);
+ const size_t size = getpagesize();
+ std::vector<uint8_t> data(size);
+ FillData(data);
constexpr int nRegions = 16;
unique_fd fd[nRegions];
@@ -248,8 +254,8 @@
ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd[i], PROT_READ | PROT_WRITE));
void* region = nullptr;
ASSERT_NO_FATAL_FAILURE(TestMmap(fd[i], size, PROT_READ | PROT_WRITE, ®ion));
- memcpy(region, &data, size);
- ASSERT_EQ(0, memcmp(region, &data, size));
+ memcpy(region, data.data(), size);
+ ASSERT_EQ(0, memcmp(region, data.data(), size));
EXPECT_EQ(0, munmap(region, size));
}
@@ -262,7 +268,7 @@
if (region == MAP_FAILED) {
_exit(1);
}
- if (memcmp(region, &data, size) != 0) {
+ if (memcmp(region, data.data(), size) != 0) {
munmap(region, size);
_exit(2);
}
@@ -272,11 +278,11 @@
_exit(0);
}, ::testing::ExitedWithCode(0), "");
- memset(&data, 0, size);
+ memset(data.data(), 0, size);
for (int i = 0; i < nRegions; i++) {
void *region;
ASSERT_NO_FATAL_FAILURE(TestMmap(fd[i], size, PROT_READ | PROT_WRITE, ®ion));
- ASSERT_EQ(0, memcmp(region, &data, size));
+ ASSERT_EQ(0, memcmp(region, data.data(), size));
EXPECT_EQ(0, munmap(region, size));
}
}
diff --git a/libutils/include/utils/CallStack.h b/libutils/include/utils/CallStack.h
index fe4d4f5..54d559b 100644
--- a/libutils/include/utils/CallStack.h
+++ b/libutils/include/utils/CallStack.h
@@ -37,7 +37,9 @@
# endif // !WEAKS_AVAILABLE
#endif // CALLSTACK_WEAK predefined
-#define ALWAYS_INLINE __attribute__((always_inline))
+#ifndef CALLSTACK_ALWAYS_INLINE
+#define CALLSTACK_ALWAYS_INLINE __attribute__((always_inline))
+#endif // CALLSTACK_ALWAYS_INLINE predefined
namespace android {
@@ -102,7 +104,7 @@
// Return current call stack if possible, nullptr otherwise.
#ifdef WEAKS_AVAILABLE
- static CallStackUPtr ALWAYS_INLINE getCurrent(int32_t ignoreDepth = 1) {
+ static CallStackUPtr CALLSTACK_ALWAYS_INLINE getCurrent(int32_t ignoreDepth = 1) {
if (reinterpret_cast<uintptr_t>(getCurrentInternal) == 0) {
ALOGW("CallStack::getCurrentInternal not linked, returning null");
return CallStackUPtr(nullptr);
@@ -111,14 +113,15 @@
}
}
#else // !WEAKS_AVAILABLE
- static CallStackUPtr ALWAYS_INLINE getCurrent(int32_t = 1) {
+ static CallStackUPtr CALLSTACK_ALWAYS_INLINE getCurrent(int32_t = 1) {
return CallStackUPtr(nullptr);
}
#endif // !WEAKS_AVAILABLE
#ifdef WEAKS_AVAILABLE
- static void ALWAYS_INLINE logStack(const char* logtag, CallStack* stack = getCurrent().get(),
- android_LogPriority priority = ANDROID_LOG_DEBUG) {
+ static void CALLSTACK_ALWAYS_INLINE logStack(const char* logtag,
+ CallStack* stack = getCurrent().get(),
+ android_LogPriority priority = ANDROID_LOG_DEBUG) {
if (reinterpret_cast<uintptr_t>(logStackInternal) != 0 && stack != nullptr) {
logStackInternal(logtag, stack, priority);
} else {
@@ -127,15 +130,16 @@
}
#else
- static void ALWAYS_INLINE logStack(const char* logtag, CallStack* = getCurrent().get(),
- android_LogPriority = ANDROID_LOG_DEBUG) {
+ static void CALLSTACK_ALWAYS_INLINE logStack(const char* logtag,
+ CallStack* = getCurrent().get(),
+ android_LogPriority = ANDROID_LOG_DEBUG) {
ALOG(LOG_WARN, logtag, "CallStack::logStackInternal not linked");
}
#endif // !WEAKS_AVAILABLE
#ifdef WEAKS_AVAILABLE
- static String8 ALWAYS_INLINE stackToString(const char* prefix = nullptr,
- const CallStack* stack = getCurrent().get()) {
+ static String8 CALLSTACK_ALWAYS_INLINE
+ stackToString(const char* prefix = nullptr, const CallStack* stack = getCurrent().get()) {
if (reinterpret_cast<uintptr_t>(stackToStringInternal) != 0 && stack != nullptr) {
return stackToStringInternal(prefix, stack);
} else {
@@ -143,8 +147,8 @@
}
}
#else // !WEAKS_AVAILABLE
- static String8 ALWAYS_INLINE stackToString(const char* prefix = nullptr,
- const CallStack* = getCurrent().get()) {
+ static String8 CALLSTACK_ALWAYS_INLINE stackToString(const char* prefix = nullptr,
+ const CallStack* = getCurrent().get()) {
return String8::format("%s<CallStack package not linked>", (prefix ? prefix : ""));
}
#endif // !WEAKS_AVAILABLE
@@ -165,4 +169,6 @@
} // namespace android
+#undef CALLSTACK_ALWAYS_INLINE
+
#endif // ANDROID_CALLSTACK_H
diff --git a/libvendorsupport/include/vendorsupport/api_level.h b/libvendorsupport/include/vendorsupport/api_level.h
index ba1a6b8..d365075 100644
--- a/libvendorsupport/include/vendorsupport/api_level.h
+++ b/libvendorsupport/include/vendorsupport/api_level.h
@@ -14,38 +14,34 @@
#pragma once
-#include <android/api-level.h>
+#include <sys/cdefs.h>
+
+__BEGIN_DECLS
#define __ANDROID_VENDOR_API_MAX__ 1000000
#define __INVALID_API_LEVEL -1
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/**
* @brief Find corresponding vendor API level from an SDK API version.
*
* @details
* SDK API versions and vendor API levels are not compatible and not
- * convertible. However, this function can be used to compare the two versions
+ * exchangeable. However, this function can be used to compare the two versions
* to know which one is newer than the other.
*
- * @param sdk_api_level The SDK version int. This must be less than 10000.
+ * @param sdkApiLevel The SDK version int. This must be less than 10000.
* @return The corresponding vendor API level of the SDK version. -1 if the SDK
* version is invalid or 10000.
*/
-int vendor_api_level_of(int sdk_api_level);
+int AVendorSupport_getVendorApiLevelOf(int sdkApiLevel);
/**
* @brief Find corresponding SDK API version from a vendor API level.
*
- * @param vendor_api_level The vendor API level int.
+ * @param vendorApiLevel The vendor API level int.
* @return The corresponding SDK API version of the vendor API level. -1 if the
* vendor API level is invalid.
*/
-int sdk_api_level_of(int vendor_api_level);
+int AVendorSupport_getSdkApiLevelOf(int vendorApiLevel);
-#ifdef __cplusplus
-}
-#endif
+__END_DECLS
diff --git a/libvendorsupport/libvendorsupport.map.txt b/libvendorsupport/libvendorsupport.map.txt
index 9a23b94..d99c834 100644
--- a/libvendorsupport/libvendorsupport.map.txt
+++ b/libvendorsupport/libvendorsupport.map.txt
@@ -1,7 +1,7 @@
LIBVENDORSUPPORT {
global:
- vendor_api_level_of; # llndk systemapi
- sdk_api_level_of; # llndk systemapi
+ AVendorSupport_getVendorApiLevelOf; # llndk systemapi
+ AVendorSupport_getSdkApiLevelOf; # llndk systemapi
local:
*;
};
diff --git a/libvendorsupport/tests/version_props_test.cpp b/libvendorsupport/tests/version_props_test.cpp
index 538a2e2..ad54c88 100644
--- a/libvendorsupport/tests/version_props_test.cpp
+++ b/libvendorsupport/tests/version_props_test.cpp
@@ -21,17 +21,17 @@
namespace {
-TEST(vendorsupport, get_corresponding_vendor_api_level) {
- ASSERT_EQ(__ANDROID_API_U__, vendor_api_level_of(__ANDROID_API_U__));
- ASSERT_EQ(202404, vendor_api_level_of(__ANDROID_API_V__));
- ASSERT_EQ(__INVALID_API_LEVEL, vendor_api_level_of(__ANDROID_API_FUTURE__));
+TEST(VendorSupport, GetCorrespondingVendorApiLevel) {
+ ASSERT_EQ(__ANDROID_API_U__, AVendorSupport_getVendorApiLevelOf(__ANDROID_API_U__));
+ ASSERT_EQ(202404, AVendorSupport_getVendorApiLevelOf(__ANDROID_API_V__));
+ ASSERT_EQ(__INVALID_API_LEVEL, AVendorSupport_getVendorApiLevelOf(__ANDROID_API_FUTURE__));
}
-TEST(vendorsupport, get_corresponding_sdk_api_level) {
- ASSERT_EQ(__ANDROID_API_U__, sdk_api_level_of(__ANDROID_API_U__));
- ASSERT_EQ(__ANDROID_API_V__, sdk_api_level_of(202404));
- ASSERT_EQ(__INVALID_API_LEVEL, sdk_api_level_of(__ANDROID_VENDOR_API_MAX__));
- ASSERT_EQ(__INVALID_API_LEVEL, sdk_api_level_of(35));
+TEST(VendorSupport, GetCorrespondingSdkApiLevel) {
+ ASSERT_EQ(__ANDROID_API_U__, AVendorSupport_getSdkApiLevelOf(__ANDROID_API_U__));
+ ASSERT_EQ(__ANDROID_API_V__, AVendorSupport_getSdkApiLevelOf(202404));
+ ASSERT_EQ(__INVALID_API_LEVEL, AVendorSupport_getSdkApiLevelOf(__ANDROID_VENDOR_API_MAX__));
+ ASSERT_EQ(__INVALID_API_LEVEL, AVendorSupport_getSdkApiLevelOf(35));
}
} // namespace
\ No newline at end of file
diff --git a/libvendorsupport/version_props.c b/libvendorsupport/version_props.c
index 4d0e45e..835828c 100644
--- a/libvendorsupport/version_props.c
+++ b/libvendorsupport/version_props.c
@@ -16,26 +16,26 @@
#include <log/log.h>
-int vendor_api_level_of(int sdk_api_level) {
- if (sdk_api_level < __ANDROID_API_V__) {
- return sdk_api_level;
+int AVendorSupport_getVendorApiLevelOf(int sdkApiLevel) {
+ if (sdkApiLevel < __ANDROID_API_V__) {
+ return sdkApiLevel;
}
// In Android V, vendor API level started with version 202404.
// The calculation assumes that the SDK api level bumps once a year.
- if (sdk_api_level < __ANDROID_API_FUTURE__) {
- return 202404 + ((sdk_api_level - __ANDROID_API_V__) * 100);
+ if (sdkApiLevel < __ANDROID_API_FUTURE__) {
+ return 202404 + ((sdkApiLevel - __ANDROID_API_V__) * 100);
}
- ALOGE("The SDK version must be less than 10000: %d", sdk_api_level);
+ ALOGE("The SDK version must be less than 10000: %d", sdkApiLevel);
return __INVALID_API_LEVEL;
}
-int sdk_api_level_of(int vendor_api_level) {
- if (vendor_api_level < __ANDROID_API_V__) {
- return vendor_api_level;
+int AVendorSupport_getSdkApiLevelOf(int vendorApiLevel) {
+ if (vendorApiLevel < __ANDROID_API_V__) {
+ return vendorApiLevel;
}
- if (vendor_api_level >= 202404 && vendor_api_level < __ANDROID_VENDOR_API_MAX__) {
- return (vendor_api_level - 202404) / 100 + __ANDROID_API_V__;
+ if (vendorApiLevel >= 202404 && vendorApiLevel < __ANDROID_VENDOR_API_MAX__) {
+ return (vendorApiLevel - 202404) / 100 + __ANDROID_API_V__;
}
- ALOGE("Unexpected vendor api level: %d", vendor_api_level);
+ ALOGE("Unexpected vendor api level: %d", vendorApiLevel);
return __INVALID_API_LEVEL;
}
diff --git a/rootdir/init.rc b/rootdir/init.rc
index 0646d14..f3b2d03 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -640,6 +640,11 @@
restorecon_recursive /metadata/apex
mkdir /metadata/staged-install 0770 root system
+
+ mkdir /metadata/aconfig 0750 root system
+ mkdir /metadata/aconfig/flags 0750 root system
+ mkdir /metadata/aconfig/boot 0754 root system
+
on late-fs
# Ensure that tracefs has the correct permissions.
# This does not work correctly if it is called in post-fs.
diff --git a/trusty/metrics/include/trusty/metrics/tipc.h b/trusty/metrics/include/trusty/metrics/tipc.h
index 66d0876..b29628e 100644
--- a/trusty/metrics/include/trusty/metrics/tipc.h
+++ b/trusty/metrics/include/trusty/metrics/tipc.h
@@ -91,9 +91,12 @@
* struct metrics_report_crash_req - arguments of %METRICS_CMD_REPORT_CRASH
* requests
* @app_id_len: length of app ID that follows this structure
+ * @crash_reason: architecture-specific code representing the reason for the
+ * crash
*/
struct metrics_report_crash_req {
uint32_t app_id_len;
+ uint32_t crash_reason;
} __attribute__((__packed__));
#define METRICS_MAX_APP_ID_LEN 256