Merge "Ignore expansion-to-defined warning from dlmalloc include"
diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 60ce452..d1eabab 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -91,6 +91,8 @@
using android::fs_mgr::AvbHashtreeResult;
using android::fs_mgr::AvbUniquePtr;
+using namespace std::literals;
+
// record fs stat
enum FsStatFlags {
FS_STAT_IS_EXT4 = 0x0001,
@@ -131,10 +133,10 @@
}
}
-static void log_fs_stat(const char* blk_device, int fs_stat)
-{
+static void log_fs_stat(const std::string& blk_device, int fs_stat) {
if ((fs_stat & FS_STAT_IS_EXT4) == 0) return; // only log ext4
- std::string msg = android::base::StringPrintf("\nfs_stat,%s,0x%x\n", blk_device, fs_stat);
+ std::string msg =
+ android::base::StringPrintf("\nfs_stat,%s,0x%x\n", blk_device.c_str(), fs_stat);
android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(FSCK_LOG_FILE, O_WRONLY | O_CLOEXEC |
O_APPEND | O_CREAT, 0664)));
if (fd == -1 || !android::base::WriteStringToFd(msg, fd)) {
@@ -150,7 +152,7 @@
return fs_type == "f2fs";
}
-static std::string realpath(const char* blk_device) {
+static std::string realpath(const std::string& blk_device) {
std::string real_path;
if (!Realpath(blk_device, &real_path)) {
real_path = blk_device;
@@ -166,14 +168,14 @@
FS_STAT_SET_RESERVED_BLOCKS_FAILED | FS_STAT_ENABLE_ENCRYPTION_FAILED);
}
-static void check_fs(const char *blk_device, char *fs_type, char *target, int *fs_stat)
-{
+static void check_fs(const std::string& blk_device, const std::string& fs_type,
+ const std::string& target, int* fs_stat) {
int status;
int ret;
long tmpmnt_flags = MS_NOATIME | MS_NOEXEC | MS_NOSUID;
- char tmpmnt_opts[64] = "errors=remount-ro";
- const char* e2fsck_argv[] = {E2FSCK_BIN, "-y", blk_device};
- const char* e2fsck_forced_argv[] = {E2FSCK_BIN, "-f", "-y", blk_device};
+ auto tmpmnt_opts = "errors=remount-ro"s;
+ const char* e2fsck_argv[] = {E2FSCK_BIN, "-y", blk_device.c_str()};
+ const char* e2fsck_forced_argv[] = {E2FSCK_BIN, "-f", "-y", blk_device.c_str()};
if (*fs_stat & FS_STAT_INVALID_MAGIC) { // will fail, so do not try
return;
@@ -196,18 +198,19 @@
*/
if (!(*fs_stat & FS_STAT_FULL_MOUNT_FAILED)) { // already tried if full mount failed
errno = 0;
- if (!strcmp(fs_type, "ext4")) {
+ if (fs_type == "ext4") {
// This option is only valid with ext4
- strlcat(tmpmnt_opts, ",nomblk_io_submit", sizeof(tmpmnt_opts));
+ tmpmnt_opts += ",nomblk_io_submit";
}
- ret = mount(blk_device, target, fs_type, tmpmnt_flags, tmpmnt_opts);
+ ret = mount(blk_device.c_str(), target.c_str(), fs_type.c_str(), tmpmnt_flags,
+ tmpmnt_opts.c_str());
PINFO << __FUNCTION__ << "(): mount(" << blk_device << "," << target << "," << fs_type
<< ")=" << ret;
if (!ret) {
bool umounted = false;
int retry_count = 5;
while (retry_count-- > 0) {
- umounted = umount(target) == 0;
+ umounted = umount(target.c_str()) == 0;
if (umounted) {
LINFO << __FUNCTION__ << "(): unmount(" << target << ") succeeded";
break;
@@ -254,7 +257,7 @@
}
}
} else if (is_f2fs(fs_type)) {
- const char* f2fs_fsck_argv[] = {F2FS_FSCK_BIN, "-a", blk_device};
+ const char* f2fs_fsck_argv[] = {F2FS_FSCK_BIN, "-a", blk_device.c_str()};
LINFO << "Running " << F2FS_FSCK_BIN << " -a " << realpath(blk_device);
ret = android_fork_execvp_ext(ARRAY_SIZE(f2fs_fsck_argv),
@@ -290,8 +293,9 @@
// Read the primary superblock from an ext4 filesystem. On failure return
// false. If it's not an ext4 filesystem, also set FS_STAT_INVALID_MAGIC.
-static bool read_ext4_superblock(const char* blk_device, struct ext4_super_block* sb, int* fs_stat) {
- android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(blk_device, O_RDONLY | O_CLOEXEC)));
+static bool read_ext4_superblock(const std::string& blk_device, struct ext4_super_block* sb,
+ int* fs_stat) {
+ android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(blk_device.c_str(), O_RDONLY | O_CLOEXEC)));
if (fd < 0) {
PERROR << "Failed to open '" << blk_device << "'";
@@ -332,7 +336,7 @@
}
// Enable/disable quota support on the filesystem if needed.
-static void tune_quota(const char* blk_device, const struct fstab_rec* rec,
+static void tune_quota(const std::string& blk_device, const struct fstab_rec* rec,
const struct ext4_super_block* sb, int* fs_stat) {
bool has_quota = (sb->s_feature_ro_compat & cpu_to_le32(EXT4_FEATURE_RO_COMPAT_QUOTA)) != 0;
bool want_quota = fs_mgr_is_quota(rec) != 0;
@@ -347,7 +351,7 @@
return;
}
- const char* argv[] = {TUNE2FS_BIN, nullptr, nullptr, blk_device};
+ const char* argv[] = {TUNE2FS_BIN, nullptr, nullptr, blk_device.c_str()};
if (want_quota) {
LINFO << "Enabling quotas on " << blk_device;
@@ -368,7 +372,7 @@
}
// Set the number of reserved filesystem blocks if needed.
-static void tune_reserved_size(const char* blk_device, const struct fstab_rec* rec,
+static void tune_reserved_size(const std::string& blk_device, const struct fstab_rec* rec,
const struct ext4_super_block* sb, int* fs_stat) {
if (!(rec->fs_mgr_flags & MF_RESERVEDSIZE)) {
return;
@@ -400,7 +404,8 @@
auto reserved_blocks_str = std::to_string(reserved_blocks);
auto reserved_gid_str = std::to_string(AID_RESERVED_DISK);
const char* argv[] = {
- TUNE2FS_BIN, "-r", reserved_blocks_str.c_str(), "-g", reserved_gid_str.c_str(), blk_device};
+ TUNE2FS_BIN, "-r", reserved_blocks_str.c_str(), "-g", reserved_gid_str.c_str(),
+ blk_device.c_str()};
if (!run_tune2fs(argv, ARRAY_SIZE(argv))) {
LERROR << "Failed to run " TUNE2FS_BIN " to set the number of reserved blocks on "
<< blk_device;
@@ -409,7 +414,7 @@
}
// Enable file-based encryption if needed.
-static void tune_encrypt(const char* blk_device, const struct fstab_rec* rec,
+static void tune_encrypt(const std::string& blk_device, const struct fstab_rec* rec,
const struct ext4_super_block* sb, int* fs_stat) {
bool has_encrypt = (sb->s_feature_incompat & cpu_to_le32(EXT4_FEATURE_INCOMPAT_ENCRYPT)) != 0;
bool want_encrypt = fs_mgr_is_file_encrypted(rec) != 0;
@@ -424,7 +429,7 @@
return;
}
- const char* argv[] = {TUNE2FS_BIN, "-Oencrypt", blk_device};
+ const char* argv[] = {TUNE2FS_BIN, "-Oencrypt", blk_device.c_str()};
LINFO << "Enabling ext4 encryption on " << blk_device;
if (!run_tune2fs(argv, ARRAY_SIZE(argv))) {
@@ -438,8 +443,8 @@
// false. If it's not an f2fs filesystem, also set FS_STAT_INVALID_MAGIC.
#define F2FS_BLKSIZE 4096
#define F2FS_SUPER_OFFSET 1024
-static bool read_f2fs_superblock(const char* blk_device, int* fs_stat) {
- android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(blk_device, O_RDONLY | O_CLOEXEC)));
+static bool read_f2fs_superblock(const std::string& blk_device, int* fs_stat) {
+ android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(blk_device.c_str(), O_RDONLY | O_CLOEXEC)));
__le32 sb1, sb2;
if (fd < 0) {
@@ -473,7 +478,7 @@
// If needed, we'll also enable (or disable) filesystem features as specified by
// the fstab record.
//
-static int prepare_fs_for_mount(const char* blk_device, const struct fstab_rec* rec) {
+static int prepare_fs_for_mount(const std::string& blk_device, const struct fstab_rec* rec) {
int fs_stat = 0;
if (is_extfs(rec->fs_type)) {
@@ -516,17 +521,6 @@
return fs_stat;
}
-static void remove_trailing_slashes(char *n)
-{
- int len;
-
- len = strlen(n) - 1;
- while ((*(n + len) == '/') && len) {
- *(n + len) = '\0';
- len--;
- }
-}
-
// Mark the given block device as read-only, using the BLKROSET ioctl.
bool fs_mgr_set_blk_ro(const std::string& blockdev) {
unique_fd fd(TEMP_FAILURE_RETRY(open(blockdev.c_str(), O_RDONLY | O_CLOEXEC)));
@@ -548,34 +542,28 @@
return false;
}
-/*
- * __mount(): wrapper around the mount() system call which also
- * sets the underlying block device to read-only if the mount is read-only.
- * See "man 2 mount" for return values.
- */
-static int __mount(const char *source, const char *target, const struct fstab_rec *rec)
-{
- unsigned long mountflags = rec->flags;
- int ret;
- int save_errno;
-
- /* We need this because sometimes we have legacy symlinks
- * that are lingering around and need cleaning up.
- */
+// __mount(): wrapper around the mount() system call which also
+// sets the underlying block device to read-only if the mount is read-only.
+// See "man 2 mount" for return values.
+static int __mount(const std::string& source, const std::string& target,
+ const struct fstab_rec* rec) {
+ // We need this because sometimes we have legacy symlinks that are
+ // lingering around and need cleaning up.
struct stat info;
- if (!lstat(target, &info))
- if ((info.st_mode & S_IFMT) == S_IFLNK)
- unlink(target);
- mkdir(target, 0755);
+ if (lstat(target.c_str(), &info) == 0 && (info.st_mode & S_IFMT) == S_IFLNK) {
+ unlink(target.c_str());
+ }
+ mkdir(target.c_str(), 0755);
errno = 0;
- ret = mount(source, target, rec->fs_type, mountflags, rec->fs_options);
- save_errno = errno;
+ unsigned long mountflags = rec->flags;
+ int ret = mount(source.c_str(), target.c_str(), rec->fs_type, mountflags, rec->fs_options);
+ int save_errno = errno;
const char* target_missing = "";
const char* source_missing = "";
if (save_errno == ENOENT) {
- if (access(target, F_OK)) {
+ if (access(target.c_str(), F_OK)) {
target_missing = "(missing)";
- } else if (access(source, F_OK)) {
+ } else if (access(source.c_str(), F_OK)) {
source_missing = "(missing)";
}
errno = save_errno;
@@ -589,24 +577,32 @@
return ret;
}
-static int fs_match(const char *in1, const char *in2)
-{
- char *n1;
- char *n2;
- int ret;
+static bool fs_match(const std::string& in1, const std::string& in2) {
+ if (in1.empty() || in2.empty()) {
+ return false;
+ }
- n1 = strdup(in1);
- n2 = strdup(in2);
+ auto in1_end = in1.size() - 1;
+ while (in1_end > 0 && in1[in1_end] == '/') {
+ in1_end--;
+ }
- remove_trailing_slashes(n1);
- remove_trailing_slashes(n2);
+ auto in2_end = in2.size() - 1;
+ while (in2_end > 0 && in2[in2_end] == '/') {
+ in2_end--;
+ }
- ret = !strcmp(n1, n2);
+ if (in1_end != in2_end) {
+ return false;
+ }
- free(n1);
- free(n2);
+ for (size_t i = 0; i <= in1_end; ++i) {
+ if (in1[i] != in2[i]) {
+ return false;
+ }
+ }
- return ret;
+ return true;
}
/*
@@ -746,17 +742,12 @@
}
if (label == super_block.s_volume_name) {
- char* new_blk_device;
-
- if (asprintf(&new_blk_device, "/dev/block/%s", ent->d_name) < 0) {
- LERROR << "Could not allocate block device string";
- return false;
- }
+ std::string new_blk_device = "/dev/block/"s + ent->d_name;
LINFO << "resolved label " << rec->blk_device << " to " << new_blk_device;
free(rec->blk_device);
- rec->blk_device = new_blk_device;
+ rec->blk_device = strdup(new_blk_device.c_str());
return true;
}
}
@@ -771,18 +762,14 @@
return true;
if (rec->fs_mgr_flags & MF_FORCECRYPT) return true;
if (rec->fs_mgr_flags & MF_CRYPT) {
- /* Check for existence of convert_fde breadcrumb file */
- char convert_fde_name[PATH_MAX];
- snprintf(convert_fde_name, sizeof(convert_fde_name),
- "%s/misc/vold/convert_fde", rec->mount_point);
- if (access(convert_fde_name, F_OK) == 0) return true;
+ // Check for existence of convert_fde breadcrumb file.
+ auto convert_fde_name = rec->mount_point + "/misc/vold/convert_fde"s;
+ if (access(convert_fde_name.c_str(), F_OK) == 0) return true;
}
if (rec->fs_mgr_flags & MF_FORCEFDEORFBE) {
- /* Check for absence of convert_fbe breadcrumb file */
- char convert_fbe_name[PATH_MAX];
- snprintf(convert_fbe_name, sizeof(convert_fbe_name),
- "%s/convert_fbe", rec->mount_point);
- if (access(convert_fbe_name, F_OK) != 0) return true;
+ // Check for absence of convert_fbe breadcrumb file.
+ auto convert_fbe_name = rec->mount_point + "/convert_fbe"s;
+ if (access(convert_fbe_name.c_str(), F_OK) != 0) return true;
}
return false;
}
@@ -1533,7 +1520,8 @@
return true;
}
-bool fs_mgr_update_verity_state(std::function<fs_mgr_verity_state_callback> callback) {
+bool fs_mgr_update_verity_state(
+ std::function<void(const std::string& mount_point, int mode)> callback) {
if (!callback) {
return false;
}
@@ -1543,27 +1531,25 @@
return false;
}
- std::unique_ptr<fstab, decltype(&fs_mgr_free_fstab)> fstab(fs_mgr_read_fstab_default(),
- fs_mgr_free_fstab);
- if (!fstab) {
+ Fstab fstab;
+ if (!ReadDefaultFstab(&fstab)) {
LERROR << "Failed to read default fstab";
return false;
}
DeviceMapper& dm = DeviceMapper::Instance();
- for (int i = 0; i < fstab->num_entries; i++) {
- auto fsrec = &fstab->recs[i];
- if (!fs_mgr_is_verified(fsrec) && !fs_mgr_is_avb(fsrec)) {
+ for (const auto& entry : fstab) {
+ if (!entry.fs_mgr_flags.verify && !entry.fs_mgr_flags.avb) {
continue;
}
std::string mount_point;
- if (!strcmp(fsrec->mount_point, "/")) {
+ if (entry.mount_point == "/") {
// In AVB, the dm device name is vroot instead of system.
- mount_point = fs_mgr_is_avb(fsrec) ? "vroot" : "system";
+ mount_point = entry.fs_mgr_flags.avb ? "vroot" : "system";
} else {
- mount_point = basename(fsrec->mount_point);
+ mount_point = basename(entry.mount_point.c_str());
}
if (dm.GetState(mount_point) == DmDeviceState::INVALID) {
@@ -1574,7 +1560,7 @@
const char* status;
std::vector<DeviceMapper::TargetInfo> table;
if (!dm.GetTableStatus(mount_point, &table) || table.empty() || table[0].data.empty()) {
- if (!fs_mgr_is_verifyatboot(fsrec)) {
+ if (!entry.fs_mgr_flags.verify_at_boot) {
PERROR << "Failed to query DM_TABLE_STATUS for " << mount_point;
continue;
}
@@ -1588,7 +1574,7 @@
// instead of [partition.vroot.verified].
if (mount_point == "vroot") mount_point = "system";
if (*status == 'C' || *status == 'V') {
- callback(fsrec, mount_point.c_str(), mode, *status);
+ callback(mount_point, mode);
}
}
diff --git a/fs_mgr/fs_mgr_format.cpp b/fs_mgr/fs_mgr_format.cpp
index 0983663..737deca 100644
--- a/fs_mgr/fs_mgr_format.cpp
+++ b/fs_mgr/fs_mgr_format.cpp
@@ -24,6 +24,7 @@
#include <cutils/partition_utils.h>
#include <sys/mount.h>
+#include <android-base/unique_fd.h>
#include <ext4_utils/ext4.h>
#include <ext4_utils/ext4_utils.h>
#include <logwrap/logwrap.h>
@@ -34,30 +35,28 @@
#include "fs_mgr_priv.h"
#include "cryptfs.h"
-static int get_dev_sz(char *fs_blkdev, uint64_t *dev_sz)
-{
- int fd;
+using android::base::unique_fd;
- if ((fd = open(fs_blkdev, O_RDONLY)) < 0) {
+static int get_dev_sz(const std::string& fs_blkdev, uint64_t* dev_sz) {
+ unique_fd fd(TEMP_FAILURE_RETRY(open(fs_blkdev.c_str(), O_RDONLY | O_CLOEXEC)));
+
+ if (fd < 0) {
PERROR << "Cannot open block device";
return -1;
}
if ((ioctl(fd, BLKGETSIZE64, dev_sz)) == -1) {
PERROR << "Cannot get block device size";
- close(fd);
return -1;
}
- close(fd);
return 0;
}
-static int format_ext4(char *fs_blkdev, char *fs_mnt_point, bool crypt_footer)
-{
+static int format_ext4(const std::string& fs_blkdev, const std::string& fs_mnt_point,
+ bool crypt_footer) {
uint64_t dev_sz;
int rc = 0;
- int status;
rc = get_dev_sz(fs_blkdev, &dev_sz);
if (rc) {
@@ -71,7 +70,8 @@
std::string size_str = std::to_string(dev_sz / 4096);
const char* const mke2fs_args[] = {
- "/system/bin/mke2fs", "-t", "ext4", "-b", "4096", fs_blkdev, size_str.c_str(), nullptr};
+ "/system/bin/mke2fs", "-t", "ext4", "-b", "4096", fs_blkdev.c_str(),
+ size_str.c_str(), nullptr};
rc = android_fork_execvp_ext(arraysize(mke2fs_args), const_cast<char**>(mke2fs_args), NULL,
true, LOG_KLOG, true, nullptr, nullptr, 0);
@@ -81,12 +81,7 @@
}
const char* const e2fsdroid_args[] = {
- "/system/bin/e2fsdroid",
- "-e",
- "-a",
- fs_mnt_point,
- fs_blkdev,
- nullptr};
+ "/system/bin/e2fsdroid", "-e", "-a", fs_mnt_point.c_str(), fs_blkdev.c_str(), nullptr};
rc = android_fork_execvp_ext(arraysize(e2fsdroid_args), const_cast<char**>(e2fsdroid_args),
NULL, true, LOG_KLOG, true, nullptr, nullptr, 0);
@@ -97,10 +92,7 @@
return rc;
}
-static int format_f2fs(char *fs_blkdev, uint64_t dev_sz, bool crypt_footer)
-{
- int status;
-
+static int format_f2fs(const std::string& fs_blkdev, uint64_t dev_sz, bool crypt_footer) {
if (!dev_sz) {
int rc = get_dev_sz(fs_blkdev, &dev_sz);
if (rc) {
@@ -118,7 +110,7 @@
const char* const args[] = {
"/system/bin/make_f2fs",
"-g", "android",
- fs_blkdev,
+ fs_blkdev.c_str(),
size_str.c_str(),
nullptr
};
diff --git a/fs_mgr/fs_mgr_overlayfs.cpp b/fs_mgr/fs_mgr_overlayfs.cpp
index 649c8bf..d2d8dc1 100644
--- a/fs_mgr/fs_mgr_overlayfs.cpp
+++ b/fs_mgr/fs_mgr_overlayfs.cpp
@@ -277,9 +277,8 @@
std::vector<std::string> fs_mgr_overlayfs_verity_enabled_list() {
std::vector<std::string> ret;
- fs_mgr_update_verity_state([&ret](fstab_rec*, const char* mount_point, int, int) {
- ret.emplace_back(mount_point);
- });
+ fs_mgr_update_verity_state(
+ [&ret](const std::string& mount_point, int) { ret.emplace_back(mount_point); });
return ret;
}
diff --git a/fs_mgr/include/fs_mgr.h b/fs_mgr/include/fs_mgr.h
index 80f97fc..c1dc731 100644
--- a/fs_mgr/include/fs_mgr.h
+++ b/fs_mgr/include/fs_mgr.h
@@ -50,10 +50,6 @@
MOUNT_MODE_LATE = 2
};
-// Callback function for verity status
-typedef void fs_mgr_verity_state_callback(fstab_rec* fstab, const char* mount_point, int mode,
- int status);
-
#define FS_MGR_MNTALL_DEV_IS_METADATA_ENCRYPTED 7
#define FS_MGR_MNTALL_DEV_NEEDS_METADATA_ENCRYPTION 6
#define FS_MGR_MNTALL_DEV_FILE_ENCRYPTED 5
@@ -77,7 +73,8 @@
fstab_rec const* fs_mgr_get_crypt_entry(fstab const* fstab);
void fs_mgr_get_crypt_info(fstab* fstab, char* key_loc, char* real_blk_device, size_t size);
bool fs_mgr_load_verity_state(int* mode);
-bool fs_mgr_update_verity_state(std::function<fs_mgr_verity_state_callback> callback);
+bool fs_mgr_update_verity_state(
+ std::function<void(const std::string& mount_point, int mode)> callback);
bool fs_mgr_swapon_all(const Fstab& fstab);
bool fs_mgr_update_logical_partition(struct fstab_rec* rec);
diff --git a/fs_mgr/liblp/builder.cpp b/fs_mgr/liblp/builder.cpp
index 699b9e7..07f9d66 100644
--- a/fs_mgr/liblp/builder.cpp
+++ b/fs_mgr/liblp/builder.cpp
@@ -606,14 +606,23 @@
}
uint64_t sectors = std::min(sectors_needed, region.length());
+ if (sectors < region.length()) {
+ const auto& block_device = block_devices_[region.device_index];
+ if (block_device.alignment) {
+ const uint64_t alignment = block_device.alignment / LP_SECTOR_SIZE;
+ sectors = AlignTo(sectors, alignment);
+ sectors = std::min(sectors, region.length());
+ }
+ }
CHECK(sectors % sectors_per_block == 0);
auto extent = std::make_unique<LinearExtent>(sectors, region.device_index, region.start);
new_extents.push_back(std::move(extent));
- sectors_needed -= sectors;
- if (!sectors_needed) {
+ if (sectors >= sectors_needed) {
+ sectors_needed = 0;
break;
}
+ sectors_needed -= sectors;
}
if (sectors_needed) {
LERROR << "Not enough free space to expand partition: " << partition->name();
diff --git a/fs_mgr/liblp/builder_test.cpp b/fs_mgr/liblp/builder_test.cpp
index 7833a25..3793964 100644
--- a/fs_mgr/liblp/builder_test.cpp
+++ b/fs_mgr/liblp/builder_test.cpp
@@ -209,8 +209,8 @@
ASSERT_TRUE(builder->ResizePartition(a, a->size() + 4096));
ASSERT_TRUE(builder->ResizePartition(b, b->size() + 4096));
}
- EXPECT_EQ(a->size(), 40960);
- EXPECT_EQ(b->size(), 40960);
+ EXPECT_EQ(a->size(), 7864320);
+ EXPECT_EQ(b->size(), 7864320);
unique_ptr<LpMetadata> exported = builder->Export();
ASSERT_NE(exported, nullptr);
@@ -218,7 +218,7 @@
// Check that each starting sector is aligned.
for (const auto& extent : exported->extents) {
ASSERT_EQ(extent.target_type, LP_TARGET_TYPE_LINEAR);
- EXPECT_EQ(extent.num_sectors, 8);
+ EXPECT_EQ(extent.num_sectors, 1536);
uint64_t lba = extent.target_data * LP_SECTOR_SIZE;
uint64_t aligned_lba = AlignTo(lba, device_info.alignment, device_info.alignment_offset);
@@ -645,7 +645,7 @@
EXPECT_EQ(metadata->extents[1].target_type, LP_TARGET_TYPE_LINEAR);
EXPECT_EQ(metadata->extents[1].target_data, 1472);
EXPECT_EQ(metadata->extents[1].target_source, 1);
- EXPECT_EQ(metadata->extents[2].num_sectors, 129088);
+ EXPECT_EQ(metadata->extents[2].num_sectors, 129600);
EXPECT_EQ(metadata->extents[2].target_type, LP_TARGET_TYPE_LINEAR);
EXPECT_EQ(metadata->extents[2].target_data, 1472);
EXPECT_EQ(metadata->extents[2].target_source, 2);
@@ -744,17 +744,41 @@
EXPECT_EQ(system_a->extents().size(), static_cast<size_t>(1));
EXPECT_EQ(system_b->extents().size(), static_cast<size_t>(1));
ASSERT_TRUE(builder->ResizePartition(system_b, 6_GiB));
- EXPECT_EQ(system_b->extents().size(), static_cast<size_t>(3));
+ EXPECT_EQ(system_b->extents().size(), static_cast<size_t>(2));
unique_ptr<LpMetadata> exported = builder->Export();
ASSERT_NE(exported, nullptr);
- ASSERT_EQ(exported->extents.size(), static_cast<size_t>(4));
+ ASSERT_EQ(exported->extents.size(), static_cast<size_t>(3));
EXPECT_EQ(exported->extents[0].target_data, 10487808);
- EXPECT_EQ(exported->extents[0].num_sectors, 4194304);
- EXPECT_EQ(exported->extents[1].target_data, 14682624);
- EXPECT_EQ(exported->extents[1].num_sectors, 6288896);
- EXPECT_EQ(exported->extents[2].target_data, 6292992);
- EXPECT_EQ(exported->extents[2].num_sectors, 2099712);
- EXPECT_EQ(exported->extents[3].target_data, 1536);
- EXPECT_EQ(exported->extents[3].num_sectors, 6291456);
+ EXPECT_EQ(exported->extents[0].num_sectors, 10483712);
+ EXPECT_EQ(exported->extents[1].target_data, 6292992);
+ EXPECT_EQ(exported->extents[1].num_sectors, 2099712);
+ EXPECT_EQ(exported->extents[2].target_data, 1536);
+ EXPECT_EQ(exported->extents[2].num_sectors, 6291456);
+}
+
+TEST_F(BuilderTest, PartialExtents) {
+ // super has a minimum extent size of 768KiB.
+ BlockDeviceInfo device_info("super", 1_GiB, 768 * 1024, 0, 4096);
+ auto builder = MetadataBuilder::New(device_info, 65536, 1);
+ ASSERT_NE(builder, nullptr);
+ Partition* system = builder->AddPartition("system", 0);
+ ASSERT_NE(system, nullptr);
+ Partition* vendor = builder->AddPartition("vendor", 0);
+ ASSERT_NE(vendor, nullptr);
+ ASSERT_TRUE(builder->ResizePartition(system, device_info.alignment + 4096));
+ ASSERT_TRUE(builder->ResizePartition(vendor, device_info.alignment));
+ ASSERT_EQ(system->size(), device_info.alignment * 2);
+ ASSERT_EQ(vendor->size(), device_info.alignment);
+
+ ASSERT_TRUE(builder->ResizePartition(system, device_info.alignment * 2));
+ ASSERT_EQ(system->extents().size(), static_cast<size_t>(1));
+
+ unique_ptr<LpMetadata> exported = builder->Export();
+ ASSERT_NE(exported, nullptr);
+ ASSERT_EQ(exported->extents.size(), static_cast<size_t>(2));
+ EXPECT_EQ(exported->extents[0].target_data, 1536);
+ EXPECT_EQ(exported->extents[0].num_sectors, 3072);
+ EXPECT_EQ(exported->extents[1].target_data, 4608);
+ EXPECT_EQ(exported->extents[1].num_sectors, 1536);
}
diff --git a/init/builtins.cpp b/init/builtins.cpp
index b382126..2bebe76 100644
--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -734,13 +734,10 @@
return Success();
}
-static void verity_update_property(fstab_rec *fstab, const char *mount_point,
- int mode, int status) {
- property_set("partition."s + mount_point + ".verified", std::to_string(mode));
-}
-
static Result<Success> do_verity_update_state(const BuiltinArguments& args) {
- if (!fs_mgr_update_verity_state(verity_update_property)) {
+ if (!fs_mgr_update_verity_state([](const std::string& mount_point, int mode) {
+ property_set("partition." + mount_point + ".verified", std::to_string(mode));
+ })) {
return Error() << "fs_mgr_update_verity_state() failed";
}
return Success();
diff --git a/libmeminfo/include/meminfo/sysmeminfo.h b/libmeminfo/include/meminfo/sysmeminfo.h
index 885be1d..f18ae08 100644
--- a/libmeminfo/include/meminfo/sysmeminfo.h
+++ b/libmeminfo/include/meminfo/sysmeminfo.h
@@ -18,6 +18,7 @@
#include <sys/types.h>
+#include <functional>
#include <map>
#include <string>
#include <vector>
@@ -51,6 +52,9 @@
bool ReadMemInfo(const std::string& path = "/proc/meminfo");
bool ReadMemInfo(const std::vector<std::string>& tags,
const std::string& path = "/proc/meminfo");
+ bool ReadMemInfo(const std::vector<std::string>& tags, std::vector<uint64_t>* out,
+ const std::string& path = "/proc/meminfo");
+ bool ReadMemInfo(std::vector<uint64_t>* out, const std::string& path = "/proc/meminfo");
// getters
uint64_t mem_total_kb() { return mem_in_kb_[kMemTotal]; }
@@ -59,19 +63,21 @@
uint64_t mem_cached_kb() { return mem_in_kb_[kMemCached]; }
uint64_t mem_shmem_kb() { return mem_in_kb_[kMemShmem]; }
uint64_t mem_slab_kb() { return mem_in_kb_[kMemSlab]; }
- uint64_t mem_slab_reclailmable_kb() { return mem_in_kb_[kMemSReclaim]; }
+ uint64_t mem_slab_reclaimable_kb() { return mem_in_kb_[kMemSReclaim]; }
uint64_t mem_slab_unreclaimable_kb() { return mem_in_kb_[kMemSUnreclaim]; }
uint64_t mem_swap_kb() { return mem_in_kb_[kMemSwapTotal]; }
uint64_t mem_swap_free_kb() { return mem_in_kb_[kMemSwapFree]; }
uint64_t mem_mapped_kb() { return mem_in_kb_[kMemMapped]; }
uint64_t mem_vmalloc_used_kb() { return mem_in_kb_[kMemVmallocUsed]; }
uint64_t mem_page_tables_kb() { return mem_in_kb_[kMemPageTables]; }
- uint64_t mem_kernel_stack_kb() { return mem_in_kb_[kMemPageTables]; }
+ uint64_t mem_kernel_stack_kb() { return mem_in_kb_[kMemKernelStack]; }
uint64_t mem_zram_kb(const std::string& zram_dev = "");
private:
std::map<std::string, uint64_t> mem_in_kb_;
bool MemZramDevice(const std::string& zram_dev, uint64_t* mem_zram_dev);
+ bool ReadMemInfo(const std::vector<std::string>& tags, const std::string& path,
+ std::function<void(const std::string&, uint64_t)> store_val);
};
} // namespace meminfo
diff --git a/libmeminfo/libmeminfo_benchmark.cpp b/libmeminfo/libmeminfo_benchmark.cpp
index 1db0824..2660a4d 100644
--- a/libmeminfo/libmeminfo_benchmark.cpp
+++ b/libmeminfo/libmeminfo_benchmark.cpp
@@ -29,6 +29,8 @@
#include <benchmark/benchmark.h>
+using ::android::meminfo::SysMemInfo;
+
enum {
MEMINFO_TOTAL,
MEMINFO_FREE,
@@ -71,8 +73,7 @@
static const char* const tags[] = {
"MemTotal:", "MemFree:", "Buffers:", "Cached:", "Shmem:", "Slab:",
"SReclaimable:", "SUnreclaim:", "SwapTotal:", "SwapFree:", "ZRam:", "Mapped:",
- "VmallocUsed:", "PageTables:", "KernelStack:", NULL
- };
+ "VmallocUsed:", "PageTables:", "KernelStack:", NULL};
static const int tagsLen[] = {9, 8, 8, 7, 6, 5, 13, 11, 10, 9, 5, 7, 12, 11, 12, 0};
@@ -105,7 +106,7 @@
}
}
-static void BM_ParseSysMemInfo(benchmark::State& state) {
+static void BM_ReadMemInfo_old(benchmark::State& state) {
std::string meminfo = R"meminfo(MemTotal: 3019740 kB
MemFree: 1809728 kB
MemAvailable: 2546560 kB
@@ -159,9 +160,9 @@
get_mem_info(mem, tf.path);
}
}
-BENCHMARK(BM_ParseSysMemInfo);
+BENCHMARK(BM_ReadMemInfo_old);
-static void BM_ReadMemInfo(benchmark::State& state) {
+static void BM_ReadMemInfo_new(benchmark::State& state) {
std::string meminfo = R"meminfo(MemTotal: 3019740 kB
MemFree: 1809728 kB
MemAvailable: 2546560 kB
@@ -211,12 +212,21 @@
android::base::WriteStringToFd(meminfo, tf.fd);
std::string file = std::string(tf.path);
- ::android::meminfo::SysMemInfo mi;
+ std::vector<uint64_t> mem(MEMINFO_COUNT);
+ const std::vector<std::string> tags = {
+ SysMemInfo::kMemTotal, SysMemInfo::kMemFree, SysMemInfo::kMemBuffers,
+ SysMemInfo::kMemCached, SysMemInfo::kMemShmem, SysMemInfo::kMemSlab,
+ SysMemInfo::kMemSReclaim, SysMemInfo::kMemSUnreclaim, SysMemInfo::kMemSwapTotal,
+ SysMemInfo::kMemSwapFree, SysMemInfo::kMemMapped, SysMemInfo::kMemVmallocUsed,
+ SysMemInfo::kMemPageTables, SysMemInfo::kMemKernelStack,
+ };
+
+ SysMemInfo smi;
for (auto _ : state) {
- mi.ReadMemInfo(file);
+ smi.ReadMemInfo(tags, &mem, file);
}
}
-BENCHMARK(BM_ReadMemInfo);
+BENCHMARK(BM_ReadMemInfo_new);
static uint64_t get_zram_mem_used(const std::string& zram_dir) {
FILE* f = fopen((zram_dir + "mm_stat").c_str(), "r");
@@ -246,23 +256,145 @@
return 0;
}
-static void BM_OldReadZramTotal(benchmark::State& state) {
+static void BM_ZramTotal_old(benchmark::State& state) {
std::string exec_dir = ::android::base::GetExecutableDirectory();
std::string zram_mmstat_dir = exec_dir + "/testdata1/";
for (auto _ : state) {
uint64_t zram_total __attribute__((unused)) = get_zram_mem_used(zram_mmstat_dir) / 1024;
}
}
-BENCHMARK(BM_OldReadZramTotal);
+BENCHMARK(BM_ZramTotal_old);
-static void BM_NewReadZramTotal(benchmark::State& state) {
+static void BM_ZramTotal_new(benchmark::State& state) {
std::string exec_dir = ::android::base::GetExecutableDirectory();
std::string zram_mmstat_dir = exec_dir + "/testdata1/";
- ::android::meminfo::SysMemInfo mi;
+ SysMemInfo smi;
for (auto _ : state) {
- uint64_t zram_total __attribute__((unused)) = mi.mem_zram_kb(zram_mmstat_dir);
+ uint64_t zram_total __attribute__((unused)) = smi.mem_zram_kb(zram_mmstat_dir);
}
}
-BENCHMARK(BM_NewReadZramTotal);
+BENCHMARK(BM_ZramTotal_new);
+
+static void BM_MemInfoWithZram_old(benchmark::State& state) {
+ std::string meminfo = R"meminfo(MemTotal: 3019740 kB
+MemFree: 1809728 kB
+MemAvailable: 2546560 kB
+Buffers: 54736 kB
+Cached: 776052 kB
+SwapCached: 0 kB
+Active: 445856 kB
+Inactive: 459092 kB
+Active(anon): 78492 kB
+Inactive(anon): 2240 kB
+Active(file): 367364 kB
+Inactive(file): 456852 kB
+Unevictable: 3096 kB
+Mlocked: 3096 kB
+SwapTotal: 0 kB
+SwapFree: 0 kB
+Dirty: 32 kB
+Writeback: 0 kB
+AnonPages: 74988 kB
+Mapped: 62624 kB
+Shmem: 4020 kB
+Slab: 86464 kB
+SReclaimable: 44432 kB
+SUnreclaim: 42032 kB
+KernelStack: 4880 kB
+PageTables: 2900 kB
+NFS_Unstable: 0 kB
+Bounce: 0 kB
+WritebackTmp: 0 kB
+CommitLimit: 1509868 kB
+Committed_AS: 80296 kB
+VmallocTotal: 263061440 kB
+VmallocUsed: 0 kB
+VmallocChunk: 0 kB
+AnonHugePages: 6144 kB
+ShmemHugePages: 0 kB
+ShmemPmdMapped: 0 kB
+CmaTotal: 131072 kB
+CmaFree: 130380 kB
+HugePages_Total: 0
+HugePages_Free: 0
+HugePages_Rsvd: 0
+HugePages_Surp: 0
+Hugepagesize: 2048 kB)meminfo";
+
+ TemporaryFile tf;
+ ::android::base::WriteStringToFd(meminfo, tf.fd);
+ std::string exec_dir = ::android::base::GetExecutableDirectory();
+ std::string zram_mmstat_dir = exec_dir + "/testdata1/";
+ uint64_t mem[MEMINFO_COUNT];
+ for (auto _ : state) {
+ get_mem_info(mem, tf.path);
+ mem[MEMINFO_ZRAM_TOTAL] = get_zram_mem_used("/sys/block/zram0/") / 1024;
+ CHECK_EQ(mem[MEMINFO_KERNEL_STACK], 4880u);
+ }
+}
+BENCHMARK(BM_MemInfoWithZram_old);
+
+static void BM_MemInfoWithZram_new(benchmark::State& state) {
+ std::string meminfo = R"meminfo(MemTotal: 3019740 kB
+MemFree: 1809728 kB
+MemAvailable: 2546560 kB
+Buffers: 54736 kB
+Cached: 776052 kB
+SwapCached: 0 kB
+Active: 445856 kB
+Inactive: 459092 kB
+Active(anon): 78492 kB
+Inactive(anon): 2240 kB
+Active(file): 367364 kB
+Inactive(file): 456852 kB
+Unevictable: 3096 kB
+Mlocked: 3096 kB
+SwapTotal: 0 kB
+SwapFree: 0 kB
+Dirty: 32 kB
+Writeback: 0 kB
+AnonPages: 74988 kB
+Mapped: 62624 kB
+Shmem: 4020 kB
+Slab: 86464 kB
+SReclaimable: 44432 kB
+SUnreclaim: 42032 kB
+KernelStack: 4880 kB
+PageTables: 2900 kB
+NFS_Unstable: 0 kB
+Bounce: 0 kB
+WritebackTmp: 0 kB
+CommitLimit: 1509868 kB
+Committed_AS: 80296 kB
+VmallocTotal: 263061440 kB
+VmallocUsed: 0 kB
+VmallocChunk: 0 kB
+AnonHugePages: 6144 kB
+ShmemHugePages: 0 kB
+ShmemPmdMapped: 0 kB
+CmaTotal: 131072 kB
+CmaFree: 130380 kB
+HugePages_Total: 0
+HugePages_Free: 0
+HugePages_Rsvd: 0
+HugePages_Surp: 0
+Hugepagesize: 2048 kB)meminfo";
+
+ TemporaryFile tf;
+ android::base::WriteStringToFd(meminfo, tf.fd);
+
+ std::string file = std::string(tf.path);
+ std::vector<uint64_t> mem(MEMINFO_COUNT);
+ std::vector<std::string> tags(SysMemInfo::kDefaultSysMemInfoTags);
+ auto it = tags.begin();
+ tags.insert(it + MEMINFO_ZRAM_TOTAL, "Zram:");
+ SysMemInfo smi;
+
+ for (auto _ : state) {
+ smi.ReadMemInfo(tags, &mem, file);
+ CHECK_EQ(mem[MEMINFO_KERNEL_STACK], 4880u);
+ }
+}
+BENCHMARK(BM_MemInfoWithZram_new);
BENCHMARK_MAIN();
diff --git a/libmeminfo/libmeminfo_test.cpp b/libmeminfo/libmeminfo_test.cpp
index b7a4b6b..2856c2d 100644
--- a/libmeminfo/libmeminfo_test.cpp
+++ b/libmeminfo/libmeminfo_test.cpp
@@ -347,8 +347,8 @@
Inactive(file): 456852 kB
Unevictable: 3096 kB
Mlocked: 3096 kB
-SwapTotal: 0 kB
-SwapFree: 0 kB
+SwapTotal: 32768 kB
+SwapFree: 4096 kB
Dirty: 32 kB
Writeback: 0 kB
AnonPages: 74988 kB
@@ -365,7 +365,7 @@
CommitLimit: 1509868 kB
Committed_AS: 80296 kB
VmallocTotal: 263061440 kB
-VmallocUsed: 0 kB
+VmallocUsed: 65536 kB
VmallocChunk: 0 kB
AnonHugePages: 6144 kB
ShmemHugePages: 0 kB
@@ -385,7 +385,19 @@
SysMemInfo mi;
ASSERT_TRUE(mi.ReadMemInfo(tf.path));
EXPECT_EQ(mi.mem_total_kb(), 3019740);
+ EXPECT_EQ(mi.mem_free_kb(), 1809728);
+ EXPECT_EQ(mi.mem_buffers_kb(), 54736);
+ EXPECT_EQ(mi.mem_cached_kb(), 776052);
+ EXPECT_EQ(mi.mem_shmem_kb(), 4020);
+ EXPECT_EQ(mi.mem_slab_kb(), 86464);
+ EXPECT_EQ(mi.mem_slab_reclaimable_kb(), 44432);
+ EXPECT_EQ(mi.mem_slab_unreclaimable_kb(), 42032);
+ EXPECT_EQ(mi.mem_swap_kb(), 32768);
+ EXPECT_EQ(mi.mem_swap_free_kb(), 4096);
+ EXPECT_EQ(mi.mem_mapped_kb(), 62624);
+ EXPECT_EQ(mi.mem_vmalloc_used_kb(), 65536);
EXPECT_EQ(mi.mem_page_tables_kb(), 2900);
+ EXPECT_EQ(mi.mem_kernel_stack_kb(), 4880);
}
TEST(SysMemInfoParser, TestEmptyFile) {
@@ -399,7 +411,7 @@
EXPECT_EQ(mi.mem_total_kb(), 0);
}
-TEST(SysMemInfoParse, TestZramTotal) {
+TEST(SysMemInfoParser, TestZramTotal) {
std::string exec_dir = ::android::base::GetExecutableDirectory();
SysMemInfo mi;
@@ -410,6 +422,100 @@
EXPECT_EQ(mi.mem_zram_kb(zram_memused_dir), 30504);
}
+enum {
+ MEMINFO_TOTAL,
+ MEMINFO_FREE,
+ MEMINFO_BUFFERS,
+ MEMINFO_CACHED,
+ MEMINFO_SHMEM,
+ MEMINFO_SLAB,
+ MEMINFO_SLAB_RECLAIMABLE,
+ MEMINFO_SLAB_UNRECLAIMABLE,
+ MEMINFO_SWAP_TOTAL,
+ MEMINFO_SWAP_FREE,
+ MEMINFO_ZRAM_TOTAL,
+ MEMINFO_MAPPED,
+ MEMINFO_VMALLOC_USED,
+ MEMINFO_PAGE_TABLES,
+ MEMINFO_KERNEL_STACK,
+ MEMINFO_COUNT
+};
+
+TEST(SysMemInfoParser, TestZramWithTags) {
+ std::string meminfo = R"meminfo(MemTotal: 3019740 kB
+MemFree: 1809728 kB
+MemAvailable: 2546560 kB
+Buffers: 54736 kB
+Cached: 776052 kB
+SwapCached: 0 kB
+Active: 445856 kB
+Inactive: 459092 kB
+Active(anon): 78492 kB
+Inactive(anon): 2240 kB
+Active(file): 367364 kB
+Inactive(file): 456852 kB
+Unevictable: 3096 kB
+Mlocked: 3096 kB
+SwapTotal: 32768 kB
+SwapFree: 4096 kB
+Dirty: 32 kB
+Writeback: 0 kB
+AnonPages: 74988 kB
+Mapped: 62624 kB
+Shmem: 4020 kB
+Slab: 86464 kB
+SReclaimable: 44432 kB
+SUnreclaim: 42032 kB
+KernelStack: 4880 kB
+PageTables: 2900 kB
+NFS_Unstable: 0 kB
+Bounce: 0 kB
+WritebackTmp: 0 kB
+CommitLimit: 1509868 kB
+Committed_AS: 80296 kB
+VmallocTotal: 263061440 kB
+VmallocUsed: 65536 kB
+VmallocChunk: 0 kB
+AnonHugePages: 6144 kB
+ShmemHugePages: 0 kB
+ShmemPmdMapped: 0 kB
+CmaTotal: 131072 kB
+CmaFree: 130380 kB
+HugePages_Total: 0
+HugePages_Free: 0
+HugePages_Rsvd: 0
+HugePages_Surp: 0
+Hugepagesize: 2048 kB)meminfo";
+
+ TemporaryFile tf;
+ ASSERT_TRUE(tf.fd != -1);
+ ASSERT_TRUE(::android::base::WriteStringToFd(meminfo, tf.fd));
+ std::string file = std::string(tf.path);
+ std::vector<uint64_t> mem(MEMINFO_COUNT);
+ std::vector<std::string> tags(SysMemInfo::kDefaultSysMemInfoTags);
+ auto it = tags.begin();
+ tags.insert(it + MEMINFO_ZRAM_TOTAL, "Zram:");
+ SysMemInfo mi;
+
+ // Read system memory info
+ EXPECT_TRUE(mi.ReadMemInfo(tags, &mem, file));
+
+ EXPECT_EQ(mem[MEMINFO_TOTAL], 3019740);
+ EXPECT_EQ(mem[MEMINFO_FREE], 1809728);
+ EXPECT_EQ(mem[MEMINFO_BUFFERS], 54736);
+ EXPECT_EQ(mem[MEMINFO_CACHED], 776052);
+ EXPECT_EQ(mem[MEMINFO_SHMEM], 4020);
+ EXPECT_EQ(mem[MEMINFO_SLAB], 86464);
+ EXPECT_EQ(mem[MEMINFO_SLAB_RECLAIMABLE], 44432);
+ EXPECT_EQ(mem[MEMINFO_SLAB_UNRECLAIMABLE], 42032);
+ EXPECT_EQ(mem[MEMINFO_SWAP_TOTAL], 32768);
+ EXPECT_EQ(mem[MEMINFO_SWAP_FREE], 4096);
+ EXPECT_EQ(mem[MEMINFO_MAPPED], 62624);
+ EXPECT_EQ(mem[MEMINFO_VMALLOC_USED], 65536);
+ EXPECT_EQ(mem[MEMINFO_PAGE_TABLES], 2900);
+ EXPECT_EQ(mem[MEMINFO_KERNEL_STACK], 4880);
+}
+
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
if (argc <= 1) {
diff --git a/libmeminfo/sysmeminfo.cpp b/libmeminfo/sysmeminfo.cpp
index 7e56238..4ec1c99 100644
--- a/libmeminfo/sysmeminfo.cpp
+++ b/libmeminfo/sysmeminfo.cpp
@@ -18,12 +18,15 @@
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
+#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
+#include <algorithm>
#include <cctype>
#include <cstdio>
#include <fstream>
+#include <iterator>
#include <string>
#include <utility>
#include <vector>
@@ -49,7 +52,29 @@
};
bool SysMemInfo::ReadMemInfo(const std::string& path) {
- return ReadMemInfo(SysMemInfo::kDefaultSysMemInfoTags, path);
+ return ReadMemInfo(SysMemInfo::kDefaultSysMemInfoTags, path,
+ [&](const std::string& tag, uint64_t val) { mem_in_kb_[tag] = val; });
+}
+
+bool SysMemInfo::ReadMemInfo(std::vector<uint64_t>* out, const std::string& path) {
+ return ReadMemInfo(SysMemInfo::kDefaultSysMemInfoTags, out, path);
+}
+
+bool SysMemInfo::ReadMemInfo(const std::vector<std::string>& tags, std::vector<uint64_t>* out,
+ const std::string& path) {
+ out->clear();
+ out->resize(tags.size());
+
+ return ReadMemInfo(tags, path, [&]([[maybe_unused]] const std::string& tag, uint64_t val) {
+ auto it = std::find(tags.begin(), tags.end(), tag);
+ if (it == tags.end()) {
+ LOG(ERROR) << "Tried to store invalid tag: " << tag;
+ return;
+ }
+ auto index = std::distance(tags.begin(), it);
+ // store the values in the same order as the tags
+ out->at(index) = val;
+ });
}
// TODO: Delete this function if it can't match up with the c-like implementation below.
@@ -88,7 +113,8 @@
}
#else
-bool SysMemInfo::ReadMemInfo(const std::vector<std::string>& tags, const std::string& path) {
+bool SysMemInfo::ReadMemInfo(const std::vector<std::string>& tags, const std::string& path,
+ std::function<void(const std::string&, uint64_t)> store_val) {
char buffer[4096];
int fd = open(path.c_str(), O_RDONLY | O_CLOEXEC);
if (fd < 0) {
@@ -106,22 +132,34 @@
char* p = buffer;
uint32_t found = 0;
uint32_t lineno = 0;
+ bool zram_tag_found = false;
while (*p && found < tags.size()) {
for (auto& tag : tags) {
+ // Special case for "Zram:" tag that android_os_Debug and friends look
+ // up along with the rest of the numbers from /proc/meminfo
+ if (!zram_tag_found && tag == "Zram:") {
+ store_val(tag, mem_zram_kb());
+ zram_tag_found = true;
+ found++;
+ continue;
+ }
+
if (strncmp(p, tag.c_str(), tag.size()) == 0) {
p += tag.size();
while (*p == ' ') p++;
char* endptr = nullptr;
- mem_in_kb_[tag] = strtoull(p, &endptr, 10);
+ uint64_t val = strtoull(p, &endptr, 10);
if (p == endptr) {
PLOG(ERROR) << "Failed to parse line:" << lineno + 1 << " in file: " << path;
return false;
}
+ store_val(tag, val);
p = endptr;
found++;
break;
}
}
+
while (*p && *p != '\n') {
p++;
}
@@ -163,24 +201,19 @@
}
bool SysMemInfo::MemZramDevice(const std::string& zram_dev, uint64_t* mem_zram_dev) {
- std::string content;
- if (android::base::ReadFileToString(zram_dev + "mm_stat", &content)) {
- std::vector<std::string> values = ::android::base::Split(content, " ");
- if (values.size() < 3) {
- LOG(ERROR) << "Malformed mm_stat file for zram dev: " << zram_dev
- << " content: " << content;
+ std::string mmstat = ::android::base::StringPrintf("%s/%s", zram_dev.c_str(), "mm_stat");
+ auto mmstat_fp = std::unique_ptr<FILE, decltype(&fclose)>{fopen(mmstat.c_str(), "re"), fclose};
+ if (mmstat_fp != nullptr) {
+ // only if we do have mmstat, use it. Otherwise, fall through to trying out the old
+ // 'mem_used_total'
+ if (fscanf(mmstat_fp.get(), "%*" SCNu64 " %*" SCNu64 " %" SCNu64, mem_zram_dev) != 1) {
+ PLOG(ERROR) << "Malformed mm_stat file in: " << zram_dev;
return false;
}
-
- if (!::android::base::ParseUint(values[2], mem_zram_dev)) {
- LOG(ERROR) << "Malformed mm_stat file for zram dev: " << zram_dev
- << " value: " << values[2];
- return false;
- }
-
return true;
}
+ std::string content;
if (::android::base::ReadFileToString(zram_dev + "mem_used_total", &content)) {
*mem_zram_dev = strtoull(content.c_str(), NULL, 10);
if (*mem_zram_dev == ULLONG_MAX) {
diff --git a/libmeminfo/testdata1/mm_stat b/libmeminfo/testdata1/mm_stat
index 684f567..32b325f 100644
--- a/libmeminfo/testdata1/mm_stat
+++ b/libmeminfo/testdata1/mm_stat
@@ -1 +1 @@
-145674240 26801454 31236096 0 45772800 3042 1887 517
+ 145674240 26801454 31236096 0 45772800 3042 1887 517
diff --git a/libsparse/output_file.cpp b/libsparse/output_file.cpp
index fe314b3..5b8179f 100644
--- a/libsparse/output_file.cpp
+++ b/libsparse/output_file.cpp
@@ -508,7 +508,7 @@
out->len = len;
out->block_size = block_size;
- out->cur_out_ptr = 0ll;
+ out->cur_out_ptr = 0LL;
out->chunk_cnt = 0;
out->crc32 = 0;
out->use_crc = crc;
diff --git a/rootdir/ueventd.rc b/rootdir/ueventd.rc
index d90a1ce..a9658a4 100644
--- a/rootdir/ueventd.rc
+++ b/rootdir/ueventd.rc
@@ -1,6 +1,9 @@
firmware_directories /etc/firmware/ /odm/firmware/ /vendor/firmware/ /firmware/image/
uevent_socket_rcvbuf_size 16M
+subsystem adf
+ devname uevent_devname
+
subsystem graphics
devname uevent_devpath
dirname /dev/graphics
@@ -9,10 +12,26 @@
devname uevent_devpath
dirname /dev/dri
+subsystem oncrpc
+ devname uevent_devpath
+ dirname /dev/oncrpc
+
+subsystem adsp
+ devname uevent_devpath
+ dirname /dev/adsp
+
+subsystem msm_camera
+ devname uevent_devpath
+ dirname /dev/msm_camera
+
subsystem input
devname uevent_devpath
dirname /dev/input
+subsystem mtd
+ devname uevent_devpath
+ dirname /dev/mtd
+
subsystem sound
devname uevent_devpath
dirname /dev/snd
@@ -40,25 +59,73 @@
/dev/pmsg0 0222 root log
+# the msm hw3d client device node is world writable/readable.
+/dev/msm_hw3dc 0666 root root
+
+# gpu driver for adreno200 is globally accessible
+/dev/kgsl 0666 root root
+
# kms driver for drm based gpu
/dev/dri/* 0666 root graphics
# these should not be world writable
/dev/diag 0660 radio radio
+/dev/diag_arm9 0660 radio radio
/dev/ttyMSM0 0600 bluetooth bluetooth
/dev/uhid 0660 uhid uhid
/dev/uinput 0660 uhid uhid
+/dev/alarm 0664 system radio
/dev/rtc0 0640 system system
/dev/tty0 0660 root system
/dev/graphics/* 0660 root graphics
+/dev/msm_hw3dm 0660 system graphics
/dev/input/* 0660 root input
/dev/v4l-touch* 0660 root input
+/dev/eac 0660 root audio
+/dev/cam 0660 root camera
+/dev/pmem 0660 system graphics
+/dev/pmem_adsp* 0660 system audio
+/dev/pmem_camera* 0660 system camera
+/dev/oncrpc/* 0660 root system
+/dev/adsp/* 0660 system audio
/dev/snd/* 0660 system audio
+/dev/mt9t013 0660 system system
+/dev/msm_camera/* 0660 system system
+/dev/akm8976_daemon 0640 compass system
+/dev/akm8976_aot 0640 compass system
+/dev/akm8973_daemon 0640 compass system
+/dev/akm8973_aot 0640 compass system
+/dev/bma150 0640 compass system
+/dev/cm3602 0640 compass system
+/dev/akm8976_pffd 0640 compass system
+/dev/lightsensor 0640 system system
+/dev/msm_pcm_out* 0660 system audio
+/dev/msm_pcm_in* 0660 system audio
+/dev/msm_pcm_ctl* 0660 system audio
+/dev/msm_snd* 0660 system audio
/dev/msm_mp3* 0660 system audio
+/dev/audience_a1026* 0660 system audio
+/dev/tpa2018d1* 0660 system audio
+/dev/msm_audpre 0660 system audio
+/dev/msm_audio_ctl 0660 system audio
+/dev/htc-acoustic 0660 system audio
+/dev/vdec 0660 system audio
+/dev/q6venc 0660 system audio
+/dev/snd/dsp 0660 system audio
+/dev/snd/dsp1 0660 system audio
+/dev/snd/mixer 0660 system audio
+/dev/smd0 0640 radio radio
+/dev/qmi 0640 radio radio
+/dev/qmi0 0640 radio radio
+/dev/qmi1 0640 radio radio
+/dev/qmi2 0640 radio radio
+/dev/bus/usb/* 0660 root usb
+/dev/mtp_usb 0660 root mtp
/dev/usb_accessory 0660 root usb
/dev/tun 0660 system vpn
# CDMA radio interface MUX
+/dev/ts0710mux* 0640 radio radio
/dev/ppp 0660 radio vpn
# sysfs properties
@@ -68,3 +135,6 @@
/sys/devices/virtual/usb_composite/* enable 0664 root system
/sys/devices/system/cpu/cpu* cpufreq/scaling_max_freq 0664 system system
/sys/devices/system/cpu/cpu* cpufreq/scaling_min_freq 0664 system system
+
+# DVB API device nodes
+/dev/dvb* 0660 root system