Merge "libsnapshot: Add a compression bit to SnapshotStatus."
diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 5565e8b..e5af425 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -34,7 +34,6 @@
#include <android/set_abort_message.h>
#include <bionic/malloc.h>
#include <bionic/mte.h>
-#include <bionic/mte_kernel.h>
#include <bionic/reserved_signals.h>
#include <android-base/cmsg.h>
@@ -386,16 +385,6 @@
#if defined(__aarch64__) && defined(ANDROID_EXPERIMENTAL_MTE)
static void SetTagCheckingLevelSync() {
- int tagged_addr_ctrl = prctl(PR_GET_TAGGED_ADDR_CTRL, 0, 0, 0, 0);
- if (tagged_addr_ctrl < 0) {
- abort();
- }
-
- tagged_addr_ctrl = (tagged_addr_ctrl & ~PR_MTE_TCF_MASK) | PR_MTE_TCF_SYNC;
- if (prctl(PR_SET_TAGGED_ADDR_CTRL, tagged_addr_ctrl, 0, 0, 0) != 0) {
- abort();
- }
-
HeapTaggingLevel heap_tagging_level = M_HEAP_TAGGING_LEVEL_SYNC;
if (!android_mallopt(M_SET_HEAP_TAGGING_LEVEL, &heap_tagging_level, sizeof(heap_tagging_level))) {
abort();
diff --git a/fs_mgr/tools/Android.bp b/fs_mgr/tools/Android.bp
index 4d4aae4..d6ccc4b 100644
--- a/fs_mgr/tools/Android.bp
+++ b/fs_mgr/tools/Android.bp
@@ -29,3 +29,15 @@
cflags: ["-Werror"],
}
+
+cc_binary {
+ name: "dmuserd",
+ srcs: ["dmuserd.cpp"],
+
+ shared_libs: [
+ "libbase",
+ "liblog",
+ ],
+
+ cflags: ["-Werror"],
+}
diff --git a/fs_mgr/tools/dmuserd.cpp b/fs_mgr/tools/dmuserd.cpp
new file mode 100644
index 0000000..92f5878
--- /dev/null
+++ b/fs_mgr/tools/dmuserd.cpp
@@ -0,0 +1,319 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#define _LARGEFILE64_SOURCE
+
+#include <errno.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <poll.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/prctl.h>
+#include <unistd.h>
+#include <iostream>
+
+#define SECTOR_SIZE ((__u64)512)
+#define BUFFER_BYTES 4096
+
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+
+/* This should be replaced with linux/dm-user.h. */
+#ifndef _LINUX_DM_USER_H
+#define _LINUX_DM_USER_H
+
+#include <linux/types.h>
+
+#define DM_USER_REQ_MAP_READ 0
+#define DM_USER_REQ_MAP_WRITE 1
+#define DM_USER_REQ_MAP_FLUSH 2
+#define DM_USER_REQ_MAP_DISCARD 3
+#define DM_USER_REQ_MAP_SECURE_ERASE 4
+#define DM_USER_REQ_MAP_WRITE_SAME 5
+#define DM_USER_REQ_MAP_WRITE_ZEROES 6
+#define DM_USER_REQ_MAP_ZONE_OPEN 7
+#define DM_USER_REQ_MAP_ZONE_CLOSE 8
+#define DM_USER_REQ_MAP_ZONE_FINISH 9
+#define DM_USER_REQ_MAP_ZONE_APPEND 10
+#define DM_USER_REQ_MAP_ZONE_RESET 11
+#define DM_USER_REQ_MAP_ZONE_RESET_ALL 12
+
+#define DM_USER_REQ_MAP_FLAG_FAILFAST_DEV 0x00001
+#define DM_USER_REQ_MAP_FLAG_FAILFAST_TRANSPORT 0x00002
+#define DM_USER_REQ_MAP_FLAG_FAILFAST_DRIVER 0x00004
+#define DM_USER_REQ_MAP_FLAG_SYNC 0x00008
+#define DM_USER_REQ_MAP_FLAG_META 0x00010
+#define DM_USER_REQ_MAP_FLAG_PRIO 0x00020
+#define DM_USER_REQ_MAP_FLAG_NOMERGE 0x00040
+#define DM_USER_REQ_MAP_FLAG_IDLE 0x00080
+#define DM_USER_REQ_MAP_FLAG_INTEGRITY 0x00100
+#define DM_USER_REQ_MAP_FLAG_FUA 0x00200
+#define DM_USER_REQ_MAP_FLAG_PREFLUSH 0x00400
+#define DM_USER_REQ_MAP_FLAG_RAHEAD 0x00800
+#define DM_USER_REQ_MAP_FLAG_BACKGROUND 0x01000
+#define DM_USER_REQ_MAP_FLAG_NOWAIT 0x02000
+#define DM_USER_REQ_MAP_FLAG_CGROUP_PUNT 0x04000
+#define DM_USER_REQ_MAP_FLAG_NOUNMAP 0x08000
+#define DM_USER_REQ_MAP_FLAG_HIPRI 0x10000
+#define DM_USER_REQ_MAP_FLAG_DRV 0x20000
+#define DM_USER_REQ_MAP_FLAG_SWAP 0x40000
+
+#define DM_USER_RESP_SUCCESS 0
+#define DM_USER_RESP_ERROR 1
+#define DM_USER_RESP_UNSUPPORTED 2
+
+struct dm_user_message {
+ __u64 seq;
+ __u64 type;
+ __u64 flags;
+ __u64 sector;
+ __u64 len;
+ __u8 buf[];
+};
+
+#endif
+
+static bool verbose = false;
+
+size_t write_all(int fd, void* buf, size_t len) {
+ char* buf_c = (char*)buf;
+ ssize_t total = 0;
+ ssize_t once;
+
+ while (total < len) {
+ once = write(fd, buf_c + total, len - total);
+ if (once < 0) return once;
+ if (once == 0) {
+ errno = ENOSPC;
+ return 0;
+ }
+ total += once;
+ }
+
+ return total;
+}
+
+size_t read_all(int fd, void* buf, size_t len) {
+ char* buf_c = (char*)buf;
+ ssize_t total = 0;
+ ssize_t once;
+
+ while (total < len) {
+ once = read(fd, buf_c + total, len - total);
+ if (once < 0) return once;
+ if (once == 0) {
+ errno = ENOSPC;
+ return 0;
+ }
+ total += once;
+ }
+
+ return total;
+}
+
+int not_splice(int from, int to, __u64 count) {
+ while (count > 0) {
+ char buf[BUFFER_BYTES];
+ __u64 max = count > BUFFER_BYTES ? BUFFER_BYTES : count;
+
+ if (read_all(from, buf, max) <= 0) {
+ perror("Unable to read");
+ return -EIO;
+ }
+
+ if (write_all(to, buf, max) <= 0) {
+ perror("Unable to write");
+ return -EIO;
+ }
+
+ count -= max;
+ }
+
+ return 0;
+}
+
+int simple_daemon(char* control_path, char* backing_path) {
+ int control_fd = open(control_path, O_RDWR);
+ if (control_fd < 0) {
+ fprintf(stderr, "Unable to open control device %s\n", control_path);
+ return -1;
+ }
+
+ int backing_fd = open(backing_path, O_RDWR);
+ if (backing_fd < 0) {
+ fprintf(stderr, "Unable to open backing device %s\n", backing_path);
+ return -1;
+ }
+
+ while (1) {
+ struct dm_user_message msg;
+ char* base;
+ __u64 type;
+
+ if (verbose) std::cerr << "dmuserd: Waiting for message...\n";
+
+ if (read_all(control_fd, &msg, sizeof(msg)) < 0) {
+ if (errno == ENOTBLK) return 0;
+
+ perror("unable to read msg");
+ return -1;
+ }
+
+ if (verbose) {
+ std::string type;
+ switch (msg.type) {
+ case DM_USER_REQ_MAP_WRITE:
+ type = "write";
+ break;
+ case DM_USER_REQ_MAP_READ:
+ type = "read";
+ break;
+ case DM_USER_REQ_MAP_FLUSH:
+ type = "flush";
+ break;
+ default:
+ /*
+ * FIXME: Can't I do "whatever"s here rather that
+ * std::string("whatever")?
+ */
+ type = std::string("(unknown, id=") + std::to_string(msg.type) + ")";
+ break;
+ }
+
+ std::string flags;
+ if (msg.flags & DM_USER_REQ_MAP_FLAG_SYNC) {
+ if (!flags.empty()) flags += "|";
+ flags += "S";
+ }
+ if (msg.flags & DM_USER_REQ_MAP_FLAG_META) {
+ if (!flags.empty()) flags += "|";
+ flags += "M";
+ }
+ if (msg.flags & DM_USER_REQ_MAP_FLAG_FUA) {
+ if (!flags.empty()) flags += "|";
+ flags += "FUA";
+ }
+ if (msg.flags & DM_USER_REQ_MAP_FLAG_PREFLUSH) {
+ if (!flags.empty()) flags += "|";
+ flags += "F";
+ }
+
+ std::cerr << "dmuserd: Got " << type << " request " << flags << " for sector "
+ << std::to_string(msg.sector) << " with length " << std::to_string(msg.len)
+ << "\n";
+ }
+
+ type = msg.type;
+ switch (type) {
+ case DM_USER_REQ_MAP_READ:
+ msg.type = DM_USER_RESP_SUCCESS;
+ break;
+ case DM_USER_REQ_MAP_WRITE:
+ if (msg.flags & DM_USER_REQ_MAP_FLAG_PREFLUSH ||
+ msg.flags & DM_USER_REQ_MAP_FLAG_FUA) {
+ if (fsync(backing_fd) < 0) {
+ perror("Unable to fsync(), just sync()ing instead");
+ sync();
+ }
+ }
+ msg.type = DM_USER_RESP_SUCCESS;
+ if (lseek64(backing_fd, msg.sector * SECTOR_SIZE, SEEK_SET) < 0) {
+ perror("Unable to seek");
+ return -1;
+ }
+ if (not_splice(control_fd, backing_fd, msg.len) < 0) {
+ if (errno == ENOTBLK) return 0;
+ std::cerr << "unable to handle write data\n";
+ return -1;
+ }
+ if (msg.flags & DM_USER_REQ_MAP_FLAG_FUA) {
+ if (fsync(backing_fd) < 0) {
+ perror("Unable to fsync(), just sync()ing instead");
+ sync();
+ }
+ }
+ break;
+ case DM_USER_REQ_MAP_FLUSH:
+ msg.type = DM_USER_RESP_SUCCESS;
+ if (fsync(backing_fd) < 0) {
+ perror("Unable to fsync(), just sync()ing instead");
+ sync();
+ }
+ break;
+ default:
+ std::cerr << "dmuserd: unsupported op " << std::to_string(msg.type) << "\n";
+ msg.type = DM_USER_RESP_UNSUPPORTED;
+ break;
+ }
+
+ if (verbose) std::cerr << "dmuserd: Responding to message\n";
+
+ if (write_all(control_fd, &msg, sizeof(msg)) < 0) {
+ if (errno == ENOTBLK) return 0;
+ perror("unable to write msg");
+ return -1;
+ }
+
+ switch (type) {
+ case DM_USER_REQ_MAP_READ:
+ if (verbose) std::cerr << "dmuserd: Sending read data\n";
+ if (lseek64(backing_fd, msg.sector * SECTOR_SIZE, SEEK_SET) < 0) {
+ perror("Unable to seek");
+ return -1;
+ }
+ if (not_splice(backing_fd, control_fd, msg.len) < 0) {
+ if (errno == ENOTBLK) return 0;
+ std::cerr << "unable to handle read data\n";
+ return -1;
+ }
+ break;
+ }
+ }
+
+ /* The daemon doesn't actully terminate for this test. */
+ perror("Unable to read from control device");
+ return -1;
+}
+
+void usage(char* prog) {
+ printf("Usage: %s\n", prog);
+ printf(" Handles block requests in userspace, backed by memory\n");
+ printf(" -h Display this help message\n");
+ printf(" -c <control dev> Control device to use for the test\n");
+ printf(" -b <store path> The file to use as a backing store, otherwise memory\n");
+ printf(" -v Enable verbose mode\n");
+}
+
+int main(int argc, char* argv[]) {
+ char* control_path = NULL;
+ char* backing_path = NULL;
+ char* store;
+ int c;
+
+ prctl(PR_SET_IO_FLUSHER, 0, 0, 0, 0);
+
+ while ((c = getopt(argc, argv, "h:c:s:b:v")) != -1) {
+ switch (c) {
+ case 'h':
+ usage(basename(argv[0]));
+ exit(0);
+ case 'c':
+ control_path = strdup(optarg);
+ break;
+ case 'b':
+ backing_path = strdup(optarg);
+ break;
+ case 'v':
+ verbose = true;
+ break;
+ default:
+ usage(basename(argv[0]));
+ exit(1);
+ }
+ }
+
+ int r = simple_daemon(control_path, backing_path);
+ if (r) fprintf(stderr, "simple_daemon() errored out\n");
+ return r;
+}
diff --git a/init/Android.mk b/init/Android.mk
index ac31ef1..4c1665b 100644
--- a/init/Android.mk
+++ b/init/Android.mk
@@ -82,6 +82,7 @@
$(TARGET_RAMDISK_OUT)/proc \
$(TARGET_RAMDISK_OUT)/second_stage_resources \
$(TARGET_RAMDISK_OUT)/sys \
+ $(TARGET_RAMDISK_OUT)/metadata \
LOCAL_STATIC_LIBRARIES := \
libc++fs \
diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index c4c8768..2bceb75 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -69,7 +69,7 @@
EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS :=
ifeq ($(CLANG_COVERAGE),true)
- EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS := export LLVM_PROFILE_FILE /data/misc/trace/clang-%20m.profraw
+ EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS := export LLVM_PROFILE_FILE /data/misc/trace/clang-%p-%m.profraw
endif
# Put it here instead of in init.rc module definition,
diff --git a/rootdir/init.rc b/rootdir/init.rc
index fbb48e8..4219e32 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -808,6 +808,10 @@
wait_for_prop apexd.status activated
perform_apex_config
+ # After apexes are mounted, tell keymaster early boot has ended, so it will
+ # stop allowing use of early-boot keys
+ exec - system system -- /system/bin/vdc keymaster early-boot-ended
+
# Special-case /data/media/obb per b/64566063
mkdir /data/media 0770 media_rw media_rw encryption=None
exec - media_rw media_rw -- /system/bin/chattr +F /data/media
diff --git a/trusty/libtrusty/trusty.c b/trusty/libtrusty/trusty.c
index ad4d8cd..f44f8b4 100644
--- a/trusty/libtrusty/trusty.c
+++ b/trusty/libtrusty/trusty.c
@@ -29,30 +29,27 @@
#include <trusty/ipc.h>
-int tipc_connect(const char *dev_name, const char *srv_name)
-{
- int fd;
- int rc;
+int tipc_connect(const char* dev_name, const char* srv_name) {
+ int fd;
+ int rc;
- fd = open(dev_name, O_RDWR);
- if (fd < 0) {
- rc = -errno;
- ALOGE("%s: cannot open tipc device \"%s\": %s\n",
- __func__, dev_name, strerror(errno));
- return rc < 0 ? rc : -1;
- }
+ fd = TEMP_FAILURE_RETRY(open(dev_name, O_RDWR));
+ if (fd < 0) {
+ rc = -errno;
+ ALOGE("%s: cannot open tipc device \"%s\": %s\n", __func__, dev_name, strerror(errno));
+ return rc < 0 ? rc : -1;
+ }
- rc = ioctl(fd, TIPC_IOC_CONNECT, srv_name);
- if (rc < 0) {
- rc = -errno;
- ALOGE("%s: can't connect to tipc service \"%s\" (err=%d)\n",
- __func__, srv_name, errno);
- close(fd);
- return rc < 0 ? rc : -1;
- }
+ rc = TEMP_FAILURE_RETRY(ioctl(fd, TIPC_IOC_CONNECT, srv_name));
+ if (rc < 0) {
+ rc = -errno;
+ ALOGE("%s: can't connect to tipc service \"%s\" (err=%d)\n", __func__, srv_name, errno);
+ close(fd);
+ return rc < 0 ? rc : -1;
+ }
- ALOGV("%s: connected to \"%s\" fd %d\n", __func__, srv_name, fd);
- return fd;
+ ALOGV("%s: connected to \"%s\" fd %d\n", __func__, srv_name, fd);
+ return fd;
}
ssize_t tipc_send(int fd, const struct iovec* iov, int iovcnt, struct trusty_shm* shms,
@@ -63,7 +60,7 @@
req.shm = (__u64)shms;
req.shm_cnt = (__u64)shmcnt;
- int rc = ioctl(fd, TIPC_IOC_SEND_MSG, &req);
+ int rc = TEMP_FAILURE_RETRY(ioctl(fd, TIPC_IOC_SEND_MSG, &req));
if (rc < 0) {
ALOGE("%s: failed to send message (err=%d)\n", __func__, rc);
}
@@ -71,7 +68,6 @@
return rc;
}
-void tipc_close(int fd)
-{
- close(fd);
+void tipc_close(int fd) {
+ close(fd);
}