Merge "Read data set by android_add_crash_detail into tombstone." into main
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/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/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/init/first_stage_console.cpp b/init/first_stage_console.cpp
index 67cac19..c6c3008 100644
--- a/init/first_stage_console.cpp
+++ b/init/first_stage_console.cpp
@@ -86,7 +86,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/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/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