Merge "libsnapshot: Return path if snapshot is already merged"
diff --git a/adb/test_device.py b/adb/test_device.py
index 32d797e..57925e8 100755
--- a/adb/test_device.py
+++ b/adb/test_device.py
@@ -903,10 +903,12 @@
remote_path += '/filename'
self.device.push(local=tmp_file.name, remote=remote_path)
- def test_push_multiple_slash_root(self):
+ def disabled_test_push_multiple_slash_root(self):
"""Regression test for pushing to //data/local/tmp.
Bug: http://b/141311284
+
+ Disabled because this broken on the adbd side as well: b/141943968
"""
with tempfile.NamedTemporaryFile() as tmp_file:
tmp_file.write('\0' * 1024 * 1024)
diff --git a/fs_mgr/libdm/Android.bp b/fs_mgr/libdm/Android.bp
index 449a170..dd95a5e 100644
--- a/fs_mgr/libdm/Android.bp
+++ b/fs_mgr/libdm/Android.bp
@@ -55,13 +55,7 @@
cc_defaults {
name: "libdm_defaults",
- sanitize: {
- misc_undefined: ["integer"],
- },
- cflags: [
- "-Wall",
- "-Werror",
- ],
+ defaults: ["fs_mgr_defaults"],
static_libs: [
"libdm",
"libbase",
@@ -76,3 +70,12 @@
name: "libdm_test",
defaults: ["libdm_defaults"],
}
+
+cc_test {
+ name: "vts_libdm_test",
+ defaults: ["libdm_defaults"],
+ test_suites: ["vts-core"],
+ auto_gen_config: true,
+ require_root: true,
+ test_min_api_level: 29,
+}
diff --git a/fs_mgr/libdm/vts_core/Android.bp b/fs_mgr/libdm/vts_core/Android.bp
deleted file mode 100644
index 2eceb28..0000000
--- a/fs_mgr/libdm/vts_core/Android.bp
+++ /dev/null
@@ -1,23 +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.
-//
-
-cc_test {
- name: "vts_libdm_test",
- defaults: ["libdm_defaults"],
- test_suites: ["vts-core"],
- require_root: true,
- test_min_api_level: 29,
-}
diff --git a/fs_mgr/liblp/Android.bp b/fs_mgr/liblp/Android.bp
index 178b343..a7c77b8 100644
--- a/fs_mgr/liblp/Android.bp
+++ b/fs_mgr/liblp/Android.bp
@@ -69,13 +69,7 @@
cc_defaults {
name: "liblp_test_defaults",
- sanitize: {
- misc_undefined: ["integer"],
- },
- cflags: [
- "-Wall",
- "-Werror",
- ],
+ defaults: ["fs_mgr_defaults"],
cppflags: [
"-Wno-unused-parameter",
],
@@ -101,6 +95,14 @@
}
cc_test {
+ name: "vts_core_liblp_test",
+ defaults: ["liblp_test_defaults"],
+ test_suites: ["vts-core"],
+ auto_gen_config: true,
+ test_min_api_level: 29,
+}
+
+cc_test {
name: "vts_kernel_liblp_test",
defaults: ["liblp_test_defaults"],
}
diff --git a/fs_mgr/liblp/vts_core/Android.bp b/fs_mgr/liblp/vts_core/Android.bp
deleted file mode 100644
index 7af0b9e..0000000
--- a/fs_mgr/liblp/vts_core/Android.bp
+++ /dev/null
@@ -1,22 +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.
-//
-
-cc_test {
- name: "vts_core_liblp_test",
- defaults: ["liblp_test_defaults"],
- test_suites: ["vts-core"],
- test_min_api_level: 29,
-}
diff --git a/fs_mgr/libsnapshot/partition_cow_creator.cpp b/fs_mgr/libsnapshot/partition_cow_creator.cpp
index 4250d23..404ef27 100644
--- a/fs_mgr/libsnapshot/partition_cow_creator.cpp
+++ b/fs_mgr/libsnapshot/partition_cow_creator.cpp
@@ -67,59 +67,6 @@
return false;
}
-// Return the number of sectors, N, where |target_partition|[0..N] (from
-// |target_metadata|) are the sectors that should be snapshotted. N is computed
-// so that this range of sectors are used by partitions in |current_metadata|.
-//
-// The client code (update_engine) should have computed target_metadata by
-// resizing partitions of current_metadata, so only the first N sectors should
-// be snapshotted, not a range with start index != 0.
-//
-// Note that if partition A has shrunk and partition B has grown, the new
-// extents of partition B may use the empty space that was used by partition A.
-// In this case, that new extent cannot be written directly, as it may be used
-// by the running system. Hence, all extents of the new partition B must be
-// intersected with all old partitions (including old partition A and B) to get
-// the region that needs to be snapshotted.
-std::optional<uint64_t> PartitionCowCreator::GetSnapshotSize() {
- // Compute the number of sectors that needs to be snapshotted.
- uint64_t snapshot_sectors = 0;
- std::vector<std::unique_ptr<Extent>> intersections;
- for (const auto& extent : target_partition->extents()) {
- for (auto* existing_partition :
- ListPartitionsWithSuffix(current_metadata, current_suffix)) {
- for (const auto& existing_extent : existing_partition->extents()) {
- auto intersection = Intersect(extent.get(), existing_extent.get());
- if (intersection != nullptr && intersection->num_sectors() > 0) {
- snapshot_sectors += intersection->num_sectors();
- intersections.emplace_back(std::move(intersection));
- }
- }
- }
- }
- uint64_t snapshot_size = snapshot_sectors * kSectorSize;
-
- // Sanity check that all recorded intersections are indeed within
- // target_partition[0..snapshot_sectors].
- Partition target_partition_snapshot = target_partition->GetBeginningExtents(snapshot_size);
- for (const auto& intersection : intersections) {
- if (!HasExtent(&target_partition_snapshot, intersection.get())) {
- auto linear_intersection = intersection->AsLinearExtent();
- LOG(ERROR) << "Extent "
- << (linear_intersection
- ? (std::to_string(linear_intersection->physical_sector()) + "," +
- std::to_string(linear_intersection->end_sector()))
- : "")
- << " is not part of Partition " << target_partition->name() << "[0.."
- << snapshot_size
- << "]. The metadata wasn't constructed correctly. This should not happen.";
- return std::nullopt;
- }
- }
-
- return snapshot_size;
-}
-
std::optional<uint64_t> PartitionCowCreator::GetCowSize(uint64_t snapshot_size) {
// TODO: Use |operations|. to determine a minimum COW size.
// kCowEstimateFactor is good for prototyping but we can't use that in production.
@@ -139,12 +86,11 @@
Return ret;
ret.snapshot_status.device_size = target_partition->size();
- auto snapshot_size = GetSnapshotSize();
- if (!snapshot_size.has_value()) return std::nullopt;
+ // TODO(b/141889746): Optimize by using a smaller snapshot. Some ranges in target_partition
+ // may be written directly.
+ ret.snapshot_status.snapshot_size = target_partition->size();
- ret.snapshot_status.snapshot_size = *snapshot_size;
-
- auto cow_size = GetCowSize(*snapshot_size);
+ auto cow_size = GetCowSize(ret.snapshot_status.snapshot_size);
if (!cow_size.has_value()) return std::nullopt;
// Compute regions that are free in both current and target metadata. These are the regions
diff --git a/fs_mgr/libsnapshot/partition_cow_creator.h b/fs_mgr/libsnapshot/partition_cow_creator.h
index 7c81418..0e645c6 100644
--- a/fs_mgr/libsnapshot/partition_cow_creator.h
+++ b/fs_mgr/libsnapshot/partition_cow_creator.h
@@ -59,7 +59,6 @@
private:
bool HasExtent(Partition* p, Extent* e);
- std::optional<uint64_t> GetSnapshotSize();
std::optional<uint64_t> GetCowSize(uint64_t snapshot_size);
};
diff --git a/fs_mgr/libsnapshot/partition_cow_creator_test.cpp b/fs_mgr/libsnapshot/partition_cow_creator_test.cpp
index 4c9afff..ccd087e 100644
--- a/fs_mgr/libsnapshot/partition_cow_creator_test.cpp
+++ b/fs_mgr/libsnapshot/partition_cow_creator_test.cpp
@@ -20,7 +20,7 @@
#include "partition_cow_creator.h"
#include "test_helpers.h"
-using ::android::fs_mgr::MetadataBuilder;
+using namespace android::fs_mgr;
namespace android {
namespace snapshot {
@@ -55,5 +55,46 @@
ASSERT_EQ(40 * 1024, ret->snapshot_status.snapshot_size);
}
+TEST_F(PartitionCowCreatorTest, Holes) {
+ const auto& opener = test_device->GetPartitionOpener();
+
+ constexpr auto slack_space = 1_MiB;
+ constexpr auto big_size = (kSuperSize - slack_space) / 2;
+ constexpr auto small_size = big_size / 2;
+
+ BlockDeviceInfo super_device("super", kSuperSize, 0, 0, 4_KiB);
+ std::vector<BlockDeviceInfo> devices = {super_device};
+ auto source = MetadataBuilder::New(devices, "super", 1024, 2);
+ auto system = source->AddPartition("system_a", 0);
+ ASSERT_NE(nullptr, system);
+ ASSERT_TRUE(source->ResizePartition(system, big_size));
+ auto vendor = source->AddPartition("vendor_a", 0);
+ ASSERT_NE(nullptr, vendor);
+ ASSERT_TRUE(source->ResizePartition(vendor, big_size));
+ // Create a hole between system and vendor
+ ASSERT_TRUE(source->ResizePartition(system, small_size));
+ auto source_metadata = source->Export();
+ ASSERT_NE(nullptr, source_metadata);
+ ASSERT_TRUE(FlashPartitionTable(opener, fake_super, *source_metadata.get()));
+
+ auto target = MetadataBuilder::NewForUpdate(opener, "super", 0, 1);
+ // Shrink vendor
+ vendor = target->FindPartition("vendor_b");
+ ASSERT_NE(nullptr, vendor);
+ ASSERT_TRUE(target->ResizePartition(vendor, small_size));
+ // Grow system to take hole & saved space from vendor
+ system = target->FindPartition("system_b");
+ ASSERT_NE(nullptr, system);
+ ASSERT_TRUE(target->ResizePartition(system, big_size * 2 - small_size));
+
+ PartitionCowCreator creator{.target_metadata = target.get(),
+ .target_suffix = "_b",
+ .target_partition = system,
+ .current_metadata = source.get(),
+ .current_suffix = "_a"};
+ auto ret = creator.Run();
+ ASSERT_TRUE(ret.has_value());
+}
+
} // namespace snapshot
} // namespace android
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index c94fde5..f3994c1 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -58,15 +58,11 @@
using namespace std::chrono_literals;
using namespace std::string_literals;
-// These are not reset between each test because it's expensive to create
-// these resources (starting+connecting to gsid, zero-filling images).
+// Global states. See test_helpers.h.
std::unique_ptr<SnapshotManager> sm;
TestDeviceInfo* test_device = nullptr;
std::string fake_super;
-static constexpr uint64_t kSuperSize = 16_MiB + 4_KiB;
-static constexpr uint64_t kGroupSize = 16_MiB;
-
class SnapshotTest : public ::testing::Test {
public:
SnapshotTest() : dm_(DeviceMapper::Instance()) {}
@@ -743,9 +739,9 @@
}
// Grow all partitions.
- SetSize(sys_, 4_MiB);
- SetSize(vnd_, 4_MiB);
- SetSize(prd_, 4_MiB);
+ SetSize(sys_, 3788_KiB);
+ SetSize(vnd_, 3788_KiB);
+ SetSize(prd_, 3788_KiB);
// Execute the update.
ASSERT_TRUE(sm->BeginUpdate());
@@ -810,6 +806,7 @@
// Test that if new system partitions uses empty space in super, that region is not snapshotted.
TEST_F(SnapshotUpdateTest, DirectWriteEmptySpace) {
+ GTEST_SKIP() << "b/141889746";
SetSize(sys_, 4_MiB);
// vnd_b and prd_b are unchanged.
ASSERT_TRUE(sm->CreateUpdateSnapshots(manifest_));
diff --git a/fs_mgr/libsnapshot/test_helpers.h b/fs_mgr/libsnapshot/test_helpers.h
index bb19adc..769d21e 100644
--- a/fs_mgr/libsnapshot/test_helpers.h
+++ b/fs_mgr/libsnapshot/test_helpers.h
@@ -23,6 +23,7 @@
#include <liblp/mock_property_fetcher.h>
#include <liblp/partition_opener.h>
#include <libsnapshot/snapshot.h>
+#include <storage_literals/storage_literals.h>
#include <update_engine/update_metadata.pb.h>
namespace android {
@@ -38,8 +39,17 @@
using testing::NiceMock;
using testing::Return;
+using namespace android::storage_literals;
using namespace std::string_literals;
+// These are not reset between each test because it's expensive to create
+// these resources (starting+connecting to gsid, zero-filling images).
+extern std::unique_ptr<SnapshotManager> sm;
+extern class TestDeviceInfo* test_device;
+extern std::string fake_super;
+static constexpr uint64_t kSuperSize = 16_MiB + 4_KiB;
+static constexpr uint64_t kGroupSize = 16_MiB;
+
// Redirect requests for "super" to our fake super partition.
class TestPartitionOpener final : public android::fs_mgr::PartitionOpener {
public:
diff --git a/init/selinux.cpp b/init/selinux.cpp
index 4852cd0..a15d136 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -36,16 +36,18 @@
// The split SEPolicy is loaded as described below:
// 1) There is a precompiled SEPolicy located at either /vendor/etc/selinux/precompiled_sepolicy or
// /odm/etc/selinux/precompiled_sepolicy if odm parition is present. Stored along with this file
-// are the sha256 hashes of the parts of the SEPolicy on /system and /product that were used to
-// compile this precompiled policy. The system partition contains a similar sha256 of the parts
-// of the SEPolicy that it currently contains. Symmetrically, product paritition contains a
-// sha256 of its SEPolicy. System loads this precompiled_sepolicy directly if and only if hashes
-// for system policy match and hashes for product policy match.
-// 2) If these hashes do not match, then either /system or /product (or both) have been updated out
-// of sync with /vendor and the init needs to compile the SEPolicy. /system contains the
-// SEPolicy compiler, secilc, and it is used by the LoadSplitPolicy() function below to compile
-// the SEPolicy to a temp directory and load it. That function contains even more documentation
-// with the specific implementation details of how the SEPolicy is compiled if needed.
+// are the sha256 hashes of the parts of the SEPolicy on /system, /system_ext and /product that
+// were used to compile this precompiled policy. The system partition contains a similar sha256
+// of the parts of the SEPolicy that it currently contains. Symmetrically, system_ext and
+// product paritition contain sha256 hashes of their SEPolicy. The init loads this
+// precompiled_sepolicy directly if and only if the hashes along with the precompiled SEPolicy on
+// /vendor or /odm match the hashes for system, system_ext and product SEPolicy, respectively.
+// 2) If these hashes do not match, then either /system or /system_ext or /product (or some of them)
+// have been updated out of sync with /vendor (or /odm if it is present) and the init needs to
+// compile the SEPolicy. /system contains the SEPolicy compiler, secilc, and it is used by the
+// LoadSplitPolicy() function below to compile the SEPolicy to a temp directory and load it.
+// That function contains even more documentation with the specific implementation details of how
+// the SEPolicy is compiled if needed.
#include "selinux.h"
@@ -228,6 +230,13 @@
"/system/etc/selinux/plat_sepolicy_and_mapping.sha256";
return false;
}
+ std::string actual_system_ext_id;
+ if (!ReadFirstLine("/system_ext/etc/selinux/system_ext_sepolicy_and_mapping.sha256",
+ &actual_system_ext_id)) {
+ PLOG(INFO) << "Failed to read "
+ "/system_ext/etc/selinux/system_ext_sepolicy_and_mapping.sha256";
+ return false;
+ }
std::string actual_product_id;
if (!ReadFirstLine("/product/etc/selinux/product_sepolicy_and_mapping.sha256",
&actual_product_id)) {
@@ -243,6 +252,13 @@
file->clear();
return false;
}
+ std::string precompiled_system_ext_id;
+ std::string precompiled_system_ext_sha256 = *file + ".system_ext_sepolicy_and_mapping.sha256";
+ if (!ReadFirstLine(precompiled_system_ext_sha256.c_str(), &precompiled_system_ext_id)) {
+ PLOG(INFO) << "Failed to read " << precompiled_system_ext_sha256;
+ file->clear();
+ return false;
+ }
std::string precompiled_product_id;
std::string precompiled_product_sha256 = *file + ".product_sepolicy_and_mapping.sha256";
if (!ReadFirstLine(precompiled_product_sha256.c_str(), &precompiled_product_id)) {
@@ -251,6 +267,7 @@
return false;
}
if (actual_plat_id.empty() || actual_plat_id != precompiled_plat_id ||
+ actual_system_ext_id.empty() || actual_system_ext_id != precompiled_system_ext_id ||
actual_product_id.empty() || actual_product_id != precompiled_product_id) {
file->clear();
return false;
@@ -336,6 +353,17 @@
plat_compat_cil_file.clear();
}
+ std::string system_ext_policy_cil_file("/system_ext/etc/selinux/system_ext_sepolicy.cil");
+ if (access(system_ext_policy_cil_file.c_str(), F_OK) == -1) {
+ system_ext_policy_cil_file.clear();
+ }
+
+ std::string system_ext_mapping_file("/system_ext/etc/selinux/mapping/" + vend_plat_vers +
+ ".cil");
+ if (access(system_ext_mapping_file.c_str(), F_OK) == -1) {
+ system_ext_mapping_file.clear();
+ }
+
std::string product_policy_cil_file("/product/etc/selinux/product_sepolicy.cil");
if (access(product_policy_cil_file.c_str(), F_OK) == -1) {
product_policy_cil_file.clear();
@@ -384,6 +412,12 @@
if (!plat_compat_cil_file.empty()) {
compile_args.push_back(plat_compat_cil_file.c_str());
}
+ if (!system_ext_policy_cil_file.empty()) {
+ compile_args.push_back(system_ext_policy_cil_file.c_str());
+ }
+ if (!system_ext_mapping_file.empty()) {
+ compile_args.push_back(system_ext_mapping_file.c_str());
+ }
if (!product_policy_cil_file.empty()) {
compile_args.push_back(product_policy_cil_file.c_str());
}
diff --git a/libkeyutils/Android.bp b/libkeyutils/Android.bp
index dda491a..b388e95 100644
--- a/libkeyutils/Android.bp
+++ b/libkeyutils/Android.bp
@@ -16,17 +16,3 @@
srcs: ["keyutils_test.cpp"],
test_suites: ["device-tests"],
}
-
-cc_binary {
- name: "mini-keyctl",
- srcs: [
- "mini_keyctl.cpp",
- "mini_keyctl_utils.cpp"
- ],
- shared_libs: [
- "libbase",
- "libkeyutils",
- "liblog",
- ],
- cflags: ["-Werror", "-Wall", "-Wextra", "-fexceptions"],
-}
diff --git a/libkeyutils/mini_keyctl.cpp b/libkeyutils/mini_keyctl.cpp
deleted file mode 100644
index fe89e62..0000000
--- a/libkeyutils/mini_keyctl.cpp
+++ /dev/null
@@ -1,90 +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.
- */
-
-/*
- * A tool loads keys to keyring.
- */
-
-#include "mini_keyctl_utils.h"
-
-#include <error.h>
-#include <stdio.h>
-#include <unistd.h>
-
-#include <android-base/parseint.h>
-
-static void Usage(int exit_code) {
- fprintf(stderr, "usage: mini-keyctl <action> [args,]\n");
- fprintf(stderr, " mini-keyctl add <type> <desc> <data> <keyring>\n");
- fprintf(stderr, " mini-keyctl padd <type> <desc> <keyring>\n");
- fprintf(stderr, " mini-keyctl unlink <key> <keyring>\n");
- fprintf(stderr, " mini-keyctl restrict_keyring <keyring>\n");
- fprintf(stderr, " mini-keyctl security <key>\n");
- _exit(exit_code);
-}
-
-static key_serial_t parseKeyOrDie(const char* str) {
- key_serial_t key;
- if (!android::base::ParseInt(str, &key)) {
- error(1 /* exit code */, 0 /* errno */, "Unparsable key: '%s'\n", str);
- }
- return key;
-}
-
-int main(int argc, const char** argv) {
- if (argc < 2) Usage(1);
- const std::string action = argv[1];
-
- if (action == "add") {
- if (argc != 6) Usage(1);
- std::string type = argv[2];
- std::string desc = argv[3];
- std::string data = argv[4];
- std::string keyring = argv[5];
- return Add(type, desc, data, keyring);
- } else if (action == "padd") {
- if (argc != 5) Usage(1);
- std::string type = argv[2];
- std::string desc = argv[3];
- std::string keyring = argv[4];
- return Padd(type, desc, keyring);
- } else if (action == "restrict_keyring") {
- if (argc != 3) Usage(1);
- std::string keyring = argv[2];
- return RestrictKeyring(keyring);
- } else if (action == "unlink") {
- if (argc != 4) Usage(1);
- key_serial_t key = parseKeyOrDie(argv[2]);
- const std::string keyring = argv[3];
- return Unlink(key, keyring);
- } else if (action == "security") {
- if (argc != 3) Usage(1);
- const char* key_str = argv[2];
- key_serial_t key = parseKeyOrDie(key_str);
- std::string context = RetrieveSecurityContext(key);
- if (context.empty()) {
- perror(key_str);
- return 1;
- }
- fprintf(stderr, "%s\n", context.c_str());
- return 0;
- } else {
- fprintf(stderr, "Unrecognized action: %s\n", action.c_str());
- Usage(1);
- }
-
- return 0;
-}
diff --git a/libkeyutils/mini_keyctl/Android.bp b/libkeyutils/mini_keyctl/Android.bp
new file mode 100644
index 0000000..a04a3db
--- /dev/null
+++ b/libkeyutils/mini_keyctl/Android.bp
@@ -0,0 +1,27 @@
+cc_library_static {
+ name: "libmini_keyctl_static",
+ srcs: [
+ "mini_keyctl_utils.cpp"
+ ],
+ shared_libs: [
+ "libbase",
+ "libkeyutils",
+ ],
+ cflags: ["-Werror", "-Wall", "-Wextra"],
+ export_include_dirs: ["."],
+}
+
+cc_binary {
+ name: "mini-keyctl",
+ srcs: [
+ "mini_keyctl.cpp",
+ ],
+ static_libs: [
+ "libmini_keyctl_static",
+ ],
+ shared_libs: [
+ "libbase",
+ "libkeyutils",
+ ],
+ cflags: ["-Werror", "-Wall", "-Wextra"],
+}
diff --git a/libkeyutils/mini_keyctl/mini_keyctl.cpp b/libkeyutils/mini_keyctl/mini_keyctl.cpp
new file mode 100644
index 0000000..8aace9a
--- /dev/null
+++ b/libkeyutils/mini_keyctl/mini_keyctl.cpp
@@ -0,0 +1,178 @@
+/*
+ * 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.
+ */
+
+/*
+ * A tool loads keys to keyring.
+ */
+
+#include <dirent.h>
+#include <errno.h>
+#include <error.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <iostream>
+#include <iterator>
+#include <string>
+
+#include <android-base/file.h>
+#include <android-base/parseint.h>
+#include <keyutils.h>
+#include <mini_keyctl_utils.h>
+
+constexpr int kMaxCertSize = 4096;
+
+static void Usage(int exit_code) {
+ fprintf(stderr, "usage: mini-keyctl <action> [args,]\n");
+ fprintf(stderr, " mini-keyctl add <type> <desc> <data> <keyring>\n");
+ fprintf(stderr, " mini-keyctl padd <type> <desc> <keyring>\n");
+ fprintf(stderr, " mini-keyctl unlink <key> <keyring>\n");
+ fprintf(stderr, " mini-keyctl restrict_keyring <keyring>\n");
+ fprintf(stderr, " mini-keyctl security <key>\n");
+ _exit(exit_code);
+}
+
+static key_serial_t parseKeyOrDie(const char* str) {
+ key_serial_t key;
+ if (!android::base::ParseInt(str, &key)) {
+ error(1 /* exit code */, 0 /* errno */, "Unparsable key: '%s'\n", str);
+ }
+ return key;
+}
+
+int Unlink(key_serial_t key, const std::string& keyring) {
+ key_serial_t keyring_id = android::GetKeyringId(keyring);
+ if (keyctl_unlink(key, keyring_id) < 0) {
+ error(1, errno, "Failed to unlink key %x from keyring %s", key, keyring.c_str());
+ return 1;
+ }
+ return 0;
+}
+
+int Add(const std::string& type, const std::string& desc, const std::string& data,
+ const std::string& keyring) {
+ if (data.size() > kMaxCertSize) {
+ error(1, 0, "Certificate too large");
+ return 1;
+ }
+
+ key_serial_t keyring_id = android::GetKeyringId(keyring);
+ key_serial_t key = add_key(type.c_str(), desc.c_str(), data.c_str(), data.size(), keyring_id);
+
+ if (key < 0) {
+ error(1, errno, "Failed to add key");
+ return 1;
+ }
+
+ std::cout << key << std::endl;
+ return 0;
+}
+
+int Padd(const std::string& type, const std::string& desc, const std::string& keyring) {
+ key_serial_t keyring_id = android::GetKeyringId(keyring);
+
+ // read from stdin to get the certificates
+ std::istreambuf_iterator<char> begin(std::cin), end;
+ std::string data(begin, end);
+
+ if (data.size() > kMaxCertSize) {
+ error(1, 0, "Certificate too large");
+ return 1;
+ }
+
+ key_serial_t key = add_key(type.c_str(), desc.c_str(), data.c_str(), data.size(), keyring_id);
+
+ if (key < 0) {
+ error(1, errno, "Failed to add key");
+ return 1;
+ }
+
+ std::cout << key << std::endl;
+ return 0;
+}
+
+int RestrictKeyring(const std::string& keyring) {
+ key_serial_t keyring_id = android::GetKeyringId(keyring);
+ if (keyctl_restrict_keyring(keyring_id, nullptr, nullptr) < 0) {
+ error(1, errno, "Cannot restrict keyring '%s'", keyring.c_str());
+ return 1;
+ }
+ return 0;
+}
+
+std::string RetrieveSecurityContext(key_serial_t key) {
+ // Simply assume this size is enough in practice.
+ const int kMaxSupportedSize = 256;
+ std::string context;
+ context.resize(kMaxSupportedSize);
+ long retval = keyctl_get_security(key, context.data(), kMaxSupportedSize);
+ if (retval < 0) {
+ error(1, errno, "Cannot get security context of key %x", key);
+ return std::string();
+ }
+ if (retval > kMaxSupportedSize) {
+ error(1, 0, "The key has unexpectedly long security context than %d", kMaxSupportedSize);
+ return std::string();
+ }
+ context.resize(retval);
+ return context;
+}
+
+int main(int argc, const char** argv) {
+ if (argc < 2) Usage(1);
+ const std::string action = argv[1];
+
+ if (action == "add") {
+ if (argc != 6) Usage(1);
+ std::string type = argv[2];
+ std::string desc = argv[3];
+ std::string data = argv[4];
+ std::string keyring = argv[5];
+ return Add(type, desc, data, keyring);
+ } else if (action == "padd") {
+ if (argc != 5) Usage(1);
+ std::string type = argv[2];
+ std::string desc = argv[3];
+ std::string keyring = argv[4];
+ return Padd(type, desc, keyring);
+ } else if (action == "restrict_keyring") {
+ if (argc != 3) Usage(1);
+ std::string keyring = argv[2];
+ return RestrictKeyring(keyring);
+ } else if (action == "unlink") {
+ if (argc != 4) Usage(1);
+ key_serial_t key = parseKeyOrDie(argv[2]);
+ const std::string keyring = argv[3];
+ return Unlink(key, keyring);
+ } else if (action == "security") {
+ if (argc != 3) Usage(1);
+ const char* key_str = argv[2];
+ key_serial_t key = parseKeyOrDie(key_str);
+ std::string context = RetrieveSecurityContext(key);
+ if (context.empty()) {
+ perror(key_str);
+ return 1;
+ }
+ fprintf(stderr, "%s\n", context.c_str());
+ return 0;
+ } else {
+ fprintf(stderr, "Unrecognized action: %s\n", action.c_str());
+ Usage(1);
+ }
+
+ return 0;
+}
diff --git a/libkeyutils/mini_keyctl/mini_keyctl_utils.cpp b/libkeyutils/mini_keyctl/mini_keyctl_utils.cpp
new file mode 100644
index 0000000..fb9503f
--- /dev/null
+++ b/libkeyutils/mini_keyctl/mini_keyctl_utils.cpp
@@ -0,0 +1,83 @@
+/*
+ * 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.
+ */
+
+#include <mini_keyctl_utils.h>
+
+#include <fstream>
+#include <iterator>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include <android-base/logging.h>
+#include <android-base/parseint.h>
+
+namespace android {
+
+namespace {
+
+std::vector<std::string> SplitBySpace(const std::string& s) {
+ std::istringstream iss(s);
+ return std::vector<std::string>{std::istream_iterator<std::string>{iss},
+ std::istream_iterator<std::string>{}};
+}
+
+} // namespace
+
+// Find the keyring id. request_key(2) only finds keys in the process, session or thread keyring
+// hierarchy, but not internal keyring of a kernel subsystem (e.g. .fs-verity). To support all
+// cases, this function looks up a keyring's ID by parsing /proc/keys. The keyring description may
+// contain other information in the descritption section depending on the key type, only the first
+// word in the keyring description is used for searching.
+key_serial_t GetKeyringId(const std::string& keyring_desc) {
+ // If the keyring id is already a hex number, directly convert it to keyring id
+ key_serial_t keyring_id;
+ if (android::base::ParseInt(keyring_desc.c_str(), &keyring_id)) {
+ return keyring_id;
+ }
+
+ // Only keys allowed by SELinux rules will be shown here.
+ std::ifstream proc_keys_file("/proc/keys");
+ if (!proc_keys_file.is_open()) {
+ PLOG(ERROR) << "Failed to open /proc/keys";
+ return -1;
+ }
+
+ std::string line;
+ while (getline(proc_keys_file, line)) {
+ std::vector<std::string> tokens = SplitBySpace(line);
+ if (tokens.size() < 9) {
+ continue;
+ }
+ std::string key_id = "0x" + tokens[0];
+ std::string key_type = tokens[7];
+ // The key description may contain space.
+ std::string key_desc_prefix = tokens[8];
+ // The prefix has a ":" at the end
+ std::string key_desc_pattern = keyring_desc + ":";
+ if (key_type != "keyring" || key_desc_prefix != key_desc_pattern) {
+ continue;
+ }
+ if (!android::base::ParseInt(key_id.c_str(), &keyring_id)) {
+ LOG(ERROR) << "Unexpected key format in /proc/keys: " << key_id;
+ return -1;
+ }
+ return keyring_id;
+ }
+ return -1;
+}
+
+} // namespace android
diff --git a/libkeyutils/mini_keyctl/mini_keyctl_utils.h b/libkeyutils/mini_keyctl/mini_keyctl_utils.h
new file mode 100644
index 0000000..cc31d29
--- /dev/null
+++ b/libkeyutils/mini_keyctl/mini_keyctl_utils.h
@@ -0,0 +1,28 @@
+/*
+ * 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.
+ */
+
+#ifndef _MINI_KEYCTL_MINI_KEYCTL_UTILS_H_
+#define _MINI_KEYCTL_MINI_KEYCTL_UTILS_H_
+
+#include <string>
+
+#include <keyutils.h>
+
+namespace android {
+key_serial_t GetKeyringId(const std::string& keyring_desc);
+} // namespace android
+
+#endif // _MINI_KEYCTL_MINI_KEYCTL_UTILS_H_
diff --git a/libkeyutils/mini_keyctl_utils.cpp b/libkeyutils/mini_keyctl_utils.cpp
deleted file mode 100644
index 79b4680..0000000
--- a/libkeyutils/mini_keyctl_utils.cpp
+++ /dev/null
@@ -1,164 +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.
- */
-
-#include <mini_keyctl_utils.h>
-
-#include <dirent.h>
-#include <errno.h>
-#include <error.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include <fstream>
-#include <iostream>
-#include <iterator>
-#include <sstream>
-#include <string>
-#include <vector>
-
-#include <android-base/file.h>
-#include <android-base/parseint.h>
-#include <android-base/properties.h>
-#include <android-base/strings.h>
-#include <keyutils.h>
-
-static constexpr int kMaxCertSize = 4096;
-
-static std::vector<std::string> SplitBySpace(const std::string& s) {
- std::istringstream iss(s);
- return std::vector<std::string>{std::istream_iterator<std::string>{iss},
- std::istream_iterator<std::string>{}};
-}
-
-// Find the keyring id. Because request_key(2) syscall is not available or the key is
-// kernel keyring, the id is looked up from /proc/keys. The keyring description may contain other
-// information in the descritption section depending on the key type, only the first word in the
-// keyring description is used for searching.
-static key_serial_t GetKeyringIdOrDie(const std::string& keyring_desc) {
- // If the keyring id is already a hex number, directly convert it to keyring id
- key_serial_t keyring_id;
- if (android::base::ParseInt(keyring_desc.c_str(), &keyring_id)) {
- return keyring_id;
- }
-
- // Only keys allowed by SELinux rules will be shown here.
- std::ifstream proc_keys_file("/proc/keys");
- if (!proc_keys_file.is_open()) {
- error(1, errno, "Failed to open /proc/keys");
- return -1;
- }
-
- std::string line;
- while (getline(proc_keys_file, line)) {
- std::vector<std::string> tokens = SplitBySpace(line);
- if (tokens.size() < 9) {
- continue;
- }
- std::string key_id = "0x" + tokens[0];
- std::string key_type = tokens[7];
- // The key description may contain space.
- std::string key_desc_prefix = tokens[8];
- // The prefix has a ":" at the end
- std::string key_desc_pattern = keyring_desc + ":";
- if (key_type != "keyring" || key_desc_prefix != key_desc_pattern) {
- continue;
- }
- if (!android::base::ParseInt(key_id.c_str(), &keyring_id)) {
- error(1, 0, "Unexpected key format in /proc/keys: %s", key_id.c_str());
- return -1;
- }
- return keyring_id;
- }
- return -1;
-}
-
-int Unlink(key_serial_t key, const std::string& keyring) {
- key_serial_t keyring_id = GetKeyringIdOrDie(keyring);
- if (keyctl_unlink(key, keyring_id) < 0) {
- error(1, errno, "Failed to unlink key %x from keyring %s", key, keyring.c_str());
- return 1;
- }
- return 0;
-}
-
-int Add(const std::string& type, const std::string& desc, const std::string& data,
- const std::string& keyring) {
- if (data.size() > kMaxCertSize) {
- error(1, 0, "Certificate too large");
- return 1;
- }
-
- key_serial_t keyring_id = GetKeyringIdOrDie(keyring);
- key_serial_t key = add_key(type.c_str(), desc.c_str(), data.c_str(), data.size(), keyring_id);
-
- if (key < 0) {
- error(1, errno, "Failed to add key");
- return 1;
- }
-
- std::cout << key << std::endl;
- return 0;
-}
-
-int Padd(const std::string& type, const std::string& desc, const std::string& keyring) {
- key_serial_t keyring_id = GetKeyringIdOrDie(keyring);
-
- // read from stdin to get the certificates
- std::istreambuf_iterator<char> begin(std::cin), end;
- std::string data(begin, end);
-
- if (data.size() > kMaxCertSize) {
- error(1, 0, "Certificate too large");
- return 1;
- }
-
- key_serial_t key = add_key(type.c_str(), desc.c_str(), data.c_str(), data.size(), keyring_id);
-
- if (key < 0) {
- error(1, errno, "Failed to add key");
- return 1;
- }
-
- std::cout << key << std::endl;
- return 0;
-}
-
-int RestrictKeyring(const std::string& keyring) {
- key_serial_t keyring_id = GetKeyringIdOrDie(keyring);
- if (keyctl_restrict_keyring(keyring_id, nullptr, nullptr) < 0) {
- error(1, errno, "Cannot restrict keyring '%s'", keyring.c_str());
- return 1;
- }
- return 0;
-}
-
-std::string RetrieveSecurityContext(key_serial_t key) {
- // Simply assume this size is enough in practice.
- const int kMaxSupportedSize = 256;
- std::string context;
- context.resize(kMaxSupportedSize);
- long retval = keyctl_get_security(key, context.data(), kMaxSupportedSize);
- if (retval < 0) {
- error(1, errno, "Cannot get security context of key %x", key);
- return std::string();
- }
- if (retval > kMaxSupportedSize) {
- error(1, 0, "The key has unexpectedly long security context than %d", kMaxSupportedSize);
- return std::string();
- }
- context.resize(retval);
- return context;
-}
diff --git a/libkeyutils/mini_keyctl_utils.h b/libkeyutils/mini_keyctl_utils.h
deleted file mode 100644
index 3616831..0000000
--- a/libkeyutils/mini_keyctl_utils.h
+++ /dev/null
@@ -1,35 +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.
- */
-
-#include "include/keyutils.h"
-
-#include <string>
-
-// Add key to a keyring. Returns non-zero if error happens.
-int Add(const std::string& type, const std::string& desc, const std::string& data,
- const std::string& keyring);
-
-// Add key from stdin to a keyring. Returns non-zero if error happens.
-int Padd(const std::string& type, const std::string& desc, const std::string& keyring);
-
-// Removes the link from a keyring to a key if exists. Return non-zero if error happens.
-int Unlink(key_serial_t key, const std::string& keyring);
-
-// Apply key-linking to a keyring. Return non-zero if error happens.
-int RestrictKeyring(const std::string& keyring);
-
-// Retrieves a key's security context. Return the context string, or empty string on error.
-std::string RetrieveSecurityContext(key_serial_t key);
diff --git a/liblog/Android.bp b/liblog/Android.bp
index c38d8cd..c40c5ef 100644
--- a/liblog/Android.bp
+++ b/liblog/Android.bp
@@ -15,7 +15,6 @@
//
liblog_sources = [
- "config_write.cpp",
"log_event_list.cpp",
"log_event_write.cpp",
"logger_lock.cpp",
@@ -23,7 +22,6 @@
"logger_read.cpp",
"logger_write.cpp",
"logprint.cpp",
- "stderr_write.cpp",
]
liblog_host_sources = [
"fake_log_device.cpp",
@@ -108,7 +106,9 @@
},
cflags: [
+ "-Wall",
"-Werror",
+ "-Wextra",
// This is what we want to do:
// liblog_cflags := $(shell \
// sed -n \
diff --git a/liblog/README.md b/liblog/README.md
index 98bee9f..871399a 100644
--- a/liblog/README.md
+++ b/liblog/README.md
@@ -96,11 +96,6 @@
int android_log_destroy(android_log_context *ctx)
- #include <log/log_transport.h>
-
- int android_set_log_transport(int transport_flag)
- int android_get_log_transport()
-
Description
-----------
@@ -144,11 +139,6 @@
that was used when opening the sub-log. It is recommended to open the log `ANDROID_LOG_RDONLY` in
these cases.
-`android_set_log_transport()` selects transport filters. Argument is either `LOGGER_DEFAULT`,
-`LOGGER_LOGD`, or `LOGGER_NULL`. Log to logger daemon for default or logd, or drop contents on floor
-respectively. `Both android_set_log_transport()` and `android_get_log_transport()` return the
-current transport mask, or a negative errno for any problems.
-
Errors
------
diff --git a/liblog/config_write.cpp b/liblog/config_write.cpp
deleted file mode 100644
index d454379..0000000
--- a/liblog/config_write.cpp
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Copyright (C) 2016 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.
- */
-
-#include <log/log_transport.h>
-
-#include "config_write.h"
-#include "logger.h"
-
-struct listnode __android_log_transport_write = {&__android_log_transport_write,
- &__android_log_transport_write};
-struct listnode __android_log_persist_write = {&__android_log_persist_write,
- &__android_log_persist_write};
-
-static void __android_log_add_transport(struct listnode* list,
- struct android_log_transport_write* transport) {
- uint32_t i;
-
- /* Try to keep one functioning transport for each log buffer id */
- for (i = LOG_ID_MIN; i < LOG_ID_MAX; i++) {
- struct android_log_transport_write* transp;
-
- if (list_empty(list)) {
- if (!transport->available || ((*transport->available)(static_cast<log_id_t>(i)) >= 0)) {
- list_add_tail(list, &transport->node);
- return;
- }
- } else {
- write_transport_for_each(transp, list) {
- if (!transp->available) {
- return;
- }
- if (((*transp->available)(static_cast<log_id_t>(i)) < 0) &&
- (!transport->available || ((*transport->available)(static_cast<log_id_t>(i)) >= 0))) {
- list_add_tail(list, &transport->node);
- return;
- }
- }
- }
- }
-}
-
-void __android_log_config_write() {
- if ((__android_log_transport == LOGGER_DEFAULT) || (__android_log_transport & LOGGER_LOGD)) {
-#if (FAKE_LOG_DEVICE == 0)
- extern struct android_log_transport_write logdLoggerWrite;
- extern struct android_log_transport_write pmsgLoggerWrite;
-
- __android_log_add_transport(&__android_log_transport_write, &logdLoggerWrite);
- __android_log_add_transport(&__android_log_persist_write, &pmsgLoggerWrite);
-#else
- extern struct android_log_transport_write fakeLoggerWrite;
-
- __android_log_add_transport(&__android_log_transport_write, &fakeLoggerWrite);
-#endif
- }
-
- if (__android_log_transport & LOGGER_STDERR) {
- extern struct android_log_transport_write stderrLoggerWrite;
-
- /*
- * stderr logger should be primary if we can be the only one, or if
- * already in the primary list. Otherwise land in the persist list.
- * Remember we can be called here if we are already initialized.
- */
- if (list_empty(&__android_log_transport_write)) {
- __android_log_add_transport(&__android_log_transport_write, &stderrLoggerWrite);
- } else {
- struct android_log_transport_write* transp;
- write_transport_for_each(transp, &__android_log_transport_write) {
- if (transp == &stderrLoggerWrite) {
- return;
- }
- }
- __android_log_add_transport(&__android_log_persist_write, &stderrLoggerWrite);
- }
- }
-}
-
-void __android_log_config_write_close() {
- struct android_log_transport_write* transport;
- struct listnode* n;
-
- write_transport_for_each_safe(transport, n, &__android_log_transport_write) {
- transport->logMask = 0;
- list_remove(&transport->node);
- }
- write_transport_for_each_safe(transport, n, &__android_log_persist_write) {
- transport->logMask = 0;
- list_remove(&transport->node);
- }
-}
diff --git a/liblog/config_write.h b/liblog/config_write.h
deleted file mode 100644
index a901f13..0000000
--- a/liblog/config_write.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (C) 2016 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 <cutils/list.h>
-
-#include "log_portability.h"
-
-__BEGIN_DECLS
-
-extern struct listnode __android_log_transport_write;
-extern struct listnode __android_log_persist_write;
-
-#define write_transport_for_each(transp, transports) \
- for ((transp) = node_to_item((transports)->next, \
- struct android_log_transport_write, node); \
- ((transp) != node_to_item((transports), \
- struct android_log_transport_write, node)) && \
- ((transp) != node_to_item((transp)->node.next, \
- struct android_log_transport_write, node)); \
- (transp) = node_to_item((transp)->node.next, \
- struct android_log_transport_write, node))
-
-#define write_transport_for_each_safe(transp, n, transports) \
- for ((transp) = node_to_item((transports)->next, \
- struct android_log_transport_write, node), \
- (n) = (transp)->node.next; \
- ((transp) != node_to_item((transports), \
- struct android_log_transport_write, node)) && \
- ((transp) != \
- node_to_item((n), struct android_log_transport_write, node)); \
- (transp) = node_to_item((n), struct android_log_transport_write, node), \
- (n) = (transp)->node.next)
-
-void __android_log_config_write();
-void __android_log_config_write_close();
-
-__END_DECLS
diff --git a/liblog/fake_writer.cpp b/liblog/fake_writer.cpp
index c0b0e69..4d07caa 100644
--- a/liblog/fake_writer.cpp
+++ b/liblog/fake_writer.cpp
@@ -20,7 +20,6 @@
#include <log/log.h>
-#include "config_write.h"
#include "fake_log_device.h"
#include "log_portability.h"
#include "logger.h"
@@ -32,9 +31,9 @@
static int logFds[(int)LOG_ID_MAX] = {-1, -1, -1, -1, -1, -1};
struct android_log_transport_write fakeLoggerWrite = {
- .node = {&fakeLoggerWrite.node, &fakeLoggerWrite.node},
- .context.priv = &logFds,
.name = "fake",
+ .logMask = 0,
+ .context.priv = &logFds,
.available = NULL,
.open = fakeOpen,
.close = fakeClose,
diff --git a/liblog/include/log/log_transport.h b/liblog/include/log/log_transport.h
deleted file mode 100644
index b48761a..0000000
--- a/liblog/include/log/log_transport.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
-**
-** Copyright 2017, The Android Open Source Project
-**
-** This file is dual licensed. It may be redistributed and/or modified
-** under the terms of the Apache 2.0 License OR version 2 of the GNU
-** General Public License.
-*/
-
-#pragma once
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * Logging transports, bit mask to select features. Function returns selection.
- */
-/* clang-format off */
-#define LOGGER_DEFAULT 0x00
-#define LOGGER_LOGD 0x01
-#define LOGGER_KERNEL 0x02 /* Reserved/Deprecated */
-#define LOGGER_NULL 0x04 /* Does not release resources of other selections */
-#define LOGGER_RESERVED 0x08 /* Reserved, previously for logging to local memory */
-#define LOGGER_STDERR 0x10 /* logs sent to stderr */
-/* clang-format on */
-
-/* Both return the selected transport flag mask, or negative errno */
-int android_set_log_transport(int transport_flag);
-int android_get_log_transport();
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/liblog/log_event_list.cpp b/liblog/log_event_list.cpp
index b1b527c..18ea930 100644
--- a/liblog/log_event_list.cpp
+++ b/liblog/log_event_list.cpp
@@ -88,7 +88,6 @@
android_log_context create_android_log_parser(const char* msg, size_t len) {
android_log_context_internal* context;
- size_t i;
context =
static_cast<android_log_context_internal*>(calloc(1, sizeof(android_log_context_internal)));
@@ -177,13 +176,6 @@
return 0;
}
-static inline void copy4LE(uint8_t* buf, uint32_t val) {
- buf[0] = val & 0xFF;
- buf[1] = (val >> 8) & 0xFF;
- buf[2] = (val >> 16) & 0xFF;
- buf[3] = (val >> 24) & 0xFF;
-}
-
int android_log_write_int32(android_log_context ctx, int32_t value) {
size_t needed;
android_log_context_internal* context;
@@ -202,22 +194,11 @@
}
context->count[context->list_nest_depth]++;
context->storage[context->pos + 0] = EVENT_TYPE_INT;
- copy4LE(&context->storage[context->pos + 1], value);
+ *reinterpret_cast<int32_t*>(&context->storage[context->pos + 1]) = value;
context->pos += needed;
return 0;
}
-static inline void copy8LE(uint8_t* buf, uint64_t val) {
- buf[0] = val & 0xFF;
- buf[1] = (val >> 8) & 0xFF;
- buf[2] = (val >> 16) & 0xFF;
- buf[3] = (val >> 24) & 0xFF;
- buf[4] = (val >> 32) & 0xFF;
- buf[5] = (val >> 40) & 0xFF;
- buf[6] = (val >> 48) & 0xFF;
- buf[7] = (val >> 56) & 0xFF;
-}
-
int android_log_write_int64(android_log_context ctx, int64_t value) {
size_t needed;
android_log_context_internal* context;
@@ -236,7 +217,7 @@
}
context->count[context->list_nest_depth]++;
context->storage[context->pos + 0] = EVENT_TYPE_LONG;
- copy8LE(&context->storage[context->pos + 1], value);
+ *reinterpret_cast<int64_t*>(&context->storage[context->pos + 1]) = value;
context->pos += needed;
return 0;
}
@@ -268,7 +249,7 @@
}
context->count[context->list_nest_depth]++;
context->storage[context->pos + 0] = EVENT_TYPE_STRING;
- copy4LE(&context->storage[context->pos + 1], len);
+ *reinterpret_cast<ssize_t*>(&context->storage[context->pos + 1]) = len;
if (len) {
memcpy(&context->storage[context->pos + 5], value, len);
}
@@ -300,7 +281,7 @@
ivalue = *(uint32_t*)&value;
context->count[context->list_nest_depth]++;
context->storage[context->pos + 0] = EVENT_TYPE_FLOAT;
- copy4LE(&context->storage[context->pos + 1], ivalue);
+ *reinterpret_cast<uint32_t*>(&context->storage[context->pos + 1]) = ivalue;
context->pos += needed;
return 0;
}
@@ -401,22 +382,6 @@
}
/*
- * Extract a 4-byte value from a byte stream.
- */
-static inline uint32_t get4LE(const uint8_t* src) {
- return src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);
-}
-
-/*
- * Extract an 8-byte value from a byte stream.
- */
-static inline uint64_t get8LE(const uint8_t* src) {
- uint32_t low = src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);
- uint32_t high = src[4] | (src[5] << 8) | (src[6] << 16) | (src[7] << 24);
- return ((uint64_t)high << 32) | (uint64_t)low;
-}
-
-/*
* Gets the next element. Parsing errors result in an EVENT_TYPE_UNKNOWN type.
* If there is nothing to process, the complete field is set to non-zero. If
* an EVENT_TYPE_UNKNOWN type is returned once, and the caller does not check
@@ -489,7 +454,7 @@
elem.type = EVENT_TYPE_UNKNOWN;
return elem;
}
- elem.data.int32 = get4LE(&context->storage[pos]);
+ elem.data.int32 = *reinterpret_cast<int32_t*>(&context->storage[pos]);
/* common tangeable object suffix */
pos += elem.len;
elem.complete = !context->list_nest_depth && !context->count[0];
@@ -508,7 +473,7 @@
elem.type = EVENT_TYPE_UNKNOWN;
return elem;
}
- elem.data.int64 = get8LE(&context->storage[pos]);
+ elem.data.int64 = *reinterpret_cast<int64_t*>(&context->storage[pos]);
/* common tangeable object suffix */
pos += elem.len;
elem.complete = !context->list_nest_depth && !context->count[0];
@@ -527,7 +492,7 @@
elem.complete = true;
return elem;
}
- elem.len = get4LE(&context->storage[pos]);
+ elem.len = *reinterpret_cast<int32_t*>(&context->storage[pos]);
pos += sizeof(int32_t);
if ((pos + elem.len) > context->len) {
elem.len = context->len - pos; /* truncate string */
diff --git a/liblog/logd_reader.cpp b/liblog/logd_reader.cpp
index eba305f..e372dce 100644
--- a/liblog/logd_reader.cpp
+++ b/liblog/logd_reader.cpp
@@ -14,7 +14,6 @@
* limitations under the License.
*/
-#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
@@ -67,7 +66,6 @@
struct android_log_transport_context* transp, char* buf, size_t len);
struct android_log_transport_read logdLoggerRead = {
- .node = {&logdLoggerRead.node, &logdLoggerRead.node},
.name = "logd",
.available = logdAvailable,
.version = logdVersion,
diff --git a/liblog/logd_writer.cpp b/liblog/logd_writer.cpp
index c3f72f4..09aaffb 100644
--- a/liblog/logd_writer.cpp
+++ b/liblog/logd_writer.cpp
@@ -14,7 +14,6 @@
* limitations under the License.
*/
-#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
@@ -35,7 +34,6 @@
#include <private/android_filesystem_config.h>
#include <private/android_logger.h>
-#include "config_write.h"
#include "log_portability.h"
#include "logger.h"
#include "uio.h"
@@ -49,9 +47,9 @@
static int logdWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, size_t nr);
struct android_log_transport_write logdLoggerWrite = {
- .node = {&logdLoggerWrite.node, &logdLoggerWrite.node},
- .context.sock = -EBADF,
.name = "logd",
+ .logMask = 0,
+ .context.sock = -EBADF,
.available = logdAvailable,
.open = logdOpen,
.close = logdClose,
@@ -184,9 +182,9 @@
android_log_event_int_t buffer;
header.id = LOG_ID_SECURITY;
- buffer.header.tag = htole32(LIBLOG_LOG_TAG);
+ buffer.header.tag = LIBLOG_LOG_TAG;
buffer.payload.type = EVENT_TYPE_INT;
- buffer.payload.data = htole32(snapshot);
+ buffer.payload.data = snapshot;
newVec[headerLength].iov_base = &buffer;
newVec[headerLength].iov_len = sizeof(buffer);
@@ -202,9 +200,9 @@
android_log_event_int_t buffer;
header.id = LOG_ID_EVENTS;
- buffer.header.tag = htole32(LIBLOG_LOG_TAG);
+ buffer.header.tag = LIBLOG_LOG_TAG;
buffer.payload.type = EVENT_TYPE_INT;
- buffer.payload.data = htole32(snapshot);
+ buffer.payload.data = snapshot;
newVec[headerLength].iov_base = &buffer;
newVec[headerLength].iov_len = sizeof(buffer);
diff --git a/liblog/logger.h b/liblog/logger.h
index 4b4ef5f..8cae66c 100644
--- a/liblog/logger.h
+++ b/liblog/logger.h
@@ -31,12 +31,9 @@
void* priv;
atomic_int sock;
atomic_int fd;
- struct listnode* node;
- atomic_uintptr_t atomic_pointer;
};
struct android_log_transport_write {
- struct listnode node;
const char* name; /* human name to describe the transport */
unsigned logMask; /* mask cache of available() success */
union android_log_context_union context; /* Initialized by static allocation */
@@ -54,7 +51,6 @@
struct android_log_logger;
struct android_log_transport_read {
- struct listnode node;
const char* name; /* human name to describe the transport */
/* Does not cause resources to be taken */
@@ -149,6 +145,4 @@
int __android_log_trylock();
void __android_log_unlock();
-extern int __android_log_transport;
-
__END_DECLS
diff --git a/liblog/logger_write.cpp b/liblog/logger_write.cpp
index 4fbab4b..abcead7 100644
--- a/liblog/logger_write.cpp
+++ b/liblog/logger_write.cpp
@@ -25,27 +25,21 @@
#endif
#include <log/event_tag_map.h>
-#include <log/log_transport.h>
#include <private/android_filesystem_config.h>
#include <private/android_logger.h>
-#include "config_write.h"
#include "log_portability.h"
#include "logger.h"
#include "uio.h"
#define LOG_BUF_SIZE 1024
+android_log_transport_write* android_log_write = nullptr;
+android_log_transport_write* android_log_persist_write = nullptr;
+
static int __write_to_log_init(log_id_t, struct iovec* vec, size_t nr);
static int (*write_to_log)(log_id_t, struct iovec* vec, size_t nr) = __write_to_log_init;
-/*
- * This is used by the C++ code to decide if it should write logs through
- * the C code. Basically, if /dev/socket/logd is available, we're running in
- * the simulator rather than a desktop tool and want to use the device.
- */
-static enum { kLogUninitialized, kLogNotAvailable, kLogAvailable } g_log_status = kLogUninitialized;
-
static int check_log_uid_permissions() {
#if defined(__ANDROID__)
uid_t uid = __android_log_uid();
@@ -104,22 +98,6 @@
}
}
-extern "C" int __android_log_dev_available() {
- struct android_log_transport_write* node;
-
- if (list_empty(&__android_log_transport_write)) {
- return kLogUninitialized;
- }
-
- write_transport_for_each(node, &__android_log_transport_write) {
- __android_log_cache_available(node);
- if (node->logMask) {
- return kLogAvailable;
- }
- }
- return kLogNotAvailable;
-}
-
#if defined(__ANDROID__)
static atomic_uintptr_t tagMap;
#endif
@@ -128,7 +106,6 @@
* Release any logger resources. A new log write will immediately re-acquire.
*/
void __android_log_close() {
- struct android_log_transport_write* transport;
#if defined(__ANDROID__)
EventTagMap* m;
#endif
@@ -147,19 +124,16 @@
* disengenuous use of this function.
*/
- write_transport_for_each(transport, &__android_log_persist_write) {
- if (transport->close) {
- (*transport->close)();
- }
+ if (android_log_write != nullptr) {
+ android_log_write->close();
}
- write_transport_for_each(transport, &__android_log_transport_write) {
- if (transport->close) {
- (*transport->close)();
- }
+ if (android_log_persist_write != nullptr) {
+ android_log_persist_write->close();
}
- __android_log_config_write_close();
+ android_log_write = nullptr;
+ android_log_persist_write = nullptr;
#if defined(__ANDROID__)
/*
@@ -184,59 +158,52 @@
#endif
}
+static bool transport_initialize(android_log_transport_write* transport) {
+ if (transport == nullptr) {
+ return false;
+ }
+
+ __android_log_cache_available(transport);
+ if (!transport->logMask) {
+ return false;
+ }
+
+ // TODO: Do we actually need to call close() if open() fails?
+ if (transport->open() < 0) {
+ transport->close();
+ return false;
+ }
+
+ return true;
+}
+
/* log_init_lock assumed */
static int __write_to_log_initialize() {
- struct android_log_transport_write* transport;
- struct listnode* n;
- int i = 0, ret = 0;
+#if (FAKE_LOG_DEVICE == 0)
+ extern struct android_log_transport_write logdLoggerWrite;
+ extern struct android_log_transport_write pmsgLoggerWrite;
- __android_log_config_write();
- write_transport_for_each_safe(transport, n, &__android_log_transport_write) {
- __android_log_cache_available(transport);
- if (!transport->logMask) {
- list_remove(&transport->node);
- continue;
- }
- if (!transport->open || ((*transport->open)() < 0)) {
- if (transport->close) {
- (*transport->close)();
- }
- list_remove(&transport->node);
- continue;
- }
- ++ret;
- }
- write_transport_for_each_safe(transport, n, &__android_log_persist_write) {
- __android_log_cache_available(transport);
- if (!transport->logMask) {
- list_remove(&transport->node);
- continue;
- }
- if (!transport->open || ((*transport->open)() < 0)) {
- if (transport->close) {
- (*transport->close)();
- }
- list_remove(&transport->node);
- continue;
- }
- ++i;
- }
- if (!ret && !i) {
+ android_log_write = &logdLoggerWrite;
+ android_log_persist_write = &pmsgLoggerWrite;
+#else
+ extern struct android_log_transport_write fakeLoggerWrite;
+
+ android_log_write = &fakeLoggerWrite;
+#endif
+
+ if (!transport_initialize(android_log_write)) {
+ android_log_write = nullptr;
return -ENODEV;
}
- return ret;
-}
+ if (!transport_initialize(android_log_persist_write)) {
+ android_log_persist_write = nullptr;
+ }
-/*
- * Extract a 4-byte value from a byte stream. le32toh open coded
- */
-static inline uint32_t get4LE(const uint8_t* src) {
- return src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);
+ return 1;
}
static int __write_to_log_daemon(log_id_t log_id, struct iovec* vec, size_t nr) {
- struct android_log_transport_write* node;
int ret, save_errno;
struct timespec ts;
size_t len, i;
@@ -302,7 +269,7 @@
}
}
if (m && (m != (EventTagMap*)(uintptr_t)-1LL)) {
- tag = android_lookupEventTag_len(m, &len, get4LE(static_cast<uint8_t*>(vec[0].iov_base)));
+ tag = android_lookupEventTag_len(m, &len, *static_cast<uint32_t*>(vec[0].iov_base));
}
ret = __android_log_is_loggable_len(ANDROID_LOG_INFO, tag, len, ANDROID_LOG_VERBOSE);
if (f) { /* local copy marked for close */
@@ -313,28 +280,11 @@
return -EPERM;
}
} else {
- /* Validate the incoming tag, tag content can not split across iovec */
- char prio = ANDROID_LOG_VERBOSE;
- const char* tag = static_cast<const char*>(vec[0].iov_base);
- size_t len = vec[0].iov_len;
- if (!tag) {
- len = 0;
- }
- if (len > 0) {
- prio = *tag;
- if (len > 1) {
- --len;
- ++tag;
- } else {
- len = vec[1].iov_len;
- tag = ((const char*)vec[1].iov_base);
- if (!tag) {
- len = 0;
- }
- }
- }
+ int prio = *static_cast<int*>(vec[0].iov_base);
+ const char* tag = static_cast<const char*>(vec[1].iov_base);
+ size_t len = vec[1].iov_len;
/* tag must be nul terminated */
- if (tag && strnlen(tag, len) >= len) {
+ if (strnlen(tag, len) >= len) {
tag = NULL;
}
@@ -355,20 +305,17 @@
ret = 0;
i = 1 << log_id;
- write_transport_for_each(node, &__android_log_transport_write) {
- if (node->logMask & i) {
- ssize_t retval;
- retval = (*node->write)(log_id, &ts, vec, nr);
- if (ret >= 0) {
- ret = retval;
- }
+
+ if (android_log_write != nullptr && (android_log_write->logMask & i)) {
+ ssize_t retval;
+ retval = android_log_write->write(log_id, &ts, vec, nr);
+ if (ret >= 0) {
+ ret = retval;
}
}
- write_transport_for_each(node, &__android_log_persist_write) {
- if (node->logMask & i) {
- (void)(*node->write)(log_id, &ts, vec, nr);
- }
+ if (android_log_persist_write != nullptr && (android_log_persist_write->logMask & i)) {
+ android_log_persist_write->write(log_id, &ts, vec, nr);
}
errno = save_errno;
@@ -384,9 +331,6 @@
ret = __write_to_log_initialize();
if (ret < 0) {
__android_log_unlock();
- if (!list_empty(&__android_log_persist_write)) {
- __write_to_log_daemon(log_id, vec, nr);
- }
errno = save_errno;
return ret;
}
@@ -576,81 +520,3 @@
return write_to_log(LOG_ID_SECURITY, vec, 4);
}
-
-static int __write_to_log_null(log_id_t log_id, struct iovec* vec, size_t nr) {
- size_t len, i;
-
- if ((log_id < LOG_ID_MIN) || (log_id >= LOG_ID_MAX)) {
- return -EINVAL;
- }
-
- for (len = i = 0; i < nr; ++i) {
- len += vec[i].iov_len;
- }
- if (!len) {
- return -EINVAL;
- }
- return len;
-}
-
-/* Following functions need access to our internal write_to_log status */
-
-int __android_log_transport;
-
-int android_set_log_transport(int transport_flag) {
- int retval;
-
- if (transport_flag < 0) {
- return -EINVAL;
- }
-
- retval = LOGGER_NULL;
-
- __android_log_lock();
-
- if (transport_flag & LOGGER_NULL) {
- write_to_log = __write_to_log_null;
-
- __android_log_unlock();
-
- return retval;
- }
-
- __android_log_transport &= LOGGER_LOGD | LOGGER_STDERR;
-
- transport_flag &= LOGGER_LOGD | LOGGER_STDERR;
-
- if (__android_log_transport != transport_flag) {
- __android_log_transport = transport_flag;
- __android_log_config_write_close();
-
- write_to_log = __write_to_log_init;
- /* generically we only expect these two values for write_to_log */
- } else if ((write_to_log != __write_to_log_init) && (write_to_log != __write_to_log_daemon)) {
- write_to_log = __write_to_log_init;
- }
-
- retval = __android_log_transport;
-
- __android_log_unlock();
-
- return retval;
-}
-
-int android_get_log_transport() {
- int ret = LOGGER_DEFAULT;
-
- __android_log_lock();
- if (write_to_log == __write_to_log_null) {
- ret = LOGGER_NULL;
- } else {
- __android_log_transport &= LOGGER_LOGD | LOGGER_STDERR;
- ret = __android_log_transport;
- if ((write_to_log != __write_to_log_init) && (write_to_log != __write_to_log_daemon)) {
- ret = -EINVAL;
- }
- }
- __android_log_unlock();
-
- return ret;
-}
diff --git a/liblog/logprint.cpp b/liblog/logprint.cpp
index 3a54445..dd2c797 100644
--- a/liblog/logprint.cpp
+++ b/liblog/logprint.cpp
@@ -291,8 +291,10 @@
return 1;
}
+#ifndef __MINGW32__
static const char tz[] = "TZ";
static const char utc[] = "UTC";
+#endif
/**
* Returns FORMAT_OFF on invalid string
@@ -580,24 +582,6 @@
return 0;
}
-/*
- * Extract a 4-byte value from a byte stream.
- */
-static inline uint32_t get4LE(const uint8_t* src) {
- return src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);
-}
-
-/*
- * Extract an 8-byte value from a byte stream.
- */
-static inline uint64_t get8LE(const uint8_t* src) {
- uint32_t low, high;
-
- low = src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);
- high = src[4] | (src[5] << 8) | (src[6] << 16) | (src[7] << 24);
- return ((uint64_t)high << 32) | (uint64_t)low;
-}
-
static bool findChar(const char** cp, size_t* len, int c) {
while ((*len) && isspace(*(*cp))) {
++(*cp);
@@ -744,7 +728,7 @@
int32_t ival;
if (eventDataLen < 4) return -1;
- ival = get4LE(eventData);
+ ival = *reinterpret_cast<const int32_t*>(eventData);
eventData += 4;
eventDataLen -= 4;
@@ -754,7 +738,7 @@
case EVENT_TYPE_LONG:
/* 64-bit signed long */
if (eventDataLen < 8) return -1;
- lval = get8LE(eventData);
+ lval = *reinterpret_cast<const int64_t*>(eventData);
eventData += 8;
eventDataLen -= 8;
pr_lval:
@@ -774,7 +758,7 @@
float fval;
if (eventDataLen < 4) return -1;
- ival = get4LE(eventData);
+ ival = *reinterpret_cast<const uint32_t*>(eventData);
fval = *(float*)&ival;
eventData += 4;
eventDataLen -= 4;
@@ -795,7 +779,7 @@
unsigned int strLen;
if (eventDataLen < 4) return -1;
- strLen = get4LE(eventData);
+ strLen = *reinterpret_cast<const uint32_t*>(eventData);
eventData += 4;
eventDataLen -= 4;
@@ -1034,7 +1018,7 @@
}
inCount = buf->len;
if (inCount < 4) return -1;
- tagIndex = get4LE(eventData);
+ tagIndex = *reinterpret_cast<const uint32_t*>(eventData);
eventData += 4;
inCount -= 4;
@@ -1189,6 +1173,7 @@
return p - begin;
}
+#ifdef __ANDROID__
static char* readSeconds(char* e, struct timespec* t) {
unsigned long multiplier;
char* p;
@@ -1229,7 +1214,6 @@
return (long long)now->tv_sec * NS_PER_SEC + now->tv_nsec;
}
-#ifdef __ANDROID__
static void convertMonotonic(struct timespec* result, const AndroidLogEntry* entry) {
struct listnode* node;
struct conversionList {
diff --git a/liblog/pmsg_reader.cpp b/liblog/pmsg_reader.cpp
index 81563bc..2db45a1 100644
--- a/liblog/pmsg_reader.cpp
+++ b/liblog/pmsg_reader.cpp
@@ -37,7 +37,6 @@
struct android_log_transport_context* transp);
struct android_log_transport_read pmsgLoggerRead = {
- .node = {&pmsgLoggerRead.node, &pmsgLoggerRead.node},
.name = "pmsg",
.available = pmsgAvailable,
.version = pmsgVersion,
@@ -130,7 +129,6 @@
ssize_t ret;
off_t current, next;
uid_t uid;
- struct android_log_logger* logger;
struct __attribute__((__packed__)) {
android_pmsg_log_header_t p;
android_log_header_t l;
diff --git a/liblog/pmsg_writer.cpp b/liblog/pmsg_writer.cpp
index 4632b32..54980d9 100644
--- a/liblog/pmsg_writer.cpp
+++ b/liblog/pmsg_writer.cpp
@@ -29,7 +29,6 @@
#include <private/android_filesystem_config.h>
#include <private/android_logger.h>
-#include "config_write.h"
#include "log_portability.h"
#include "logger.h"
#include "uio.h"
@@ -40,9 +39,9 @@
static int pmsgWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, size_t nr);
struct android_log_transport_write pmsgLoggerWrite = {
- .node = {&pmsgLoggerWrite.node, &pmsgLoggerWrite.node},
- .context.fd = -1,
.name = "pmsg",
+ .logMask = 0,
+ .context.fd = -1,
.available = pmsgAvailable,
.open = pmsgOpen,
.close = pmsgClose,
@@ -87,13 +86,6 @@
return 1;
}
-/*
- * Extract a 4-byte value from a byte stream.
- */
-static inline uint32_t get4LE(const uint8_t* src) {
- return src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);
-}
-
static int pmsgWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, size_t nr) {
static const unsigned headerLength = 2;
struct iovec newVec[nr + headerLength];
@@ -107,7 +99,7 @@
return -EINVAL;
}
- if (SNET_EVENT_LOG_TAG != get4LE(static_cast<uint8_t*>(vec[0].iov_base))) {
+ if (SNET_EVENT_LOG_TAG != *static_cast<uint32_t*>(vec[0].iov_base)) {
return -EPERM;
}
}
diff --git a/liblog/stderr_write.cpp b/liblog/stderr_write.cpp
deleted file mode 100644
index e76673f..0000000
--- a/liblog/stderr_write.cpp
+++ /dev/null
@@ -1,209 +0,0 @@
-/*
- * Copyright (C) 2017 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.
- */
-
-/*
- * stderr write handler. Output is logcat-like, and responds to
- * logcat's environment variables ANDROID_PRINTF_LOG and
- * ANDROID_LOG_TAGS to filter output.
- *
- * This transport only provides a writer, that means that it does not
- * provide an End-To-End capability as the logs are effectively _lost_
- * to the stderr file stream. The purpose of this transport is to
- * supply a means for command line tools to report their logging
- * to the stderr stream, in line with all other activities.
- */
-
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include <log/event_tag_map.h>
-#include <log/log.h>
-#include <log/logprint.h>
-
-#include "log_portability.h"
-#include "logger.h"
-#include "uio.h"
-
-static int stderrOpen();
-static void stderrClose();
-static int stderrAvailable(log_id_t logId);
-static int stderrWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, size_t nr);
-
-struct stderrContext {
- AndroidLogFormat* logformat;
-#if defined(__ANDROID__)
- EventTagMap* eventTagMap;
-#endif
-};
-
-struct android_log_transport_write stderrLoggerWrite = {
- .node = {&stderrLoggerWrite.node, &stderrLoggerWrite.node},
- .context.priv = NULL,
- .name = "stderr",
- .available = stderrAvailable,
- .open = stderrOpen,
- .close = stderrClose,
- .write = stderrWrite,
-};
-
-static int stderrOpen() {
- struct stderrContext* ctx;
- const char* envStr;
- bool setFormat;
-
- if (!stderr || (fileno(stderr) < 0)) {
- return -EBADF;
- }
-
- if (stderrLoggerWrite.context.priv) {
- return fileno(stderr);
- }
-
- ctx = static_cast<stderrContext*>(calloc(1, sizeof(stderrContext)));
- if (!ctx) {
- return -ENOMEM;
- }
-
- ctx->logformat = android_log_format_new();
- if (!ctx->logformat) {
- free(ctx);
- return -ENOMEM;
- }
-
- envStr = getenv("ANDROID_PRINTF_LOG");
- setFormat = false;
-
- if (envStr) {
- char* formats = strdup(envStr);
- char* sv = NULL;
- char* arg = formats;
- while (!!(arg = strtok_r(arg, ",:; \t\n\r\f", &sv))) {
- AndroidLogPrintFormat format = android_log_formatFromString(arg);
- arg = NULL;
- if (format == FORMAT_OFF) {
- continue;
- }
- if (android_log_setPrintFormat(ctx->logformat, format) <= 0) {
- continue;
- }
- setFormat = true;
- }
- free(formats);
- }
- if (!setFormat) {
- AndroidLogPrintFormat format = android_log_formatFromString("threadtime");
- android_log_setPrintFormat(ctx->logformat, format);
- }
- envStr = getenv("ANDROID_LOG_TAGS");
- if (envStr) {
- android_log_addFilterString(ctx->logformat, envStr);
- }
- stderrLoggerWrite.context.priv = ctx;
-
- return fileno(stderr);
-}
-
-static void stderrClose() {
- stderrContext* ctx = static_cast<stderrContext*>(stderrLoggerWrite.context.priv);
-
- if (ctx) {
- stderrLoggerWrite.context.priv = NULL;
- if (ctx->logformat) {
- android_log_format_free(ctx->logformat);
- ctx->logformat = NULL;
- }
-#if defined(__ANDROID__)
- if (ctx->eventTagMap) {
- android_closeEventTagMap(ctx->eventTagMap);
- ctx->eventTagMap = NULL;
- }
-#endif
- }
-}
-
-static int stderrAvailable(log_id_t logId) {
- if ((logId >= LOG_ID_MAX) || (logId == LOG_ID_KERNEL)) {
- return -EINVAL;
- }
- return 1;
-}
-
-static int stderrWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, size_t nr) {
- struct log_msg log_msg;
- AndroidLogEntry entry;
- char binaryMsgBuf[1024];
- int err;
- size_t i;
- stderrContext* ctx = static_cast<stderrContext*>(stderrLoggerWrite.context.priv);
-
- if (!ctx) return -EBADF;
- if (!vec || !nr) return -EINVAL;
-
- log_msg.entry.len = 0;
- log_msg.entry.hdr_size = sizeof(log_msg.entry);
- log_msg.entry.pid = getpid();
-#ifdef __BIONIC__
- log_msg.entry.tid = gettid();
-#else
- log_msg.entry.tid = getpid();
-#endif
- log_msg.entry.sec = ts->tv_sec;
- log_msg.entry.nsec = ts->tv_nsec;
- log_msg.entry.lid = logId;
- log_msg.entry.uid = __android_log_uid();
-
- for (i = 0; i < nr; ++i) {
- size_t len = vec[i].iov_len;
- if ((log_msg.entry.len + len) > LOGGER_ENTRY_MAX_PAYLOAD) {
- len = LOGGER_ENTRY_MAX_PAYLOAD - log_msg.entry.len;
- }
- if (!len) continue;
- memcpy(log_msg.entry.msg + log_msg.entry.len, vec[i].iov_base, len);
- log_msg.entry.len += len;
- }
-
- if ((logId == LOG_ID_EVENTS) || (logId == LOG_ID_SECURITY)) {
-#if defined(__ANDROID__)
- if (!ctx->eventTagMap) {
- ctx->eventTagMap = android_openEventTagMap(NULL);
- }
-#endif
- err = android_log_processBinaryLogBuffer(&log_msg.entry_v1, &entry,
-#if defined(__ANDROID__)
- ctx->eventTagMap,
-#else
- NULL,
-#endif
- binaryMsgBuf, sizeof(binaryMsgBuf));
- } else {
- err = android_log_processLogBuffer(&log_msg.entry_v1, &entry);
- }
-
- /* print known truncated data, in essence logcat --debug */
- if ((err < 0) && !entry.message) return -EINVAL;
-
- if (!android_log_shouldPrintLine(ctx->logformat, entry.tag, entry.priority)) {
- return log_msg.entry.len;
- }
-
- err = android_log_printLogLine(ctx->logformat, fileno(stderr), &entry);
- if (err < 0) return errno ? -errno : -EINVAL;
- return log_msg.entry.len;
-}
diff --git a/liblog/tests/Android.bp b/liblog/tests/Android.bp
index d9d1a21..45f09f2 100644
--- a/liblog/tests/Android.bp
+++ b/liblog/tests/Android.bp
@@ -54,8 +54,7 @@
],
srcs: [
"libc_test.cpp",
- "liblog_test_default.cpp",
- "liblog_test_stderr.cpp",
+ "liblog_test.cpp",
"log_id_test.cpp",
"log_radio_test.cpp",
"log_read_test.cpp",
diff --git a/liblog/tests/liblog_benchmark.cpp b/liblog/tests/liblog_benchmark.cpp
index 21d12a1..4642b9b 100644
--- a/liblog/tests/liblog_benchmark.cpp
+++ b/liblog/tests/liblog_benchmark.cpp
@@ -17,7 +17,6 @@
#include <fcntl.h>
#include <inttypes.h>
#include <poll.h>
-#include <sys/endian.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#include <sys/types.h>
@@ -30,7 +29,6 @@
#include <benchmark/benchmark.h>
#include <cutils/sockets.h>
#include <log/event_tag_map.h>
-#include <log/log_transport.h>
#include <private/android_logger.h>
BENCHMARK_MAIN();
@@ -74,21 +72,6 @@
}
BENCHMARK(BM_log_maximum);
-static void set_log_null() {
- android_set_log_transport(LOGGER_NULL);
-}
-
-static void set_log_default() {
- android_set_log_transport(LOGGER_DEFAULT);
-}
-
-static void BM_log_maximum_null(benchmark::State& state) {
- set_log_null();
- BM_log_maximum(state);
- set_log_default();
-}
-BENCHMARK(BM_log_maximum_null);
-
/*
* Measure the time it takes to collect the time using
* discrete acquisition (state.PauseTiming() to state.ResumeTiming())
@@ -227,14 +210,14 @@
buffer.header.tag = 0;
buffer.payload.type = EVENT_TYPE_INT;
uint32_t snapshot = 0;
- buffer.payload.data = htole32(snapshot);
+ buffer.payload.data = snapshot;
newVec[2].iov_base = &buffer;
newVec[2].iov_len = sizeof(buffer);
while (state.KeepRunning()) {
++snapshot;
- buffer.payload.data = htole32(snapshot);
+ buffer.payload.data = snapshot;
writev(pstore_fd, newVec, nr);
}
state.PauseTiming();
@@ -303,11 +286,11 @@
buffer->payload.header.tag = 0;
buffer->payload.payload.type = EVENT_TYPE_INT;
uint32_t snapshot = 0;
- buffer->payload.payload.data = htole32(snapshot);
+ buffer->payload.payload.data = snapshot;
while (state.KeepRunning()) {
++snapshot;
- buffer->payload.payload.data = htole32(snapshot);
+ buffer->payload.payload.data = snapshot;
write(pstore_fd, &buffer->pmsg_header,
sizeof(android_pmsg_log_header_t) + sizeof(android_log_header_t) +
sizeof(android_log_event_int_t));
@@ -378,11 +361,11 @@
buffer->payload.header.tag = 0;
buffer->payload.payload.type = EVENT_TYPE_INT;
uint32_t snapshot = 0;
- buffer->payload.payload.data = htole32(snapshot);
+ buffer->payload.payload.data = snapshot;
while (state.KeepRunning()) {
++snapshot;
- buffer->payload.payload.data = htole32(snapshot);
+ buffer->payload.payload.data = snapshot;
write(pstore_fd, &buffer->pmsg_header,
sizeof(android_pmsg_log_header_t) + sizeof(android_log_header_t) +
sizeof(android_log_event_int_t));
@@ -453,11 +436,11 @@
buffer->payload.header.tag = 0;
buffer->payload.payload.type = EVENT_TYPE_INT;
uint32_t snapshot = 0;
- buffer->payload.payload.data = htole32(snapshot);
+ buffer->payload.payload.data = snapshot;
while (state.KeepRunning()) {
++snapshot;
- buffer->payload.payload.data = htole32(snapshot);
+ buffer->payload.payload.data = snapshot;
write(pstore_fd, &buffer->pmsg_header, LOGGER_ENTRY_MAX_PAYLOAD);
}
state.PauseTiming();
@@ -526,11 +509,11 @@
buffer->payload.header.tag = 0;
buffer->payload.payload.type = EVENT_TYPE_INT;
uint32_t snapshot = 0;
- buffer->payload.payload.data = htole32(snapshot);
+ buffer->payload.payload.data = snapshot;
while (state.KeepRunning()) {
++snapshot;
- buffer->payload.payload.data = htole32(snapshot);
+ buffer->payload.payload.data = snapshot;
write(pstore_fd, &buffer->pmsg_header, LOGGER_ENTRY_MAX_PAYLOAD);
}
state.PauseTiming();
@@ -619,13 +602,6 @@
}
BENCHMARK(BM_log_event_overhead_42);
-static void BM_log_event_overhead_null(benchmark::State& state) {
- set_log_null();
- BM_log_event_overhead(state);
- set_log_default();
-}
-BENCHMARK(BM_log_event_overhead_null);
-
/*
* Measure the time it takes to submit the android event logging call
* using discrete acquisition under very-light load (<1% CPU utilization).
@@ -640,15 +616,6 @@
}
BENCHMARK(BM_log_light_overhead);
-static void BM_log_light_overhead_null(benchmark::State& state) {
- set_log_null();
- BM_log_light_overhead(state);
- set_log_default();
-}
-// Default gets out of hand for this test, so we set a reasonable number of
-// iterations for a timely result.
-BENCHMARK(BM_log_light_overhead_null)->Iterations(500);
-
static void caught_latency(int /*signum*/) {
unsigned long long v = 0xDEADBEEFA55A5AA5ULL;
diff --git a/liblog/tests/liblog_test.cpp b/liblog/tests/liblog_test.cpp
index 5a73dc0..34fb909 100644
--- a/liblog/tests/liblog_test.cpp
+++ b/liblog/tests/liblog_test.cpp
@@ -38,26 +38,10 @@
#include <gtest/gtest.h>
#include <log/log_event_list.h>
#include <log/log_properties.h>
-#include <log/log_transport.h>
#include <log/logprint.h>
#include <private/android_filesystem_config.h>
#include <private/android_logger.h>
-#ifndef TEST_PREFIX
-#ifdef TEST_LOGGER
-#define TEST_PREFIX android_set_log_transport(TEST_LOGGER);
-// make sure we always run code despite overrides if compiled for android
-#elif defined(__ANDROID__)
-#define TEST_PREFIX
-#endif
-#endif
-
-#ifdef USING_LOGGER_STDERR
-#define SUPPORTS_END_TO_END 0
-#else
-#define SUPPORTS_END_TO_END 1
-#endif
-
// enhanced version of LOG_FAILURE_RETRY to add support for EAGAIN and
// non-syscall libs. Since we are only using this in the emergency of
// a signal to stuff a terminating code into the logs, we will spin rather
@@ -73,9 +57,6 @@
})
TEST(liblog, __android_log_btwrite) {
-#ifdef TEST_PREFIX
- TEST_PREFIX
-#endif
int intBuf = 0xDEADBEEF;
EXPECT_LT(0,
__android_log_btwrite(0, EVENT_TYPE_INT, &intBuf, sizeof(intBuf)));
@@ -89,7 +70,7 @@
usleep(1000);
}
-#if (defined(__ANDROID__) && defined(USING_LOGGER_DEFAULT))
+#if defined(__ANDROID__)
static std::string popenToString(const std::string& command) {
std::string ret;
@@ -160,9 +141,6 @@
TEST(liblog, __android_log_btwrite__android_logger_list_read) {
#ifdef __ANDROID__
-#ifdef TEST_PREFIX
- TEST_PREFIX
-#endif
struct logger_list* logger_list;
pid_t pid = getpid();
@@ -174,7 +152,6 @@
log_time ts(CLOCK_MONOTONIC);
EXPECT_LT(0, __android_log_btwrite(0, EVENT_TYPE_LONG, &ts, sizeof(ts)));
-#ifdef USING_LOGGER_DEFAULT
// Check that we can close and reopen the logger
bool logdwActiveAfter__android_log_btwrite;
if (getuid() == AID_ROOT) {
@@ -197,11 +174,9 @@
bool logdwActiveAfter__android_log_close = isLogdwActive();
EXPECT_FALSE(logdwActiveAfter__android_log_close);
}
-#endif
log_time ts1(CLOCK_MONOTONIC);
EXPECT_LT(0, __android_log_btwrite(0, EVENT_TYPE_LONG, &ts1, sizeof(ts1)));
-#ifdef USING_LOGGER_DEFAULT
if (getuid() == AID_ROOT) {
#ifndef NO_PSTORE
bool pmsgActiveAfter__android_log_btwrite = isPmsgActive();
@@ -210,7 +185,6 @@
logdwActiveAfter__android_log_btwrite = isLogdwActive();
EXPECT_TRUE(logdwActiveAfter__android_log_btwrite);
}
-#endif
usleep(1000000);
int count = 0;
@@ -244,8 +218,8 @@
}
}
- EXPECT_EQ(SUPPORTS_END_TO_END, count);
- EXPECT_EQ(SUPPORTS_END_TO_END, second_count);
+ EXPECT_EQ(1, count);
+ EXPECT_EQ(1, second_count);
android_logger_list_close(logger_list);
#else
@@ -253,144 +227,8 @@
#endif
}
-#ifdef __ANDROID__
-static void print_transport(const char* prefix, int logger) {
- static const char orstr[] = " | ";
-
- if (!prefix) {
- prefix = "";
- }
- if (logger < 0) {
- fprintf(stderr, "%s%s\n", prefix, strerror(-logger));
- return;
- }
-
- if (logger == LOGGER_DEFAULT) {
- fprintf(stderr, "%sLOGGER_DEFAULT", prefix);
- prefix = orstr;
- }
- if (logger & LOGGER_LOGD) {
- fprintf(stderr, "%sLOGGER_LOGD", prefix);
- prefix = orstr;
- }
- if (logger & LOGGER_KERNEL) {
- fprintf(stderr, "%sLOGGER_KERNEL", prefix);
- prefix = orstr;
- }
- if (logger & LOGGER_NULL) {
- fprintf(stderr, "%sLOGGER_NULL", prefix);
- prefix = orstr;
- }
- if (logger & LOGGER_STDERR) {
- fprintf(stderr, "%sLOGGER_STDERR", prefix);
- prefix = orstr;
- }
- logger &= ~(LOGGER_LOGD | LOGGER_KERNEL | LOGGER_NULL | LOGGER_STDERR);
- if (logger) {
- fprintf(stderr, "%s0x%x", prefix, logger);
- prefix = orstr;
- }
- if (prefix == orstr) {
- fprintf(stderr, "\n");
- }
-}
-#endif
-
-// This test makes little sense standalone, and requires the tests ahead
-// and behind us, to make us whole. We could incorporate a prefix and
-// suffix test to make this standalone, but opted to not complicate this.
-TEST(liblog, android_set_log_transport) {
-#ifdef __ANDROID__
-#ifdef TEST_PREFIX
- TEST_PREFIX
-#endif
-
- int logger = android_get_log_transport();
- print_transport("android_get_log_transport = ", logger);
- EXPECT_NE(LOGGER_NULL, logger);
-
- int ret;
- EXPECT_EQ(LOGGER_NULL, ret = android_set_log_transport(LOGGER_NULL));
- print_transport("android_set_log_transport = ", ret);
- EXPECT_EQ(LOGGER_NULL, ret = android_get_log_transport());
- print_transport("android_get_log_transport = ", ret);
-
- pid_t pid = getpid();
-
- struct logger_list* logger_list;
- ASSERT_TRUE(NULL !=
- (logger_list = android_logger_list_open(
- LOG_ID_EVENTS, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK,
- 1000, pid)));
-
- log_time ts(CLOCK_MONOTONIC);
- EXPECT_LT(0, __android_log_btwrite(0, EVENT_TYPE_LONG, &ts, sizeof(ts)));
-
- usleep(1000000);
-
- int count = 0;
-
- for (;;) {
- log_msg log_msg;
- if (android_logger_list_read(logger_list, &log_msg) <= 0) {
- break;
- }
-
- EXPECT_EQ(log_msg.entry.pid, pid);
-
- if ((log_msg.entry.len != sizeof(android_log_event_long_t)) ||
- (log_msg.id() != LOG_ID_EVENTS)) {
- continue;
- }
-
- android_log_event_long_t* eventData;
- eventData = reinterpret_cast<android_log_event_long_t*>(log_msg.msg());
-
- if (!eventData || (eventData->payload.type != EVENT_TYPE_LONG)) {
- continue;
- }
-
- log_time tx(reinterpret_cast<char*>(&eventData->payload.data));
- if (ts == tx) {
- ++count;
- }
- }
-
- android_logger_list_close(logger_list);
-
- EXPECT_EQ(logger, ret = android_set_log_transport(logger));
- print_transport("android_set_log_transport = ", ret);
- EXPECT_EQ(logger, ret = android_get_log_transport());
- print_transport("android_get_log_transport = ", ret);
-
- // False negative if liblog.__android_log_btwrite__android_logger_list_read
- // fails above, so we will likely succeed. But we will have so many
- // failures elsewhere that it is probably not worthwhile for us to
- // highlight yet another disappointment.
- //
- // We also expect failures in the following tests if the set does not
- // react in an appropriate manner internally, yet passes, so we depend
- // on this test being in the middle of a series of tests performed in
- // the same process.
- EXPECT_EQ(0, count);
-#else
- GTEST_LOG_(INFO) << "This test does nothing.\n";
-#endif
-}
-
-#ifdef TEST_PREFIX
-static inline uint32_t get4LE(const uint8_t* src) {
- return src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);
-}
-
-static inline uint32_t get4LE(const char* src) {
- return get4LE(reinterpret_cast<const uint8_t*>(src));
-}
-#endif
-
static void bswrite_test(const char* message) {
-#ifdef TEST_PREFIX
- TEST_PREFIX
+#ifdef __ANDROID__
struct logger_list* logger_list;
pid_t pid = getpid();
@@ -400,11 +238,7 @@
LOG_ID_EVENTS, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK,
1000, pid)));
-#ifdef __ANDROID__
log_time ts(android_log_clockid());
-#else
- log_time ts(CLOCK_REALTIME);
-#endif
EXPECT_LT(0, __android_log_bswrite(0, message));
size_t num_lines = 1, size = 0, length = 0, total = 0;
@@ -455,7 +289,7 @@
continue;
}
- size_t len = get4LE(reinterpret_cast<char*>(&eventData->length));
+ size_t len = eventData->length;
if (len == total) {
++count;
@@ -486,7 +320,7 @@
}
}
- EXPECT_EQ(SUPPORTS_END_TO_END, count);
+ EXPECT_EQ(1, count);
android_logger_list_close(logger_list);
#else
@@ -516,8 +350,7 @@
}
static void buf_write_test(const char* message) {
-#ifdef TEST_PREFIX
- TEST_PREFIX
+#ifdef __ANDROID__
struct logger_list* logger_list;
pid_t pid = getpid();
@@ -528,11 +361,7 @@
LOG_ID_MAIN, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 1000, pid)));
static const char tag[] = "TEST__android_log_buf_write";
-#ifdef __ANDROID__
log_time ts(android_log_clockid());
-#else
- log_time ts(CLOCK_REALTIME);
-#endif
EXPECT_LT(
0, __android_log_buf_write(LOG_ID_MAIN, ANDROID_LOG_INFO, tag, message));
@@ -590,7 +419,7 @@
android_log_format_free(logformat);
}
- EXPECT_EQ(SUPPORTS_END_TO_END, count);
+ EXPECT_EQ(1, count);
android_logger_list_close(logger_list);
#else
@@ -611,8 +440,7 @@
buf_write_test("\n Hello World \n");
}
-#ifdef USING_LOGGER_DEFAULT // requires blocking reader functionality
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
static unsigned signaled;
static log_time signal_time;
@@ -673,8 +501,7 @@
#endif
TEST(liblog, android_logger_list_read__cpu_signal) {
-#ifdef TEST_PREFIX
- TEST_PREFIX
+#ifdef __ANDROID__
struct logger_list* logger_list;
unsigned long long v = 0xDEADBEEFA55A0000ULL;
@@ -766,7 +593,7 @@
#endif
}
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
/*
* Strictly, we are not allowed to log messages in a signal context, the
* correct way to handle this is to ensure the messages are constructed in
@@ -830,8 +657,7 @@
#endif
TEST(liblog, android_logger_list_read__cpu_thread) {
-#ifdef TEST_PREFIX
- TEST_PREFIX
+#ifdef __ANDROID__
struct logger_list* logger_list;
unsigned long long v = 0xDEADBEAFA55A0000ULL;
@@ -923,9 +749,8 @@
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
}
-#endif // USING_LOGGER_DEFAULT
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
static const char max_payload_tag[] = "TEST_max_payload_and_longish_tag_XXXX";
#define SIZEOF_MAX_PAYLOAD_BUF \
(LOGGER_ENTRY_MAX_PAYLOAD - sizeof(max_payload_tag) - 1)
@@ -1062,10 +887,8 @@
when you depart from me, sorrow abides and happiness\n\
takes his leave.";
-#ifdef USING_LOGGER_DEFAULT
TEST(liblog, max_payload) {
-#ifdef TEST_PREFIX
- TEST_PREFIX
+#ifdef __ANDROID__
pid_t pid = getpid();
char tag[sizeof(max_payload_tag)];
memcpy(tag, max_payload_tag, sizeof(tag));
@@ -1120,22 +943,16 @@
android_logger_list_close(logger_list);
-#if SUPPORTS_END_TO_END
EXPECT_EQ(true, matches);
EXPECT_LE(SIZEOF_MAX_PAYLOAD_BUF, static_cast<size_t>(max_len));
#else
- EXPECT_EQ(false, matches);
-#endif
-#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
}
-#endif
TEST(liblog, __android_log_buf_print__maxtag) {
-#ifdef TEST_PREFIX
- TEST_PREFIX
+#ifdef __ANDROID__
struct logger_list* logger_list;
pid_t pid = getpid();
@@ -1145,11 +962,7 @@
(logger_list = android_logger_list_open(
LOG_ID_MAIN, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 1000, pid)));
-#ifdef __ANDROID__
log_time ts(android_log_clockid());
-#else
- log_time ts(CLOCK_REALTIME);
-#endif
EXPECT_LT(0, __android_log_buf_print(LOG_ID_MAIN, ANDROID_LOG_INFO,
max_payload_buf, max_payload_buf));
@@ -1192,7 +1005,7 @@
android_log_format_free(logformat);
}
- EXPECT_EQ(SUPPORTS_END_TO_END, count);
+ EXPECT_EQ(1, count);
android_logger_list_close(logger_list);
#else
@@ -1201,8 +1014,7 @@
}
TEST(liblog, too_big_payload) {
-#ifdef TEST_PREFIX
- TEST_PREFIX
+#ifdef __ANDROID__
pid_t pid = getpid();
static const char big_payload_tag[] = "TEST_big_payload_XXXX";
char tag[sizeof(big_payload_tag)];
@@ -1254,10 +1066,6 @@
android_logger_list_close(logger_list);
-#if !SUPPORTS_END_TO_END
- max_len =
- max_len ? max_len : LOGGER_ENTRY_MAX_PAYLOAD - sizeof(big_payload_tag);
-#endif
EXPECT_LE(LOGGER_ENTRY_MAX_PAYLOAD - sizeof(big_payload_tag),
static_cast<size_t>(max_len));
@@ -1273,10 +1081,8 @@
#endif
}
-#ifdef USING_LOGGER_DEFAULT
TEST(liblog, dual_reader) {
-#ifdef TEST_PREFIX
- TEST_PREFIX
+#ifdef __ANDROID__
static const int num = 25;
@@ -1331,15 +1137,13 @@
android_logger_list_close(logger_list1);
android_logger_list_close(logger_list2);
- EXPECT_EQ(num * SUPPORTS_END_TO_END, count1);
- EXPECT_EQ((num - 10) * SUPPORTS_END_TO_END, count2);
+ EXPECT_EQ(num, count1);
+ EXPECT_EQ(num - 10, count2);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
}
-#endif
-#ifdef USING_LOGGER_DEFAULT // Do not retest logprint
static bool checkPriForTag(AndroidLogFormat* p_format, const char* tag,
android_LogPriority pri) {
return android_log_shouldPrintLine(p_format, tag, pri) &&
@@ -1415,9 +1219,7 @@
android_log_format_free(p_format);
}
-#endif // USING_LOGGER_DEFAULT
-#ifdef USING_LOGGER_DEFAULT // Do not retest property handling
TEST(liblog, is_loggable) {
#ifdef __ANDROID__
static const char tag[] = "is_loggable";
@@ -1705,14 +1507,11 @@
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
}
-#endif // USING_LOGGER_DEFAULT
// Following tests the specific issues surrounding error handling wrt logd.
// Kills logd and toss all collected data, equivalent to logcat -b all -c,
// except we also return errors to the logging callers.
-#ifdef USING_LOGGER_DEFAULT
#ifdef __ANDROID__
-#ifdef TEST_PREFIX
// helper to liblog.enoent to count end-to-end matching logging messages.
static int count_matching_ts(log_time ts) {
usleep(1000000);
@@ -1747,19 +1546,17 @@
return count;
}
-#endif // TEST_PREFIX
TEST(liblog, enoent) {
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
if (getuid() != 0) {
GTEST_SKIP() << "Skipping test, must be run as root.";
return;
}
- TEST_PREFIX
log_time ts(CLOCK_MONOTONIC);
EXPECT_LT(0, __android_log_btwrite(0, EVENT_TYPE_LONG, &ts, sizeof(ts)));
- EXPECT_EQ(SUPPORTS_END_TO_END, count_matching_ts(ts));
+ EXPECT_EQ(1, count_matching_ts(ts));
// This call will fail unless we are root, beware of any
// test prior to this one playing with setuid and causing interference.
@@ -1800,19 +1597,17 @@
ts = log_time(CLOCK_MONOTONIC);
EXPECT_LT(0, __android_log_btwrite(0, EVENT_TYPE_LONG, &ts, sizeof(ts)));
- EXPECT_EQ(SUPPORTS_END_TO_END, count_matching_ts(ts));
+ EXPECT_EQ(1, count_matching_ts(ts));
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
}
#endif // __ANDROID__
-#endif // USING_LOGGER_DEFAULT
// Below this point we run risks of setuid(AID_SYSTEM) which may affect others.
// Do not retest properties, and cannot log into LOG_ID_SECURITY
-#ifdef USING_LOGGER_DEFAULT
TEST(liblog, __security) {
#ifdef __ANDROID__
static const char persist_key[] = "persist.logd.security";
@@ -2069,13 +1864,11 @@
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
}
-#endif // USING_LOGGER_DEFAULT
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
static void android_errorWriteWithInfoLog_helper(int TAG, const char* SUBTAG,
int UID, const char* payload,
int DATA_LEN, int& count) {
- TEST_PREFIX
struct logger_list* logger_list;
pid_t pid = getpid();
@@ -2111,7 +1904,7 @@
char* original = eventData;
// Tag
- int tag = get4LE(eventData);
+ int tag = *reinterpret_cast<int32_t*>(eventData);
eventData += 4;
if (tag != TAG) {
@@ -2138,7 +1931,7 @@
unsigned subtag_len = strlen(SUBTAG);
if (subtag_len > 32) subtag_len = 32;
- ASSERT_EQ(subtag_len, get4LE(eventData));
+ ASSERT_EQ(subtag_len, *reinterpret_cast<uint32_t*>(eventData));
eventData += 4;
if (memcmp(SUBTAG, eventData, subtag_len)) {
@@ -2150,14 +1943,14 @@
ASSERT_EQ(EVENT_TYPE_INT, eventData[0]);
eventData++;
- ASSERT_EQ(UID, (int)get4LE(eventData));
+ ASSERT_EQ(UID, *reinterpret_cast<int32_t*>(eventData));
eventData += 4;
// Element #3: string type for data
ASSERT_EQ(EVENT_TYPE_STRING, eventData[0]);
eventData++;
- size_t dataLen = get4LE(eventData);
+ size_t dataLen = *reinterpret_cast<int32_t*>(eventData);
eventData += 4;
if (DATA_LEN < 512) ASSERT_EQ(DATA_LEN, (int)dataLen);
@@ -2189,11 +1982,11 @@
#endif
TEST(liblog, android_errorWriteWithInfoLog__android_logger_list_read__typical) {
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
int count;
android_errorWriteWithInfoLog_helper(UNIQUE_TAG(1), "test-subtag", -1,
max_payload_buf, 200, count);
- EXPECT_EQ(SUPPORTS_END_TO_END, count);
+ EXPECT_EQ(1, count);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
@@ -2201,12 +1994,12 @@
TEST(liblog,
android_errorWriteWithInfoLog__android_logger_list_read__data_too_large) {
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
int count;
android_errorWriteWithInfoLog_helper(UNIQUE_TAG(2), "test-subtag", -1,
max_payload_buf, sizeof(max_payload_buf),
count);
- EXPECT_EQ(SUPPORTS_END_TO_END, count);
+ EXPECT_EQ(1, count);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
@@ -2214,7 +2007,7 @@
TEST(liblog,
android_errorWriteWithInfoLog__android_logger_list_read__null_data) {
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
int count;
android_errorWriteWithInfoLog_helper(UNIQUE_TAG(3), "test-subtag", -1, NULL,
200, count);
@@ -2226,12 +2019,12 @@
TEST(liblog,
android_errorWriteWithInfoLog__android_logger_list_read__subtag_too_long) {
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
int count;
android_errorWriteWithInfoLog_helper(
UNIQUE_TAG(4), "abcdefghijklmnopqrstuvwxyz now i know my abc", -1,
max_payload_buf, 200, count);
- EXPECT_EQ(SUPPORTS_END_TO_END, count);
+ EXPECT_EQ(1, count);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
@@ -2245,10 +2038,9 @@
buf_write_test(max_payload_buf);
}
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
static void android_errorWriteLog_helper(int TAG, const char* SUBTAG,
int& count) {
- TEST_PREFIX
struct logger_list* logger_list;
pid_t pid = getpid();
@@ -2270,7 +2062,7 @@
if (!eventData) continue;
// Tag
- int tag = get4LE(eventData);
+ int tag = *reinterpret_cast<int32_t*>(eventData);
eventData += 4;
if (tag != TAG) continue;
@@ -2323,7 +2115,7 @@
}
// Tag
- int tag = get4LE(eventData);
+ int tag = *reinterpret_cast<int32_t*>(eventData);
eventData += 4;
if (tag != TAG) {
@@ -2348,7 +2140,7 @@
ASSERT_EQ(EVENT_TYPE_STRING, eventData[0]);
eventData++;
- ASSERT_EQ(strlen(SUBTAG), get4LE(eventData));
+ ASSERT_EQ(strlen(SUBTAG), *reinterpret_cast<uint32_t*>(eventData));
eventData += 4;
if (memcmp(SUBTAG, eventData, strlen(SUBTAG))) {
@@ -2362,17 +2154,17 @@
#endif
TEST(liblog, android_errorWriteLog__android_logger_list_read__success) {
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
int count;
android_errorWriteLog_helper(UNIQUE_TAG(5), "test-subtag", count);
- EXPECT_EQ(SUPPORTS_END_TO_END, count);
+ EXPECT_EQ(1, count);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
}
TEST(liblog, android_errorWriteLog__android_logger_list_read__null_subtag) {
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
int count;
android_errorWriteLog_helper(UNIQUE_TAG(6), NULL, count);
EXPECT_EQ(0, count);
@@ -2382,7 +2174,7 @@
}
// Do not retest logger list handling
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
static int is_real_element(int type) {
return ((type == EVENT_TYPE_INT) || (type == EVENT_TYPE_LONG) ||
(type == EVENT_TYPE_STRING) || (type == EVENT_TYPE_FLOAT));
@@ -2537,9 +2329,9 @@
return 0;
}
-#endif // TEST_PREFIX
+#endif // __ANDROID__
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
static const char* event_test_int32(uint32_t tag, size_t& expected_len) {
android_log_context ctx;
@@ -2793,7 +2585,6 @@
static void create_android_logger(const char* (*fn)(uint32_t tag,
size_t& expected_len)) {
- TEST_PREFIX
struct logger_list* logger_list;
pid_t pid = getpid();
@@ -2862,7 +2653,7 @@
// test buffer reading API
int buffer_to_string = -1;
if (eventData) {
- snprintf(msgBuf, sizeof(msgBuf), "I/[%" PRIu32 "]", get4LE(eventData));
+ snprintf(msgBuf, sizeof(msgBuf), "I/[%" PRIu32 "]", *reinterpret_cast<uint32_t*>(eventData));
print_barrier();
fprintf(stderr, "%-10s(%5u): ", msgBuf, pid);
memset(msgBuf, 0, sizeof(msgBuf));
@@ -2877,14 +2668,14 @@
EXPECT_EQ(0, strcmp(expected_string, msgBuf));
}
- EXPECT_EQ(SUPPORTS_END_TO_END, count);
+ EXPECT_EQ(1, count);
android_logger_list_close(logger_list);
}
#endif
TEST(liblog, create_android_logger_int32) {
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
create_android_logger(event_test_int32);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
@@ -2892,7 +2683,7 @@
}
TEST(liblog, create_android_logger_int64) {
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
create_android_logger(event_test_int64);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
@@ -2900,7 +2691,7 @@
}
TEST(liblog, create_android_logger_list_int64) {
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
create_android_logger(event_test_list_int64);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
@@ -2908,7 +2699,7 @@
}
TEST(liblog, create_android_logger_simple_automagic_list) {
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
create_android_logger(event_test_simple_automagic_list);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
@@ -2916,7 +2707,7 @@
}
TEST(liblog, create_android_logger_list_empty) {
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
create_android_logger(event_test_list_empty);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
@@ -2924,7 +2715,7 @@
}
TEST(liblog, create_android_logger_complex_nested_list) {
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
create_android_logger(event_test_complex_nested_list);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
@@ -2932,7 +2723,7 @@
}
TEST(liblog, create_android_logger_7_level_prefix) {
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
create_android_logger(event_test_7_level_prefix);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
@@ -2940,7 +2731,7 @@
}
TEST(liblog, create_android_logger_7_level_suffix) {
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
create_android_logger(event_test_7_level_suffix);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
@@ -2948,7 +2739,7 @@
}
TEST(liblog, create_android_logger_android_log_error_write) {
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
create_android_logger(event_test_android_log_error_write);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
@@ -2956,14 +2747,13 @@
}
TEST(liblog, create_android_logger_android_log_error_write_null) {
-#ifdef TEST_PREFIX
+#ifdef __ANDROID__
create_android_logger(event_test_android_log_error_write_null);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
}
-#ifdef USING_LOGGER_DEFAULT // Do not retest logger list handling
TEST(liblog, create_android_logger_overflow) {
android_log_context ctx;
@@ -2990,9 +2780,7 @@
EXPECT_LE(0, android_log_destroy(&ctx));
ASSERT_TRUE(NULL == ctx);
}
-#endif // USING_LOGGER_DEFAULT
-#ifdef USING_LOGGER_DEFAULT // Do not retest pmsg functionality
#ifdef __ANDROID__
#ifndef NO_PSTORE
static const char __pmsg_file[] =
@@ -3129,9 +2917,7 @@
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
}
-#endif // USING_LOGGER_DEFAULT
-#ifdef USING_LOGGER_DEFAULT // Do not retest event mapping functionality
TEST(liblog, android_lookupEventTagNum) {
#ifdef __ANDROID__
EventTagMap* map = android_openEventTagMap(NULL);
@@ -3148,4 +2934,3 @@
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
}
-#endif // USING_LOGGER_DEFAULT
diff --git a/liblog/tests/liblog_test_default.cpp b/liblog/tests/liblog_test_default.cpp
deleted file mode 100644
index 2edea27..0000000
--- a/liblog/tests/liblog_test_default.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#ifdef __ANDROID__
-#include <log/log_transport.h>
-#define TEST_LOGGER LOGGER_DEFAULT
-#endif
-#define USING_LOGGER_DEFAULT
-#include "liblog_test.cpp"
diff --git a/liblog/tests/liblog_test_stderr.cpp b/liblog/tests/liblog_test_stderr.cpp
deleted file mode 100644
index abc1b9c..0000000
--- a/liblog/tests/liblog_test_stderr.cpp
+++ /dev/null
@@ -1,5 +0,0 @@
-#include <log/log_transport.h>
-#define liblog liblog_stderr
-#define TEST_LOGGER LOGGER_STDERR
-#define USING_LOGGER_STDERR
-#include "liblog_test.cpp"
diff --git a/liblog/tests/log_wrap_test.cpp b/liblog/tests/log_wrap_test.cpp
index ebf0b15..c7dd8e8 100644
--- a/liblog/tests/log_wrap_test.cpp
+++ b/liblog/tests/log_wrap_test.cpp
@@ -27,12 +27,9 @@
#include <log/log_properties.h>
#include <log/log_read.h>
#include <log/log_time.h>
-#include <log/log_transport.h>
#ifdef __ANDROID__
static void read_with_wrap() {
- android_set_log_transport(LOGGER_LOGD);
-
// Read the last line in the log to get a starting timestamp. We're assuming
// the log is not empty.
const int mode = ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK;
diff --git a/libmeminfo/tools/procmem.cpp b/libmeminfo/tools/procmem.cpp
index 47881ed..b245f2a 100644
--- a/libmeminfo/tools/procmem.cpp
+++ b/libmeminfo/tools/procmem.cpp
@@ -17,6 +17,7 @@
#include <errno.h>
#include <inttypes.h>
#include <stdlib.h>
+#include <sys/mman.h>
#include <unistd.h>
#include <iostream>
@@ -59,25 +60,25 @@
static void print_separator(std::stringstream& ss) {
if (show_wss) {
- ss << ::android::base::StringPrintf("%7s %7s %7s %7s %7s %7s %7s %s\n", "-------",
+ ss << ::android::base::StringPrintf("%7s %7s %7s %7s %7s %7s %7s %7s %s\n",
"-------", "-------", "-------", "-------", "-------",
- "-------", "");
+ "-------", "-------", "-------", "");
return;
}
- ss << ::android::base::StringPrintf("%7s %7s %7s %7s %7s %7s %7s %7s %s\n", "-------",
+ ss << ::android::base::StringPrintf("%7s %7s %7s %7s %7s %7s %7s %7s %7s %s\n",
"-------", "-------", "-------", "-------", "-------",
- "-------", "-------", "");
+ "-------", "-------", "-------", "-------", "");
}
static void print_header(std::stringstream& ss) {
if (show_wss) {
- ss << ::android::base::StringPrintf("%7s %7s %7s %7s %7s %7s %7s %s\n", "WRss",
+ ss << ::android::base::StringPrintf("%7s %7s %7s %7s %7s %7s %7s %7s %s\n", "WRss",
"WPss", "WUss", "WShCl", "WShDi", "WPrCl", "WPrDi",
- "Name");
+ "Flags", "Name");
} else {
- ss << ::android::base::StringPrintf("%7s %7s %7s %7s %7s %7s %7s %7s %s\n", "Vss",
- "Rss", "Pss", "Uss", "ShCl", "ShDi", "PrCl", "PrDi",
- "Name");
+ ss << ::android::base::StringPrintf("%7s %7s %7s %7s %7s %7s %7s %7s %7s %s\n",
+ "Vss", "Rss", "Pss", "Uss", "ShCl", "ShDi", "PrCl",
+ "PrDi", "Flags", "Name");
}
print_separator(ss);
}
@@ -103,7 +104,15 @@
continue;
}
print_stats(ss, vma_stats);
- ss << vma.name << std::endl;
+
+ // TODO: b/141711064 fix libprocinfo to record (p)rivate or (s)hared flag
+ // for now always report as private
+ std::string flags_str("---p");
+ if (vma.flags & PROT_READ) flags_str[0] = 'r';
+ if (vma.flags & PROT_WRITE) flags_str[1] = 'w';
+ if (vma.flags & PROT_EXEC) flags_str[2] = 'x';
+
+ ss << ::android::base::StringPrintf("%7s ", flags_str.c_str()) << vma.name << std::endl;
}
print_separator(ss);
print_stats(ss, proc_stats);
diff --git a/libnativebridge/CPPLINT.cfg b/libnativebridge/CPPLINT.cfg
new file mode 100644
index 0000000..578047b
--- /dev/null
+++ b/libnativebridge/CPPLINT.cfg
@@ -0,0 +1,19 @@
+#
+# 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.
+#
+
+filter=-build/header_guard
+filter=-whitespace/comments
+filter=-whitespace/parens
diff --git a/libnativeloader/CPPLINT.cfg b/libnativeloader/CPPLINT.cfg
new file mode 100644
index 0000000..db98533
--- /dev/null
+++ b/libnativeloader/CPPLINT.cfg
@@ -0,0 +1,19 @@
+#
+# 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.
+#
+
+filter=-build/header_guard
+filter=-readability/check
+filter=-build/namespaces
diff --git a/libnativeloader/README.md b/libnativeloader/README.md
index 46f6fdd..57b9001 100644
--- a/libnativeloader/README.md
+++ b/libnativeloader/README.md
@@ -43,7 +43,7 @@
- `/vendor/etc/public.libraries.txt`: libraries in `/vendor/lib` that are
specific to the underlying SoC, e.g. GPU, DSP, etc.
- `/{system|product}/etc/public.libraries-<companyname>.txt`: libraries in
-`/{system|system}/lib` that a device manufacturer has newly added. The
+`/{system|product}/lib` that a device manufacturer has newly added. The
libraries should be named as `lib<name>.<companyname>.so` as in
`libFoo.acme.so`.
@@ -73,8 +73,8 @@
linker namespaces and finding an already created linker namespace for a given
classloader.
-`native_loader_namesapces.cpp` implements the class `NativeLoaderNamespace` that
-models a linker namespace. It's main job is to abstract the two types of the
+`native_loader_namespace.cpp` implements the class `NativeLoaderNamespace` that
+models a linker namespace. Its main job is to abstract the two types of the
dynamic linker interface so that other parts of this library do not have to know
the differences of the interfaces.
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 7c191be..7b6dde2 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -117,43 +117,11 @@
bool SetProcessProfiles(uid_t uid, pid_t pid, const std::vector<std::string>& profiles,
bool use_fd_cache) {
- const TaskProfiles& tp = TaskProfiles::GetInstance();
-
- for (const auto& name : profiles) {
- TaskProfile* profile = tp.GetProfile(name);
- if (profile != nullptr) {
- if (use_fd_cache) {
- profile->EnableResourceCaching();
- }
- if (!profile->ExecuteForProcess(uid, pid)) {
- PLOG(WARNING) << "Failed to apply " << name << " process profile";
- }
- } else {
- PLOG(WARNING) << "Failed to find " << name << "process profile";
- }
- }
-
- return true;
+ return TaskProfiles::GetInstance().SetProcessProfiles(uid, pid, profiles, use_fd_cache);
}
bool SetTaskProfiles(int tid, const std::vector<std::string>& profiles, bool use_fd_cache) {
- const TaskProfiles& tp = TaskProfiles::GetInstance();
-
- for (const auto& name : profiles) {
- TaskProfile* profile = tp.GetProfile(name);
- if (profile != nullptr) {
- if (use_fd_cache) {
- profile->EnableResourceCaching();
- }
- if (!profile->ExecuteForTask(tid)) {
- PLOG(WARNING) << "Failed to apply " << name << " task profile";
- }
- } else {
- PLOG(WARNING) << "Failed to find " << name << "task profile";
- }
- }
-
- return true;
+ return TaskProfiles::GetInstance().SetTaskProfiles(tid, profiles, use_fd_cache);
}
static std::string ConvertUidToPath(const char* cgroup, uid_t uid) {
diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index 74a39cd..608f007 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -15,7 +15,6 @@
"Controller": "cpuset",
"File": "top-app/cpus"
},
-
{
"Name": "MemLimit",
"Controller": "memory",
@@ -494,5 +493,52 @@
}
]
}
+ ],
+
+ "AggregateProfiles": [
+ {
+ "Name": "SCHED_SP_DEFAULT",
+ "Profiles": [ "TimerSlackNormal" ]
+ },
+ {
+ "Name": "SCHED_SP_BACKGROUND",
+ "Profiles": [ "HighEnergySaving", "LowIoPriority", "TimerSlackHigh" ]
+ },
+ {
+ "Name": "SCHED_SP_FOREGROUND",
+ "Profiles": [ "HighPerformance", "HighIoPriority", "TimerSlackNormal" ]
+ },
+ {
+ "Name": "SCHED_SP_TOP_APP",
+ "Profiles": [ "MaxPerformance", "MaxIoPriority", "TimerSlackNormal" ]
+ },
+ {
+ "Name": "SCHED_SP_RT_APP",
+ "Profiles": [ "RealtimePerformance", "MaxIoPriority", "TimerSlackNormal" ]
+ },
+ {
+ "Name": "CPUSET_SP_DEFAULT",
+ "Profiles": [ "TimerSlackNormal" ]
+ },
+ {
+ "Name": "CPUSET_SP_BACKGROUND",
+ "Profiles": [ "HighEnergySaving", "ProcessCapacityLow", "LowIoPriority", "TimerSlackHigh" ]
+ },
+ {
+ "Name": "CPUSET_SP_FOREGROUND",
+ "Profiles": [ "HighPerformance", "ProcessCapacityHigh", "HighIoPriority", "TimerSlackNormal" ]
+ },
+ {
+ "Name": "CPUSET_SP_TOP_APP",
+ "Profiles": [ "MaxPerformance", "ProcessCapacityMax", "MaxIoPriority", "TimerSlackNormal" ]
+ },
+ {
+ "Name": "CPUSET_SP_SYSTEM",
+ "Profiles": [ "ServiceCapacityLow", "TimerSlackNormal" ]
+ },
+ {
+ "Name": "CPUSET_SP_RESTRICTED",
+ "Profiles": [ "ServiceCapacityRestricted", "TimerSlackNormal" ]
+ }
]
}
diff --git a/libprocessgroup/profiles/task_profiles.proto b/libprocessgroup/profiles/task_profiles.proto
index 578f0d3..1de4395 100644
--- a/libprocessgroup/profiles/task_profiles.proto
+++ b/libprocessgroup/profiles/task_profiles.proto
@@ -18,10 +18,11 @@
package android.profiles;
-// Next: 3
+// Next: 4
message TaskProfiles {
repeated Attribute attributes = 1 [json_name = "Attributes"];
repeated Profile profiles = 2 [json_name = "Profiles"];
+ repeated AggregateProfiles aggregateprofiles = 3 [json_name = "AggregateProfiles"];
}
// Next: 4
@@ -42,3 +43,9 @@
string name = 1 [json_name = "Name"];
map<string, string> params = 2 [json_name = "Params"];
}
+
+// Next: 3
+message AggregateProfiles {
+ string name = 1 [json_name = "Name"];
+ repeated string profiles = 2 [json_name = "Profiles"];
+}
diff --git a/libprocessgroup/sched_policy.cpp b/libprocessgroup/sched_policy.cpp
index c83df1a..6b0ab87 100644
--- a/libprocessgroup/sched_policy.cpp
+++ b/libprocessgroup/sched_policy.cpp
@@ -46,34 +46,17 @@
switch (policy) {
case SP_BACKGROUND:
- return SetTaskProfiles(tid,
- {"HighEnergySaving", "ProcessCapacityLow", "LowIoPriority",
- "TimerSlackHigh"},
- true)
- ? 0
- : -1;
+ return SetTaskProfiles(tid, {"CPUSET_SP_BACKGROUND"}, true) ? 0 : -1;
case SP_FOREGROUND:
case SP_AUDIO_APP:
case SP_AUDIO_SYS:
- return SetTaskProfiles(tid,
- {"HighPerformance", "ProcessCapacityHigh", "HighIoPriority",
- "TimerSlackNormal"},
- true)
- ? 0
- : -1;
+ return SetTaskProfiles(tid, {"CPUSET_SP_FOREGROUND"}, true) ? 0 : -1;
case SP_TOP_APP:
- return SetTaskProfiles(tid,
- {"MaxPerformance", "ProcessCapacityMax", "MaxIoPriority",
- "TimerSlackNormal"},
- true)
- ? 0
- : -1;
+ return SetTaskProfiles(tid, {"CPUSET_SP_TOP_APP"}, true) ? 0 : -1;
case SP_SYSTEM:
- return SetTaskProfiles(tid, {"ServiceCapacityLow", "TimerSlackNormal"}, true) ? 0 : -1;
+ return SetTaskProfiles(tid, {"CPUSET_SP_SYSTEM"}, true) ? 0 : -1;
case SP_RESTRICTED:
- return SetTaskProfiles(tid, {"ServiceCapacityRestricted", "TimerSlackNormal"}, true)
- ? 0
- : -1;
+ return SetTaskProfiles(tid, {"CPUSET_SP_RESTRICTED"}, true) ? 0 : -1;
default:
break;
}
@@ -134,29 +117,17 @@
switch (policy) {
case SP_BACKGROUND:
- return SetTaskProfiles(tid, {"HighEnergySaving", "LowIoPriority", "TimerSlackHigh"},
- true)
- ? 0
- : -1;
+ return SetTaskProfiles(tid, {"SCHED_SP_BACKGROUND"}, true) ? 0 : -1;
case SP_FOREGROUND:
case SP_AUDIO_APP:
case SP_AUDIO_SYS:
- return SetTaskProfiles(tid, {"HighPerformance", "HighIoPriority", "TimerSlackNormal"},
- true)
- ? 0
- : -1;
+ return SetTaskProfiles(tid, {"SCHED_SP_FOREGROUND"}, true) ? 0 : -1;
case SP_TOP_APP:
- return SetTaskProfiles(tid, {"MaxPerformance", "MaxIoPriority", "TimerSlackNormal"},
- true)
- ? 0
- : -1;
+ return SetTaskProfiles(tid, {"SCHED_SP_TOP_APP"}, true) ? 0 : -1;
case SP_RT_APP:
- return SetTaskProfiles(
- tid, {"RealtimePerformance", "MaxIoPriority", "TimerSlackNormal"}, true)
- ? 0
- : -1;
+ return SetTaskProfiles(tid, {"SCHED_SP_RT_APP"}, true) ? 0 : -1;
default:
- return SetTaskProfiles(tid, {"TimerSlackNormal"}, true) ? 0 : -1;
+ return SetTaskProfiles(tid, {"SCHED_SP_DEFAULT"}, true) ? 0 : -1;
}
return 0;
diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index aee5f0c..9447f86 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -268,6 +268,26 @@
return true;
}
+bool ApplyProfileAction::ExecuteForProcess(uid_t uid, pid_t pid) const {
+ for (const auto& profile : profiles_) {
+ profile->EnableResourceCaching();
+ if (!profile->ExecuteForProcess(uid, pid)) {
+ PLOG(WARNING) << "ExecuteForProcess failed for aggregate profile";
+ }
+ }
+ return true;
+}
+
+bool ApplyProfileAction::ExecuteForTask(int tid) const {
+ for (const auto& profile : profiles_) {
+ profile->EnableResourceCaching();
+ if (!profile->ExecuteForTask(tid)) {
+ PLOG(WARNING) << "ExecuteForTask failed for aggregate profile";
+ }
+ }
+ return true;
+}
+
bool TaskProfile::ExecuteForProcess(uid_t uid, pid_t pid) const {
for (const auto& element : elements_) {
if (!element->ExecuteForProcess(uid, pid)) {
@@ -373,15 +393,13 @@
}
}
- std::map<std::string, std::string> params;
-
const Json::Value& profiles_val = root["Profiles"];
for (Json::Value::ArrayIndex i = 0; i < profiles_val.size(); ++i) {
const Json::Value& profile_val = profiles_val[i];
std::string profile_name = profile_val["Name"].asString();
const Json::Value& actions = profile_val["Actions"];
- auto profile = std::make_unique<TaskProfile>();
+ auto profile = std::make_shared<TaskProfile>();
for (Json::Value::ArrayIndex act_idx = 0; act_idx < actions.size(); ++act_idx) {
const Json::Value& action_val = actions[act_idx];
@@ -440,7 +458,38 @@
LOG(WARNING) << "Unknown profile action: " << action_name;
}
}
- profiles_[profile_name] = std::move(profile);
+ profiles_[profile_name] = profile;
+ }
+
+ const Json::Value& aggregateprofiles_val = root["AggregateProfiles"];
+ for (Json::Value::ArrayIndex i = 0; i < aggregateprofiles_val.size(); ++i) {
+ const Json::Value& aggregateprofile_val = aggregateprofiles_val[i];
+
+ std::string aggregateprofile_name = aggregateprofile_val["Name"].asString();
+ const Json::Value& aggregateprofiles = aggregateprofile_val["Profiles"];
+ std::vector<std::shared_ptr<TaskProfile>> profiles;
+ bool ret = true;
+
+ for (Json::Value::ArrayIndex pf_idx = 0; pf_idx < aggregateprofiles.size(); ++pf_idx) {
+ std::string profile_name = aggregateprofiles[pf_idx].asString();
+
+ if (profile_name == aggregateprofile_name) {
+ LOG(WARNING) << "AggregateProfiles: recursive profile name: " << profile_name;
+ ret = false;
+ break;
+ } else if (profiles_.find(profile_name) == profiles_.end()) {
+ LOG(WARNING) << "AggregateProfiles: undefined profile name: " << profile_name;
+ ret = false;
+ break;
+ } else {
+ profiles.push_back(profiles_[profile_name]);
+ }
+ }
+ if (ret) {
+ auto profile = std::make_shared<TaskProfile>();
+ profile->Add(std::make_unique<ApplyProfileAction>(profiles));
+ profiles_[aggregateprofile_name] = profile;
+ }
}
return true;
@@ -463,3 +512,39 @@
}
return nullptr;
}
+
+bool TaskProfiles::SetProcessProfiles(uid_t uid, pid_t pid,
+ const std::vector<std::string>& profiles, bool use_fd_cache) {
+ for (const auto& name : profiles) {
+ TaskProfile* profile = GetProfile(name);
+ if (profile != nullptr) {
+ if (use_fd_cache) {
+ profile->EnableResourceCaching();
+ }
+ if (!profile->ExecuteForProcess(uid, pid)) {
+ PLOG(WARNING) << "Failed to apply " << name << " process profile";
+ }
+ } else {
+ PLOG(WARNING) << "Failed to find " << name << "process profile";
+ }
+ }
+ return true;
+}
+
+bool TaskProfiles::SetTaskProfiles(int tid, const std::vector<std::string>& profiles,
+ bool use_fd_cache) {
+ for (const auto& name : profiles) {
+ TaskProfile* profile = GetProfile(name);
+ if (profile != nullptr) {
+ if (use_fd_cache) {
+ profile->EnableResourceCaching();
+ }
+ if (!profile->ExecuteForTask(tid)) {
+ PLOG(WARNING) << "Failed to apply " << name << " task profile";
+ }
+ } else {
+ PLOG(WARNING) << "Failed to find " << name << "task profile";
+ }
+ }
+ return true;
+}
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index 891d5b5..9f2308c 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -154,6 +154,19 @@
std::vector<std::unique_ptr<ProfileAction>> elements_;
};
+// Set aggregate profile element
+class ApplyProfileAction : public ProfileAction {
+ public:
+ ApplyProfileAction(const std::vector<std::shared_ptr<TaskProfile>>& profiles)
+ : profiles_(profiles) {}
+
+ virtual bool ExecuteForProcess(uid_t uid, pid_t pid) const;
+ virtual bool ExecuteForTask(int tid) const;
+
+ private:
+ std::vector<std::shared_ptr<TaskProfile>> profiles_;
+};
+
class TaskProfiles {
public:
// Should be used by all users
@@ -162,9 +175,12 @@
TaskProfile* GetProfile(const std::string& name) const;
const ProfileAttribute* GetAttribute(const std::string& name) const;
void DropResourceCaching() const;
+ bool SetProcessProfiles(uid_t uid, pid_t pid, const std::vector<std::string>& profiles,
+ bool use_fd_cache);
+ bool SetTaskProfiles(int tid, const std::vector<std::string>& profiles, bool use_fd_cache);
private:
- std::map<std::string, std::unique_ptr<TaskProfile>> profiles_;
+ std::map<std::string, std::shared_ptr<TaskProfile>> profiles_;
std::map<std::string, std::unique_ptr<ProfileAttribute>> attributes_;
TaskProfiles();
diff --git a/libunwindstack/include/unwindstack/MapInfo.h b/libunwindstack/include/unwindstack/MapInfo.h
index 13ce10f..6c5cfc4 100644
--- a/libunwindstack/include/unwindstack/MapInfo.h
+++ b/libunwindstack/include/unwindstack/MapInfo.h
@@ -59,11 +59,14 @@
uint16_t flags = 0;
std::string name;
std::shared_ptr<Elf> elf;
+ // The offset of the beginning of this mapping to the beginning of the
+ // ELF file.
+ // elf_offset == offset - elf_start_offset.
// This value is only non-zero if the offset is non-zero but there is
// no elf signature found at that offset.
uint64_t elf_offset = 0;
- // This value is the offset from the map in memory that is the start
- // of the elf. This is not equal to offset when the linker splits
+ // This value is the offset into the file of the map in memory that is the
+ // start of the elf. This is not equal to offset when the linker splits
// shared libraries into a read-only and read-execute map.
uint64_t elf_start_offset = 0;
diff --git a/libutils/String16.cpp b/libutils/String16.cpp
index 5c3cf32..e2a8c59 100644
--- a/libutils/String16.cpp
+++ b/libutils/String16.cpp
@@ -346,7 +346,6 @@
if (isStaticString()) {
buf = static_cast<SharedBuffer*>(alloc((size() + 1) * sizeof(char16_t)));
if (buf) {
- buf->acquire();
memcpy(buf->data(), mString, (size() + 1) * sizeof(char16_t));
}
} else {
@@ -365,7 +364,6 @@
}
buf = static_cast<SharedBuffer*>(alloc(newSize));
if (buf) {
- buf->acquire();
memcpy(buf->data(), mString, copySize);
}
} else {
diff --git a/lmkd/Android.bp b/lmkd/Android.bp
index 4c5ca03..e8e125b 100644
--- a/lmkd/Android.bp
+++ b/lmkd/Android.bp
@@ -1,3 +1,15 @@
+cc_defaults {
+ name: "stats_defaults",
+
+ product_variables: {
+ use_lmkd_stats_log: {
+ cflags: [
+ "-DLMKD_LOG_STATS"
+ ],
+ },
+ },
+}
+
cc_binary {
name: "lmkd",
@@ -15,13 +27,7 @@
local_include_dirs: ["include"],
cflags: ["-Werror", "-DLMKD_TRACE_KILLS"],
init_rc: ["lmkd.rc"],
- product_variables: {
- use_lmkd_stats_log: {
- cflags: [
- "-DLMKD_LOG_STATS"
- ],
- },
- },
+ defaults: ["stats_defaults"],
logtags: ["event.logtags"],
}
@@ -32,6 +38,7 @@
"-Wall",
"-Werror",
],
+ defaults: ["stats_defaults"],
shared_libs: [
"liblog",
],
diff --git a/lmkd/README.md b/lmkd/README.md
index 656a6ea..8a73692 100644
--- a/lmkd/README.md
+++ b/lmkd/README.md
@@ -60,6 +60,31 @@
any eligible task (fast decision). Default = false
ro.lmk.kill_timeout_ms: duration in ms after a kill when no additional
- kill will be done, Default = 0 (disabled)
+ kill will be done. Default = 0 (disabled)
ro.lmk.debug: enable lmkd debug logs, Default = false
+
+ ro.lmk.swap_free_low_percentage: level of free swap as a percentage of the
+ total swap space used as a threshold to consider
+ the system as swap space starved. Default for
+ low-RAM devices = 10, for high-end devices = 20
+
+ ro.lmk.thrashing_limit: number of workingset refaults as a percentage of
+ the file-backed pagecache size used as a threshold
+ to consider system thrashing its pagecache.
+ Default for low-RAM devices = 30, for high-end
+ devices = 100
+
+ ro.lmk.thrashing_limit_decay: thrashing threshold decay expressed as a
+ percentage of the original threshold used to lower
+ the threshold when system does not recover even
+ after a kill. Default for low-RAM devices = 50,
+ for high-end devices = 10
+
+ ro.lmk.psi_partial_stall_ms: partial PSI stall threshold in milliseconds for
+ triggering low memory notification. Default for
+ low-RAM devices = 200, for high-end devices = 70
+
+ ro.lmk.psi_complete_stall_ms: complete PSI stall threshold in milliseconds for
+ triggering critical memory notification. Default =
+ 700
diff --git a/lmkd/event.logtags b/lmkd/event.logtags
index 065c6db..452f411 100644
--- a/lmkd/event.logtags
+++ b/lmkd/event.logtags
@@ -17,8 +17,8 @@
# Multiple values are separated by commas.
#
# The data type is a number from the following values:
-# 1: int
-# 2: long
+# 1: int32_t
+# 2: int64_t
# 3: string
# 4: list
#
@@ -34,5 +34,5 @@
#
# TODO: generate ".java" and ".h" files with integer constants from this file.
-# for meminfo logs
-10195355 meminfo (MemFree|1),(Cached|1),(SwapCached|1),(Buffers|1),(Shmem|1),(Unevictable|1),(SwapTotal|1),(SwapFree|1),(ActiveAnon|1),(InactiveAnon|1),(ActiveFile|1),(InactiveFile|1),(SReclaimable|1),(SUnreclaim|1),(KernelStack|1),(PageTables|1),(ION_heap|1),(ION_heap_pool|1),(CmaFree|1)
+# for killinfo logs
+10195355 killinfo (Pid|1|5),(Uid|1|5),(OomAdj|1),(MinOomAdj|1),(TaskSize|1),(enum kill_reasons|1|5),(MemFree|1),(Cached|1),(SwapCached|1),(Buffers|1),(Shmem|1),(Unevictable|1),(SwapTotal|1),(SwapFree|1),(ActiveAnon|1),(InactiveAnon|1),(ActiveFile|1),(InactiveFile|1),(SReclaimable|1),(SUnreclaim|1),(KernelStack|1),(PageTables|1),(IonHeap|1),(IonHeapPool|1),(CmaFree|1)
diff --git a/lmkd/lmkd.c b/lmkd/lmkd.c
index f06717d..e3f2bc2 100644
--- a/lmkd/lmkd.c
+++ b/lmkd/lmkd.c
@@ -47,9 +47,7 @@
#include <psi/psi.h>
#include <system/thread_defs.h>
-#ifdef LMKD_LOG_STATS
#include "statslog.h"
-#endif
/*
* Define LMKD_TRACE_KILLS to record lmkd kills in kernel traces
@@ -79,11 +77,14 @@
#define MEMCG_MEMORYSW_USAGE "/dev/memcg/memory.memsw.usage_in_bytes"
#define ZONEINFO_PATH "/proc/zoneinfo"
#define MEMINFO_PATH "/proc/meminfo"
+#define VMSTAT_PATH "/proc/vmstat"
#define PROC_STATUS_TGID_FIELD "Tgid:"
#define LINE_MAX 128
+#define PERCEPTIBLE_APP_ADJ 200
+
/* Android Logger event logtags (see event.logtags) */
-#define MEMINFO_LOG_TAG 10195355
+#define KILLINFO_LOG_TAG 10195355
/* gid containing AID_SYSTEM required */
#define INKERNEL_MINFREE_PATH "/sys/module/lowmemorykiller/parameters/minfree"
@@ -110,15 +111,34 @@
* PSI_WINDOW_SIZE_MS after the event happens.
*/
#define PSI_WINDOW_SIZE_MS 1000
-/* Polling period after initial PSI signal */
-#define PSI_POLL_PERIOD_MS 10
-/* Poll for the duration of one window after initial PSI signal */
-#define PSI_POLL_COUNT (PSI_WINDOW_SIZE_MS / PSI_POLL_PERIOD_MS)
+/* Polling period after PSI signal when pressure is high */
+#define PSI_POLL_PERIOD_SHORT_MS 10
+/* Polling period after PSI signal when pressure is low */
+#define PSI_POLL_PERIOD_LONG_MS 100
#define min(a, b) (((a) < (b)) ? (a) : (b))
+#define max(a, b) (((a) > (b)) ? (a) : (b))
#define FAIL_REPORT_RLIMIT_MS 1000
+/*
+ * System property defaults
+ */
+/* ro.lmk.swap_free_low_percentage property defaults */
+#define DEF_LOW_SWAP_LOWRAM 10
+#define DEF_LOW_SWAP 20
+/* ro.lmk.thrashing_limit property defaults */
+#define DEF_THRASHING_LOWRAM 30
+#define DEF_THRASHING 100
+/* ro.lmk.thrashing_limit_decay property defaults */
+#define DEF_THRASHING_DECAY_LOWRAM 50
+#define DEF_THRASHING_DECAY 10
+/* ro.lmk.psi_partial_stall_ms property defaults */
+#define DEF_PARTIAL_STALL_LOWRAM 200
+#define DEF_PARTIAL_STALL 70
+/* ro.lmk.psi_complete_stall_ms property defaults */
+#define DEF_COMPLETE_STALL 700
+
/* default to old in-kernel interface if no memory pressure events */
static bool use_inkernel_interface = true;
static bool has_inkernel_module;
@@ -159,7 +179,12 @@
static bool use_minfree_levels;
static bool per_app_memcg;
static int swap_free_low_percentage;
+static int psi_partial_stall_ms;
+static int psi_complete_stall_ms;
+static int thrashing_limit_pct;
+static int thrashing_limit_decay_pct;
static bool use_psi_monitors = false;
+static struct kernel_poll_info kpoll_info;
static struct psi_threshold psi_thresholds[VMPRESS_LEVEL_COUNT] = {
{ PSI_SOME, 70 }, /* 70ms out of 1sec for partial stall */
{ PSI_SOME, 100 }, /* 100ms out of 1sec for partial stall */
@@ -168,10 +193,30 @@
static android_log_context ctx;
+enum polling_update {
+ POLLING_DO_NOT_CHANGE,
+ POLLING_START,
+ POLLING_STOP,
+};
+
+/*
+ * Data used for periodic polling for the memory state of the device.
+ * Note that when system is not polling poll_handler is set to NULL,
+ * when polling starts poll_handler gets set and is reset back to
+ * NULL when polling stops.
+ */
+struct polling_params {
+ struct event_handler_info* poll_handler;
+ struct timespec poll_start_tm;
+ struct timespec last_poll_tm;
+ int polling_interval_ms;
+ enum polling_update update;
+};
+
/* data required to handle events */
struct event_handler_info {
int data;
- void (*handler)(int data, uint32_t events);
+ void (*handler)(int data, uint32_t events, struct polling_params *poll_params);
};
/* data required to handle socket events */
@@ -204,37 +249,99 @@
static int lowmem_targets_size;
/* Fields to parse in /proc/zoneinfo */
-enum zoneinfo_field {
- ZI_NR_FREE_PAGES = 0,
- ZI_NR_FILE_PAGES,
- ZI_NR_SHMEM,
- ZI_NR_UNEVICTABLE,
- ZI_WORKINGSET_REFAULT,
- ZI_HIGH,
- ZI_FIELD_COUNT
+/* zoneinfo per-zone fields */
+enum zoneinfo_zone_field {
+ ZI_ZONE_NR_FREE_PAGES = 0,
+ ZI_ZONE_MIN,
+ ZI_ZONE_LOW,
+ ZI_ZONE_HIGH,
+ ZI_ZONE_PRESENT,
+ ZI_ZONE_NR_FREE_CMA,
+ ZI_ZONE_FIELD_COUNT
};
-static const char* const zoneinfo_field_names[ZI_FIELD_COUNT] = {
+static const char* const zoneinfo_zone_field_names[ZI_ZONE_FIELD_COUNT] = {
"nr_free_pages",
- "nr_file_pages",
- "nr_shmem",
- "nr_unevictable",
- "workingset_refault",
+ "min",
+ "low",
"high",
+ "present",
+ "nr_free_cma",
};
-union zoneinfo {
+/* zoneinfo per-zone special fields */
+enum zoneinfo_zone_spec_field {
+ ZI_ZONE_SPEC_PROTECTION = 0,
+ ZI_ZONE_SPEC_PAGESETS,
+ ZI_ZONE_SPEC_FIELD_COUNT,
+};
+
+static const char* const zoneinfo_zone_spec_field_names[ZI_ZONE_SPEC_FIELD_COUNT] = {
+ "protection:",
+ "pagesets",
+};
+
+/* see __MAX_NR_ZONES definition in kernel mmzone.h */
+#define MAX_NR_ZONES 6
+
+union zoneinfo_zone_fields {
struct {
int64_t nr_free_pages;
- int64_t nr_file_pages;
- int64_t nr_shmem;
- int64_t nr_unevictable;
- int64_t workingset_refault;
+ int64_t min;
+ int64_t low;
int64_t high;
- /* fields below are calculated rather than read from the file */
- int64_t totalreserve_pages;
+ int64_t present;
+ int64_t nr_free_cma;
} field;
- int64_t arr[ZI_FIELD_COUNT];
+ int64_t arr[ZI_ZONE_FIELD_COUNT];
+};
+
+struct zoneinfo_zone {
+ union zoneinfo_zone_fields fields;
+ int64_t protection[MAX_NR_ZONES];
+ int64_t max_protection;
+};
+
+/* zoneinfo per-node fields */
+enum zoneinfo_node_field {
+ ZI_NODE_NR_INACTIVE_FILE = 0,
+ ZI_NODE_NR_ACTIVE_FILE,
+ ZI_NODE_WORKINGSET_REFAULT,
+ ZI_NODE_FIELD_COUNT
+};
+
+static const char* const zoneinfo_node_field_names[ZI_NODE_FIELD_COUNT] = {
+ "nr_inactive_file",
+ "nr_active_file",
+ "workingset_refault",
+};
+
+union zoneinfo_node_fields {
+ struct {
+ int64_t nr_inactive_file;
+ int64_t nr_active_file;
+ int64_t workingset_refault;
+ } field;
+ int64_t arr[ZI_NODE_FIELD_COUNT];
+};
+
+struct zoneinfo_node {
+ int id;
+ int zone_count;
+ struct zoneinfo_zone zones[MAX_NR_ZONES];
+ union zoneinfo_node_fields fields;
+};
+
+/* for now two memory nodes is more than enough */
+#define MAX_NR_NODES 2
+
+struct zoneinfo {
+ int node_count;
+ struct zoneinfo_node nodes[MAX_NR_NODES];
+ int64_t totalreserve_pages;
+ int64_t total_inactive_file;
+ int64_t total_active_file;
+ int64_t total_workingset_refault;
};
/* Fields to parse in /proc/meminfo */
@@ -310,6 +417,41 @@
int64_t arr[MI_FIELD_COUNT];
};
+/* Fields to parse in /proc/vmstat */
+enum vmstat_field {
+ VS_FREE_PAGES,
+ VS_INACTIVE_FILE,
+ VS_ACTIVE_FILE,
+ VS_WORKINGSET_REFAULT,
+ VS_PGSCAN_KSWAPD,
+ VS_PGSCAN_DIRECT,
+ VS_PGSCAN_DIRECT_THROTTLE,
+ VS_FIELD_COUNT
+};
+
+static const char* const vmstat_field_names[MI_FIELD_COUNT] = {
+ "nr_free_pages",
+ "nr_inactive_file",
+ "nr_active_file",
+ "workingset_refault",
+ "pgscan_kswapd",
+ "pgscan_direct",
+ "pgscan_direct_throttle",
+};
+
+union vmstat {
+ struct {
+ int64_t nr_free_pages;
+ int64_t nr_inactive_file;
+ int64_t nr_active_file;
+ int64_t workingset_refault;
+ int64_t pgscan_kswapd;
+ int64_t pgscan_direct;
+ int64_t pgscan_direct_throttle;
+ } field;
+ int64_t arr[VS_FIELD_COUNT];
+};
+
enum field_match_result {
NO_MATCH,
PARSE_FAIL,
@@ -334,11 +476,6 @@
int fd;
};
-#ifdef LMKD_LOG_STATS
-static bool enable_stats_log;
-static android_log_context log_ctx;
-#endif
-
#define PIDHASH_SZ 1024
static struct proc *pidhash[PIDHASH_SZ];
#define pid_hashfn(x) ((((x) >> 8) ^ (x)) & (PIDHASH_SZ - 1))
@@ -362,8 +499,9 @@
/* PAGE_SIZE / 1024 */
static long page_k;
-static char* proc_get_name(int pid);
-static void poll_kernel();
+static int clamp(int low, int high, int value) {
+ return max(min(value, high), low);
+}
static bool parse_int64(const char* str, int64_t* ret) {
char* endptr;
@@ -375,20 +513,25 @@
return true;
}
+static int find_field(const char* name, const char* const field_names[], int field_count) {
+ for (int i = 0; i < field_count; i++) {
+ if (!strcmp(name, field_names[i])) {
+ return i;
+ }
+ }
+ return -1;
+}
+
static enum field_match_result match_field(const char* cp, const char* ap,
const char* const field_names[],
int field_count, int64_t* field,
int *field_idx) {
- int64_t val;
- int i;
-
- for (i = 0; i < field_count; i++) {
- if (!strcmp(cp, field_names[i])) {
- *field_idx = i;
- return parse_int64(ap, field) ? PARSE_SUCCESS : PARSE_FAIL;
- }
+ int i = find_field(cp, field_names, field_count);
+ if (i < 0) {
+ return NO_MATCH;
}
- return NO_MATCH;
+ *field_idx = i;
+ return parse_int64(ap, field) ? PARSE_SUCCESS : PARSE_FAIL;
}
/*
@@ -424,28 +567,50 @@
* memory pressure to minimize file opening which by itself requires kernel
* memory allocation and might result in a stall on memory stressed system.
*/
-static int reread_file(struct reread_data *data, char *buf, size_t buf_size) {
+static char *reread_file(struct reread_data *data) {
+ /* start with page-size buffer and increase if needed */
+ static ssize_t buf_size = PAGE_SIZE;
+ static char *new_buf, *buf = NULL;
ssize_t size;
if (data->fd == -1) {
- data->fd = open(data->filename, O_RDONLY | O_CLOEXEC);
- if (data->fd == -1) {
+ /* First-time buffer initialization */
+ if (!buf && (buf = malloc(buf_size)) == NULL) {
+ return NULL;
+ }
+
+ data->fd = TEMP_FAILURE_RETRY(open(data->filename, O_RDONLY | O_CLOEXEC));
+ if (data->fd < 0) {
ALOGE("%s open: %s", data->filename, strerror(errno));
- return -1;
+ return NULL;
}
}
- size = read_all(data->fd, buf, buf_size - 1);
- if (size < 0) {
- ALOGE("%s read: %s", data->filename, strerror(errno));
- close(data->fd);
- data->fd = -1;
- return -1;
+ while (true) {
+ size = read_all(data->fd, buf, buf_size - 1);
+ if (size < 0) {
+ ALOGE("%s read: %s", data->filename, strerror(errno));
+ close(data->fd);
+ data->fd = -1;
+ return NULL;
+ }
+ if (size < buf_size - 1) {
+ break;
+ }
+ /*
+ * Since we are reading /proc files we can't use fstat to find out
+ * the real size of the file. Double the buffer size and keep retrying.
+ */
+ if ((new_buf = realloc(buf, buf_size * 2)) == NULL) {
+ errno = ENOMEM;
+ return NULL;
+ }
+ buf = new_buf;
+ buf_size *= 2;
}
- ALOG_ASSERT((size_t)size < buf_size - 1, "%s too large", data->filename);
buf[size] = 0;
- return 0;
+ return buf;
}
static struct proc *pid_lookup(int pid) {
@@ -598,6 +763,60 @@
return (int)tgid;
}
+static int proc_get_size(int pid) {
+ char path[PATH_MAX];
+ char line[LINE_MAX];
+ int fd;
+ int rss = 0;
+ int total;
+ ssize_t ret;
+
+ /* gid containing AID_READPROC required */
+ snprintf(path, PATH_MAX, "/proc/%d/statm", pid);
+ fd = open(path, O_RDONLY | O_CLOEXEC);
+ if (fd == -1)
+ return -1;
+
+ ret = read_all(fd, line, sizeof(line) - 1);
+ if (ret < 0) {
+ close(fd);
+ return -1;
+ }
+
+ sscanf(line, "%d %d ", &total, &rss);
+ close(fd);
+ return rss;
+}
+
+static char *proc_get_name(int pid) {
+ char path[PATH_MAX];
+ static char line[LINE_MAX];
+ int fd;
+ char *cp;
+ ssize_t ret;
+
+ /* gid containing AID_READPROC required */
+ snprintf(path, PATH_MAX, "/proc/%d/cmdline", pid);
+ fd = open(path, O_RDONLY | O_CLOEXEC);
+ if (fd == -1) {
+ return NULL;
+ }
+ ret = read_all(fd, line, sizeof(line) - 1);
+ close(fd);
+ if (ret < 0) {
+ return NULL;
+ }
+
+ cp = strchr(line, ' ');
+ if (cp) {
+ *cp = '\0';
+ } else {
+ line[ret] = '\0';
+ }
+
+ return line;
+}
+
static void cmd_procprio(LMKD_CTRL_PACKET packet) {
struct proc *procp;
char path[80];
@@ -637,9 +856,7 @@
}
if (use_inkernel_interface) {
-#ifdef LMKD_LOG_STATS
- stats_store_taskname(params.pid, proc_get_name(params.pid));
-#endif
+ stats_store_taskname(params.pid, proc_get_name(params.pid), kpoll_info.poll_fd);
return;
}
@@ -710,16 +927,7 @@
struct lmk_procremove params;
if (use_inkernel_interface) {
-#ifdef LMKD_LOG_STATS
- /* Perform an extra check before the pid is removed, after which it
- * will be impossible for poll_kernel to get the taskname. poll_kernel()
- * is potentially a long-running blocking function; however this method
- * handles AMS requests but does not block AMS.*/
- if (enable_stats_log) {
- poll_kernel();
- }
- stats_remove_taskname(params.pid);
-#endif
+ stats_remove_taskname(params.pid, kpoll_info.poll_fd);
return;
}
@@ -737,9 +945,7 @@
struct proc *next;
if (use_inkernel_interface) {
-#ifdef LMKD_LOG_STATS
stats_purge_tasknames();
-#endif
return;
}
@@ -1002,7 +1208,8 @@
ALOGE("Wrong control socket read length cmd=%d len=%d", cmd, len);
}
-static void ctrl_data_handler(int data, uint32_t events) {
+static void ctrl_data_handler(int data, uint32_t events,
+ struct polling_params *poll_params __unused) {
if (events & EPOLLIN) {
ctrl_command_handler(data);
}
@@ -1017,7 +1224,8 @@
return -1;
}
-static void ctrl_connect_handler(int data __unused, uint32_t events __unused) {
+static void ctrl_connect_handler(int data __unused, uint32_t events __unused,
+ struct polling_params *poll_params __unused) {
struct epoll_event epev;
int free_dscock_idx = get_free_dsock();
@@ -1055,174 +1263,202 @@
maxevents++;
}
-#ifdef LMKD_LOG_STATS
-static void memory_stat_parse_line(char* line, struct memory_stat* mem_st) {
- char key[LINE_MAX + 1];
- int64_t value;
-
- sscanf(line, "%" STRINGIFY(LINE_MAX) "s %" SCNd64 "", key, &value);
-
- if (strcmp(key, "total_") < 0) {
- return;
- }
-
- if (!strcmp(key, "total_pgfault"))
- mem_st->pgfault = value;
- else if (!strcmp(key, "total_pgmajfault"))
- mem_st->pgmajfault = value;
- else if (!strcmp(key, "total_rss"))
- mem_st->rss_in_bytes = value;
- else if (!strcmp(key, "total_cache"))
- mem_st->cache_in_bytes = value;
- else if (!strcmp(key, "total_swap"))
- mem_st->swap_in_bytes = value;
-}
-
-static int memory_stat_from_cgroup(struct memory_stat* mem_st, int pid, uid_t uid) {
- FILE *fp;
- char buf[PATH_MAX];
-
- snprintf(buf, sizeof(buf), MEMCG_PROCESS_MEMORY_STAT_PATH, uid, pid);
-
- fp = fopen(buf, "r");
-
- if (fp == NULL) {
- ALOGE("%s open failed: %s", buf, strerror(errno));
- return -1;
- }
-
- while (fgets(buf, PAGE_SIZE, fp) != NULL) {
- memory_stat_parse_line(buf, mem_st);
- }
- fclose(fp);
-
- return 0;
-}
-
-static int memory_stat_from_procfs(struct memory_stat* mem_st, int pid) {
- char path[PATH_MAX];
- char buffer[PROC_STAT_BUFFER_SIZE];
- int fd, ret;
-
- snprintf(path, sizeof(path), PROC_STAT_FILE_PATH, pid);
- if ((fd = open(path, O_RDONLY | O_CLOEXEC)) < 0) {
- ALOGE("%s open failed: %s", path, strerror(errno));
- return -1;
- }
-
- ret = read(fd, buffer, sizeof(buffer));
- if (ret < 0) {
- ALOGE("%s read failed: %s", path, strerror(errno));
- close(fd);
- return -1;
- }
- close(fd);
-
- // field 10 is pgfault
- // field 12 is pgmajfault
- // field 22 is starttime
- // field 24 is rss_in_pages
- int64_t pgfault = 0, pgmajfault = 0, starttime = 0, rss_in_pages = 0;
- if (sscanf(buffer,
- "%*u %*s %*s %*d %*d %*d %*d %*d %*d %" SCNd64 " %*d "
- "%" SCNd64 " %*d %*u %*u %*d %*d %*d %*d %*d %*d "
- "%" SCNd64 " %*d %" SCNd64 "",
- &pgfault, &pgmajfault, &starttime, &rss_in_pages) != 4) {
- return -1;
- }
- mem_st->pgfault = pgfault;
- mem_st->pgmajfault = pgmajfault;
- mem_st->rss_in_bytes = (rss_in_pages * PAGE_SIZE);
- mem_st->process_start_time_ns = starttime * (NS_PER_SEC / sysconf(_SC_CLK_TCK));
- return 0;
-}
-#endif
-
-/* /prop/zoneinfo parsing routines */
-static int64_t zoneinfo_parse_protection(char *cp) {
+/*
+ * /proc/zoneinfo parsing routines
+ * Expected file format is:
+ *
+ * Node <node_id>, zone <zone_name>
+ * (
+ * per-node stats
+ * (<per-node field name> <value>)+
+ * )?
+ * (pages free <value>
+ * (<per-zone field name> <value>)+
+ * pagesets
+ * (<unused fields>)*
+ * )+
+ * ...
+ */
+static void zoneinfo_parse_protection(char *buf, struct zoneinfo_zone *zone) {
+ int zone_idx;
int64_t max = 0;
- long long zoneval;
char *save_ptr;
- for (cp = strtok_r(cp, "(), ", &save_ptr); cp;
- cp = strtok_r(NULL, "), ", &save_ptr)) {
- zoneval = strtoll(cp, &cp, 0);
+ for (buf = strtok_r(buf, "(), ", &save_ptr), zone_idx = 0;
+ buf && zone_idx < MAX_NR_ZONES;
+ buf = strtok_r(NULL, "), ", &save_ptr), zone_idx++) {
+ long long zoneval = strtoll(buf, &buf, 0);
if (zoneval > max) {
max = (zoneval > INT64_MAX) ? INT64_MAX : zoneval;
}
+ zone->protection[zone_idx] = zoneval;
}
-
- return max;
+ zone->max_protection = max;
}
-static bool zoneinfo_parse_line(char *line, union zoneinfo *zi) {
- char *cp = line;
- char *ap;
- char *save_ptr;
- int64_t val;
- int field_idx;
+static int zoneinfo_parse_zone(char **buf, struct zoneinfo_zone *zone) {
+ for (char *line = strtok_r(NULL, "\n", buf); line;
+ line = strtok_r(NULL, "\n", buf)) {
+ char *cp;
+ char *ap;
+ char *save_ptr;
+ int64_t val;
+ int field_idx;
+ enum field_match_result match_res;
- cp = strtok_r(line, " ", &save_ptr);
- if (!cp) {
- return true;
- }
-
- if (!strcmp(cp, "protection:")) {
- ap = strtok_r(NULL, ")", &save_ptr);
- } else {
- ap = strtok_r(NULL, " ", &save_ptr);
- }
-
- if (!ap) {
- return true;
- }
-
- switch (match_field(cp, ap, zoneinfo_field_names,
- ZI_FIELD_COUNT, &val, &field_idx)) {
- case (PARSE_SUCCESS):
- zi->arr[field_idx] += val;
- break;
- case (NO_MATCH):
- if (!strcmp(cp, "protection:")) {
- zi->field.totalreserve_pages +=
- zoneinfo_parse_protection(ap);
+ cp = strtok_r(line, " ", &save_ptr);
+ if (!cp) {
+ return false;
}
- break;
- case (PARSE_FAIL):
- default:
- return false;
+
+ field_idx = find_field(cp, zoneinfo_zone_spec_field_names, ZI_ZONE_SPEC_FIELD_COUNT);
+ if (field_idx >= 0) {
+ /* special field */
+ if (field_idx == ZI_ZONE_SPEC_PAGESETS) {
+ /* no mode fields we are interested in */
+ return true;
+ }
+
+ /* protection field */
+ ap = strtok_r(NULL, ")", &save_ptr);
+ if (ap) {
+ zoneinfo_parse_protection(ap, zone);
+ }
+ continue;
+ }
+
+ ap = strtok_r(NULL, " ", &save_ptr);
+ if (!ap) {
+ continue;
+ }
+
+ match_res = match_field(cp, ap, zoneinfo_zone_field_names, ZI_ZONE_FIELD_COUNT,
+ &val, &field_idx);
+ if (match_res == PARSE_FAIL) {
+ return false;
+ }
+ if (match_res == PARSE_SUCCESS) {
+ zone->fields.arr[field_idx] = val;
+ }
+ if (field_idx == ZI_ZONE_PRESENT && val == 0) {
+ /* zone is not populated, stop parsing it */
+ return true;
+ }
}
- return true;
+ return false;
}
-static int zoneinfo_parse(union zoneinfo *zi) {
+static int zoneinfo_parse_node(char **buf, struct zoneinfo_node *node) {
+ int fields_to_match = ZI_NODE_FIELD_COUNT;
+
+ for (char *line = strtok_r(NULL, "\n", buf); line;
+ line = strtok_r(NULL, "\n", buf)) {
+ char *cp;
+ char *ap;
+ char *save_ptr;
+ int64_t val;
+ int field_idx;
+ enum field_match_result match_res;
+
+ cp = strtok_r(line, " ", &save_ptr);
+ if (!cp) {
+ return false;
+ }
+
+ ap = strtok_r(NULL, " ", &save_ptr);
+ if (!ap) {
+ return false;
+ }
+
+ match_res = match_field(cp, ap, zoneinfo_node_field_names, ZI_NODE_FIELD_COUNT,
+ &val, &field_idx);
+ if (match_res == PARSE_FAIL) {
+ return false;
+ }
+ if (match_res == PARSE_SUCCESS) {
+ node->fields.arr[field_idx] = val;
+ fields_to_match--;
+ if (!fields_to_match) {
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+static int zoneinfo_parse(struct zoneinfo *zi) {
static struct reread_data file_data = {
.filename = ZONEINFO_PATH,
.fd = -1,
};
- char buf[PAGE_SIZE];
+ char *buf;
char *save_ptr;
char *line;
+ char zone_name[LINE_MAX + 1];
+ struct zoneinfo_node *node = NULL;
+ int node_idx = 0;
+ int zone_idx = 0;
- memset(zi, 0, sizeof(union zoneinfo));
+ memset(zi, 0, sizeof(struct zoneinfo));
- if (reread_file(&file_data, buf, sizeof(buf)) < 0) {
+ if ((buf = reread_file(&file_data)) == NULL) {
return -1;
}
for (line = strtok_r(buf, "\n", &save_ptr); line;
line = strtok_r(NULL, "\n", &save_ptr)) {
- if (!zoneinfo_parse_line(line, zi)) {
- ALOGE("%s parse error", file_data.filename);
- return -1;
+ int node_id;
+ if (sscanf(line, "Node %d, zone %" STRINGIFY(LINE_MAX) "s", &node_id, zone_name) == 2) {
+ if (!node || node->id != node_id) {
+ /* new node is found */
+ if (node) {
+ node->zone_count = zone_idx + 1;
+ node_idx++;
+ if (node_idx == MAX_NR_NODES) {
+ /* max node count exceeded */
+ ALOGE("%s parse error", file_data.filename);
+ return -1;
+ }
+ }
+ node = &zi->nodes[node_idx];
+ node->id = node_id;
+ zone_idx = 0;
+ if (!zoneinfo_parse_node(&save_ptr, node)) {
+ ALOGE("%s parse error", file_data.filename);
+ return -1;
+ }
+ } else {
+ /* new zone is found */
+ zone_idx++;
+ }
+ if (!zoneinfo_parse_zone(&save_ptr, &node->zones[zone_idx])) {
+ ALOGE("%s parse error", file_data.filename);
+ return -1;
+ }
}
}
- zi->field.totalreserve_pages += zi->field.high;
+ if (!node) {
+ ALOGE("%s parse error", file_data.filename);
+ return -1;
+ }
+ node->zone_count = zone_idx + 1;
+ zi->node_count = node_idx + 1;
+ /* calculate totals fields */
+ for (node_idx = 0; node_idx < zi->node_count; node_idx++) {
+ node = &zi->nodes[node_idx];
+ for (zone_idx = 0; zone_idx < node->zone_count; zone_idx++) {
+ struct zoneinfo_zone *zone = &zi->nodes[node_idx].zones[zone_idx];
+ zi->totalreserve_pages += zone->max_protection + zone->fields.field.high;
+ }
+ zi->total_inactive_file += node->fields.field.nr_inactive_file;
+ zi->total_active_file += node->fields.field.nr_active_file;
+ zi->total_workingset_refault += node->fields.field.workingset_refault;
+ }
return 0;
}
-/* /prop/meminfo parsing routines */
+/* /proc/meminfo parsing routines */
static bool meminfo_parse_line(char *line, union meminfo *mi) {
char *cp = line;
char *ap;
@@ -1254,13 +1490,13 @@
.filename = MEMINFO_PATH,
.fd = -1,
};
- char buf[PAGE_SIZE];
+ char *buf;
char *save_ptr;
char *line;
memset(mi, 0, sizeof(union meminfo));
- if (reread_file(&file_data, buf, sizeof(buf)) < 0) {
+ if ((buf = reread_file(&file_data)) == NULL) {
return -1;
}
@@ -1277,7 +1513,70 @@
return 0;
}
-static void meminfo_log(union meminfo *mi) {
+/* /proc/vmstat parsing routines */
+static bool vmstat_parse_line(char *line, union vmstat *vs) {
+ char *cp;
+ char *ap;
+ char *save_ptr;
+ int64_t val;
+ int field_idx;
+ enum field_match_result match_res;
+
+ cp = strtok_r(line, " ", &save_ptr);
+ if (!cp) {
+ return false;
+ }
+
+ ap = strtok_r(NULL, " ", &save_ptr);
+ if (!ap) {
+ return false;
+ }
+
+ match_res = match_field(cp, ap, vmstat_field_names, VS_FIELD_COUNT,
+ &val, &field_idx);
+ if (match_res == PARSE_SUCCESS) {
+ vs->arr[field_idx] = val;
+ }
+ return (match_res != PARSE_FAIL);
+}
+
+static int vmstat_parse(union vmstat *vs) {
+ static struct reread_data file_data = {
+ .filename = VMSTAT_PATH,
+ .fd = -1,
+ };
+ char *buf;
+ char *save_ptr;
+ char *line;
+
+ memset(vs, 0, sizeof(union vmstat));
+
+ if ((buf = reread_file(&file_data)) == NULL) {
+ return -1;
+ }
+
+ for (line = strtok_r(buf, "\n", &save_ptr); line;
+ line = strtok_r(NULL, "\n", &save_ptr)) {
+ if (!vmstat_parse_line(line, vs)) {
+ ALOGE("%s parse error", file_data.filename);
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+static void killinfo_log(struct proc* procp, int min_oom_score, int tasksize,
+ int kill_reason, union meminfo *mi) {
+ /* log process information */
+ android_log_write_int32(ctx, procp->pid);
+ android_log_write_int32(ctx, procp->uid);
+ android_log_write_int32(ctx, procp->oomadj);
+ android_log_write_int32(ctx, min_oom_score);
+ android_log_write_int32(ctx, (int32_t)min(tasksize * page_k, INT32_MAX));
+ android_log_write_int32(ctx, kill_reason);
+
+ /* log meminfo fields */
for (int field_idx = 0; field_idx < MI_FIELD_COUNT; field_idx++) {
android_log_write_int32(ctx, (int32_t)min(mi->arr[field_idx] * page_k, INT32_MAX));
}
@@ -1286,56 +1585,6 @@
android_log_reset(ctx);
}
-static int proc_get_size(int pid) {
- char path[PATH_MAX];
- char line[LINE_MAX];
- int fd;
- int rss = 0;
- int total;
- ssize_t ret;
-
- /* gid containing AID_READPROC required */
- snprintf(path, PATH_MAX, "/proc/%d/statm", pid);
- fd = open(path, O_RDONLY | O_CLOEXEC);
- if (fd == -1)
- return -1;
-
- ret = read_all(fd, line, sizeof(line) - 1);
- if (ret < 0) {
- close(fd);
- return -1;
- }
-
- sscanf(line, "%d %d ", &total, &rss);
- close(fd);
- return rss;
-}
-
-static char *proc_get_name(int pid) {
- char path[PATH_MAX];
- static char line[LINE_MAX];
- int fd;
- char *cp;
- ssize_t ret;
-
- /* gid containing AID_READPROC required */
- snprintf(path, PATH_MAX, "/proc/%d/cmdline", pid);
- fd = open(path, O_RDONLY | O_CLOEXEC);
- if (fd == -1)
- return NULL;
- ret = read_all(fd, line, sizeof(line) - 1);
- close(fd);
- if (ret < 0) {
- return NULL;
- }
-
- cp = strchr(line, ' ');
- if (cp)
- *cp = '\0';
-
- return line;
-}
-
static struct proc *proc_adj_lru(int oomadj) {
return (struct proc *)adjslot_tail(&procadjslot_list[ADJTOSLOT(oomadj)]);
}
@@ -1401,7 +1650,8 @@
static int last_killed_pid = -1;
/* Kill one process specified by procp. Returns the size of the process killed */
-static int kill_one_process(struct proc* procp, int min_oom_score) {
+static int kill_one_process(struct proc* procp, int min_oom_score, int kill_reason,
+ const char *kill_desc, union meminfo *mi) {
int pid = procp->pid;
uid_t uid = procp->uid;
int tgid;
@@ -1409,14 +1659,7 @@
int tasksize;
int r;
int result = -1;
-
-#ifdef LMKD_LOG_STATS
- struct memory_stat mem_st = {};
- int memory_stat_parse_result = -1;
-#else
- /* To prevent unused parameter warning */
- (void)(min_oom_score);
-#endif
+ struct memory_stat *mem_st;
tgid = proc_get_tgid(pid);
if (tgid >= 0 && tgid != pid) {
@@ -1434,50 +1677,42 @@
goto out;
}
-#ifdef LMKD_LOG_STATS
- if (enable_stats_log) {
- if (per_app_memcg) {
- memory_stat_parse_result = memory_stat_from_cgroup(&mem_st, pid, uid);
- } else {
- memory_stat_parse_result = memory_stat_from_procfs(&mem_st, pid);
- }
- }
-#endif
+ mem_st = stats_read_memory_stat(per_app_memcg, pid, uid);
TRACE_KILL_START(pid);
/* CAP_KILL required */
r = kill(pid, SIGKILL);
- set_process_group_and_prio(pid, SP_FOREGROUND, ANDROID_PRIORITY_HIGHEST);
-
- inc_killcnt(procp->oomadj);
- ALOGE("Kill '%s' (%d), uid %d, oom_adj %d to free %ldkB", taskname, pid, uid, procp->oomadj,
- tasksize * page_k);
-
TRACE_KILL_END();
- last_killed_pid = pid;
-
if (r) {
ALOGE("kill(%d): errno=%d", pid, errno);
+ /* Delete process record even when we fail to kill so that we don't get stuck on it */
goto out;
- } else {
-#ifdef LMKD_LOG_STATS
- if (memory_stat_parse_result == 0) {
- stats_write_lmk_kill_occurred(log_ctx, LMK_KILL_OCCURRED, uid, taskname,
- procp->oomadj, mem_st.pgfault, mem_st.pgmajfault, mem_st.rss_in_bytes,
- mem_st.cache_in_bytes, mem_st.swap_in_bytes, mem_st.process_start_time_ns,
- min_oom_score);
- } else if (enable_stats_log) {
- stats_write_lmk_kill_occurred(log_ctx, LMK_KILL_OCCURRED, uid, taskname, procp->oomadj,
- -1, -1, tasksize * BYTES_IN_KILOBYTE, -1, -1, -1,
- min_oom_score);
- }
-#endif
- result = tasksize;
}
+ set_process_group_and_prio(pid, SP_FOREGROUND, ANDROID_PRIORITY_HIGHEST);
+
+ inc_killcnt(procp->oomadj);
+
+ killinfo_log(procp, min_oom_score, tasksize, kill_reason, mi);
+
+ if (kill_desc) {
+ ALOGI("Kill '%s' (%d), uid %d, oom_adj %d to free %ldkB; reason: %s", taskname, pid,
+ uid, procp->oomadj, tasksize * page_k, kill_desc);
+ } else {
+ ALOGI("Kill '%s' (%d), uid %d, oom_adj %d to free %ldkB", taskname, pid,
+ uid, procp->oomadj, tasksize * page_k);
+ }
+
+ last_killed_pid = pid;
+
+ stats_write_lmk_kill_occurred(LMK_KILL_OCCURRED, uid, taskname,
+ procp->oomadj, min_oom_score, tasksize, mem_st);
+
+ result = tasksize;
+
out:
/*
* WARNING: After pid_remove() procp is freed and can't be used!
@@ -1491,13 +1726,11 @@
* Find one process to kill at or above the given oom_adj level.
* Returns size of the killed process.
*/
-static int find_and_kill_process(int min_score_adj) {
+static int find_and_kill_process(int min_score_adj, int kill_reason, const char *kill_desc,
+ union meminfo *mi) {
int i;
int killed_size = 0;
-
-#ifdef LMKD_LOG_STATS
bool lmk_state_change_start = false;
-#endif
for (i = OOM_SCORE_ADJ_MAX; i >= min_score_adj; i--) {
struct proc *procp;
@@ -1509,15 +1742,13 @@
if (!procp)
break;
- killed_size = kill_one_process(procp, min_score_adj);
+ killed_size = kill_one_process(procp, min_score_adj, kill_reason, kill_desc, mi);
if (killed_size >= 0) {
-#ifdef LMKD_LOG_STATS
- if (enable_stats_log && !lmk_state_change_start) {
+ if (!lmk_state_change_start) {
lmk_state_change_start = true;
- stats_write_lmk_state_changed(log_ctx, LMK_STATE_CHANGED,
+ stats_write_lmk_state_changed(LMK_STATE_CHANGED,
LMK_STATE_CHANGE_START);
}
-#endif
break;
}
}
@@ -1526,11 +1757,9 @@
}
}
-#ifdef LMKD_LOG_STATS
- if (enable_stats_log && lmk_state_change_start) {
- stats_write_lmk_state_changed(log_ctx, LMK_STATE_CHANGED, LMK_STATE_CHANGE_STOP);
+ if (lmk_state_change_start) {
+ stats_write_lmk_state_changed(LMK_STATE_CHANGED, LMK_STATE_CHANGE_STOP);
}
-#endif
return killed_size;
}
@@ -1538,9 +1767,9 @@
static int64_t get_memory_usage(struct reread_data *file_data) {
int ret;
int64_t mem_usage;
- char buf[32];
+ char *buf;
- if (reread_file(file_data, buf, sizeof(buf)) < 0) {
+ if ((buf = reread_file(file_data)) == NULL) {
return -1;
}
@@ -1609,14 +1838,276 @@
return false;
}
-static void mp_event_common(int data, uint32_t events __unused) {
+enum zone_watermark {
+ WMARK_MIN = 0,
+ WMARK_LOW,
+ WMARK_HIGH,
+ WMARK_NONE
+};
+
+struct zone_watermarks {
+ long high_wmark;
+ long low_wmark;
+ long min_wmark;
+};
+
+/*
+ * Returns lowest breached watermark or WMARK_NONE.
+ */
+static enum zone_watermark get_lowest_watermark(union meminfo *mi,
+ struct zone_watermarks *watermarks)
+{
+ int64_t nr_free_pages = mi->field.nr_free_pages - mi->field.cma_free;
+
+ if (nr_free_pages < watermarks->min_wmark) {
+ return WMARK_MIN;
+ }
+ if (nr_free_pages < watermarks->low_wmark) {
+ return WMARK_LOW;
+ }
+ if (nr_free_pages < watermarks->high_wmark) {
+ return WMARK_HIGH;
+ }
+ return WMARK_NONE;
+}
+
+void calc_zone_watermarks(struct zoneinfo *zi, struct zone_watermarks *watermarks) {
+ memset(watermarks, 0, sizeof(struct zone_watermarks));
+
+ for (int node_idx = 0; node_idx < zi->node_count; node_idx++) {
+ struct zoneinfo_node *node = &zi->nodes[node_idx];
+ for (int zone_idx = 0; zone_idx < node->zone_count; zone_idx++) {
+ struct zoneinfo_zone *zone = &node->zones[zone_idx];
+
+ if (!zone->fields.field.present) {
+ continue;
+ }
+
+ watermarks->high_wmark += zone->max_protection + zone->fields.field.high;
+ watermarks->low_wmark += zone->max_protection + zone->fields.field.low;
+ watermarks->min_wmark += zone->max_protection + zone->fields.field.min;
+ }
+ }
+}
+
+static void mp_event_psi(int data, uint32_t events, struct polling_params *poll_params) {
+ enum kill_reasons {
+ NONE = -1, /* To denote no kill condition */
+ PRESSURE_AFTER_KILL = 0,
+ NOT_RESPONDING,
+ LOW_SWAP_AND_THRASHING,
+ LOW_MEM_AND_SWAP,
+ LOW_MEM_AND_THRASHING,
+ DIRECT_RECL_AND_THRASHING,
+ KILL_REASON_COUNT
+ };
+ enum reclaim_state {
+ NO_RECLAIM = 0,
+ KSWAPD_RECLAIM,
+ DIRECT_RECLAIM,
+ };
+ static int64_t init_ws_refault;
+ static int64_t base_file_lru;
+ static int64_t init_pgscan_kswapd;
+ static int64_t init_pgscan_direct;
+ static int64_t swap_low_threshold;
+ static bool killing;
+ static int thrashing_limit;
+ static bool in_reclaim;
+ static struct zone_watermarks watermarks;
+ static struct timespec wmark_update_tm;
+
+ union meminfo mi;
+ union vmstat vs;
+ struct timespec curr_tm;
+ int64_t thrashing = 0;
+ bool swap_is_low = false;
+ enum vmpressure_level level = (enum vmpressure_level)data;
+ enum kill_reasons kill_reason = NONE;
+ bool cycle_after_kill = false;
+ enum reclaim_state reclaim = NO_RECLAIM;
+ enum zone_watermark wmark = WMARK_NONE;
+ char kill_desc[LINE_MAX];
+ bool cut_thrashing_limit = false;
+ int min_score_adj = 0;
+
+ /* Skip while still killing a process */
+ if (is_kill_pending()) {
+ /* TODO: replace this quick polling with pidfd polling if kernel supports */
+ goto no_kill;
+ }
+
+ if (clock_gettime(CLOCK_MONOTONIC_COARSE, &curr_tm) != 0) {
+ ALOGE("Failed to get current time");
+ return;
+ }
+
+ if (vmstat_parse(&vs) < 0) {
+ ALOGE("Failed to parse vmstat!");
+ return;
+ }
+
+ if (meminfo_parse(&mi) < 0) {
+ ALOGE("Failed to parse meminfo!");
+ return;
+ }
+
+ /* Reset states after process got killed */
+ if (killing) {
+ killing = false;
+ cycle_after_kill = true;
+ /* Reset file-backed pagecache size and refault amounts after a kill */
+ base_file_lru = vs.field.nr_inactive_file + vs.field.nr_active_file;
+ init_ws_refault = vs.field.workingset_refault;
+ }
+
+ /* Check free swap levels */
+ if (swap_free_low_percentage) {
+ if (!swap_low_threshold) {
+ swap_low_threshold = mi.field.total_swap * swap_free_low_percentage / 100;
+ }
+ swap_is_low = mi.field.free_swap < swap_low_threshold;
+ }
+
+ /* Identify reclaim state */
+ if (vs.field.pgscan_direct > init_pgscan_direct) {
+ init_pgscan_direct = vs.field.pgscan_direct;
+ init_pgscan_kswapd = vs.field.pgscan_kswapd;
+ reclaim = DIRECT_RECLAIM;
+ } else if (vs.field.pgscan_kswapd > init_pgscan_kswapd) {
+ init_pgscan_kswapd = vs.field.pgscan_kswapd;
+ reclaim = KSWAPD_RECLAIM;
+ } else {
+ in_reclaim = false;
+ /* Skip if system is not reclaiming */
+ goto no_kill;
+ }
+
+ if (!in_reclaim) {
+ /* Record file-backed pagecache size when entering reclaim cycle */
+ base_file_lru = vs.field.nr_inactive_file + vs.field.nr_active_file;
+ init_ws_refault = vs.field.workingset_refault;
+ thrashing_limit = thrashing_limit_pct;
+ } else {
+ /* Calculate what % of the file-backed pagecache refaulted so far */
+ thrashing = (vs.field.workingset_refault - init_ws_refault) * 100 / base_file_lru;
+ }
+ in_reclaim = true;
+
+ /*
+ * Refresh watermarks once per min in case user updated one of the margins.
+ * TODO: b/140521024 replace this periodic update with an API for AMS to notify LMKD
+ * that zone watermarks were changed by the system software.
+ */
+ if (watermarks.high_wmark == 0 || get_time_diff_ms(&wmark_update_tm, &curr_tm) > 60000) {
+ struct zoneinfo zi;
+
+ if (zoneinfo_parse(&zi) < 0) {
+ ALOGE("Failed to parse zoneinfo!");
+ return;
+ }
+
+ calc_zone_watermarks(&zi, &watermarks);
+ wmark_update_tm = curr_tm;
+ }
+
+ /* Find out which watermark is breached if any */
+ wmark = get_lowest_watermark(&mi, &watermarks);
+
+ /*
+ * TODO: move this logic into a separate function
+ * Decide if killing a process is necessary and record the reason
+ */
+ if (cycle_after_kill && wmark < WMARK_LOW) {
+ /*
+ * Prevent kills not freeing enough memory which might lead to OOM kill.
+ * This might happen when a process is consuming memory faster than reclaim can
+ * free even after a kill. Mostly happens when running memory stress tests.
+ */
+ kill_reason = PRESSURE_AFTER_KILL;
+ strncpy(kill_desc, "min watermark is breached even after kill", sizeof(kill_desc));
+ } else if (level == VMPRESS_LEVEL_CRITICAL && events != 0) {
+ /*
+ * Device is too busy reclaiming memory which might lead to ANR.
+ * Critical level is triggered when PSI complete stall (all tasks are blocked because
+ * of the memory congestion) breaches the configured threshold.
+ */
+ kill_reason = NOT_RESPONDING;
+ strncpy(kill_desc, "device is not responding", sizeof(kill_desc));
+ } else if (swap_is_low && thrashing > thrashing_limit_pct) {
+ /* Page cache is thrashing while swap is low */
+ kill_reason = LOW_SWAP_AND_THRASHING;
+ snprintf(kill_desc, sizeof(kill_desc), "device is low on swap (%" PRId64
+ "kB < %" PRId64 "kB) and thrashing (%" PRId64 "%%)",
+ mi.field.free_swap * page_k, swap_low_threshold * page_k, thrashing);
+ } else if (swap_is_low && wmark < WMARK_HIGH) {
+ /* Both free memory and swap are low */
+ kill_reason = LOW_MEM_AND_SWAP;
+ snprintf(kill_desc, sizeof(kill_desc), "%s watermark is breached and swap is low (%"
+ PRId64 "kB < %" PRId64 "kB)", wmark > WMARK_LOW ? "min" : "low",
+ mi.field.free_swap * page_k, swap_low_threshold * page_k);
+ } else if (wmark < WMARK_HIGH && thrashing > thrashing_limit) {
+ /* Page cache is thrashing while memory is low */
+ kill_reason = LOW_MEM_AND_THRASHING;
+ snprintf(kill_desc, sizeof(kill_desc), "%s watermark is breached and thrashing (%"
+ PRId64 "%%)", wmark > WMARK_LOW ? "min" : "low", thrashing);
+ cut_thrashing_limit = true;
+ /* Do not kill perceptible apps because of thrashing */
+ min_score_adj = PERCEPTIBLE_APP_ADJ;
+ } else if (reclaim == DIRECT_RECLAIM && thrashing > thrashing_limit) {
+ /* Page cache is thrashing while in direct reclaim (mostly happens on lowram devices) */
+ kill_reason = DIRECT_RECL_AND_THRASHING;
+ snprintf(kill_desc, sizeof(kill_desc), "device is in direct reclaim and thrashing (%"
+ PRId64 "%%)", thrashing);
+ cut_thrashing_limit = true;
+ /* Do not kill perceptible apps because of thrashing */
+ min_score_adj = PERCEPTIBLE_APP_ADJ;
+ }
+
+ /* Kill a process if necessary */
+ if (kill_reason != NONE) {
+ int pages_freed = find_and_kill_process(min_score_adj, kill_reason, kill_desc, &mi);
+ if (pages_freed > 0) {
+ killing = true;
+ if (cut_thrashing_limit) {
+ /*
+ * Cut thrasing limit by thrashing_limit_decay_pct percentage of the current
+ * thrashing limit until the system stops thrashing.
+ */
+ thrashing_limit = (thrashing_limit * (100 - thrashing_limit_decay_pct)) / 100;
+ }
+ }
+ }
+
+no_kill:
+ /*
+ * Start polling after initial PSI event;
+ * extend polling while device is in direct reclaim or process is being killed;
+ * do not extend when kswapd reclaims because that might go on for a long time
+ * without causing memory pressure
+ */
+ if (events || killing || reclaim == DIRECT_RECLAIM) {
+ poll_params->update = POLLING_START;
+ }
+
+ /* Decide the polling interval */
+ if (swap_is_low || killing) {
+ /* Fast polling during and after a kill or when swap is low */
+ poll_params->polling_interval_ms = PSI_POLL_PERIOD_SHORT_MS;
+ } else {
+ /* By default use long intervals */
+ poll_params->polling_interval_ms = PSI_POLL_PERIOD_LONG_MS;
+ }
+}
+
+static void mp_event_common(int data, uint32_t events, struct polling_params *poll_params) {
int ret;
unsigned long long evcount;
int64_t mem_usage, memsw_usage;
int64_t mem_pressure;
enum vmpressure_level lvl;
union meminfo mi;
- union zoneinfo zi;
+ struct zoneinfo zi;
struct timespec curr_tm;
static struct timespec last_kill_tm;
static unsigned long kill_skip_count = 0;
@@ -1653,6 +2144,15 @@
}
}
+ /* Start polling after initial PSI event */
+ if (use_psi_monitors && events) {
+ /* Override polling params only if current event is more critical */
+ if (!poll_params->poll_handler || data > poll_params->poll_handler->data) {
+ poll_params->polling_interval_ms = PSI_POLL_PERIOD_SHORT_MS;
+ poll_params->update = POLLING_START;
+ }
+ }
+
if (clock_gettime(CLOCK_MONOTONIC_COARSE, &curr_tm) != 0) {
ALOGE("Failed to get current time");
return;
@@ -1683,7 +2183,7 @@
if (use_minfree_levels) {
int i;
- other_free = mi.field.nr_free_pages - zi.field.totalreserve_pages;
+ other_free = mi.field.nr_free_pages - zi.totalreserve_pages;
if (mi.field.nr_file_pages > (mi.field.shmem + mi.field.unevictable + mi.field.swap_cached)) {
other_file = (mi.field.nr_file_pages - mi.field.shmem -
mi.field.unevictable - mi.field.swap_cached);
@@ -1765,12 +2265,10 @@
do_kill:
if (low_ram_device) {
/* For Go devices kill only one task */
- if (find_and_kill_process(level_oomadj[level]) == 0) {
+ if (find_and_kill_process(level_oomadj[level], -1, NULL, &mi) == 0) {
if (debug_process_killing) {
ALOGI("Nothing to kill");
}
- } else {
- meminfo_log(&mi);
}
} else {
int pages_freed;
@@ -1790,7 +2288,7 @@
min_score_adj = level_oomadj[level];
}
- pages_freed = find_and_kill_process(min_score_adj);
+ pages_freed = find_and_kill_process(min_score_adj, -1, NULL, &mi);
if (pages_freed == 0) {
/* Rate limit kill reports when nothing was reclaimed */
@@ -1803,15 +2301,13 @@
last_kill_tm = curr_tm;
}
- /* Log meminfo whenever we kill or when report rate limit allows */
- meminfo_log(&mi);
-
+ /* Log whenever we kill or when report rate limit allows */
if (use_minfree_levels) {
ALOGI("Reclaimed %ldkB, cache(%ldkB) and "
"free(%" PRId64 "kB)-reserved(%" PRId64 "kB) below min(%ldkB) for oom_adj %d",
pages_freed * page_k,
other_file * page_k, mi.field.nr_free_pages * page_k,
- zi.field.totalreserve_pages * page_k,
+ zi.totalreserve_pages * page_k,
minfree * page_k, min_score_adj);
} else {
ALOGI("Reclaimed %ldkB at oom_adj %d",
@@ -1827,8 +2323,15 @@
}
}
-static bool init_mp_psi(enum vmpressure_level level) {
- int fd = init_psi_monitor(psi_thresholds[level].stall_type,
+static bool init_mp_psi(enum vmpressure_level level, bool use_new_strategy) {
+ int fd;
+
+ /* Do not register a handler if threshold_ms is not set */
+ if (!psi_thresholds[level].threshold_ms) {
+ return true;
+ }
+
+ fd = init_psi_monitor(psi_thresholds[level].stall_type,
psi_thresholds[level].threshold_ms * US_PER_MS,
PSI_WINDOW_SIZE_MS * US_PER_MS);
@@ -1836,7 +2339,7 @@
return false;
}
- vmpressure_hinfo[level].handler = mp_event_common;
+ vmpressure_hinfo[level].handler = use_new_strategy ? mp_event_psi : mp_event_common;
vmpressure_hinfo[level].data = level;
if (register_psi_monitor(epollfd, fd, &vmpressure_hinfo[level]) < 0) {
destroy_psi_monitor(fd);
@@ -1860,14 +2363,29 @@
}
static bool init_psi_monitors() {
- if (!init_mp_psi(VMPRESS_LEVEL_LOW)) {
+ /*
+ * When PSI is used on low-ram devices or on high-end devices without memfree levels
+ * use new kill strategy based on zone watermarks, free swap and thrashing stats
+ */
+ bool use_new_strategy =
+ property_get_bool("ro.lmk.use_new_strategy", low_ram_device || !use_minfree_levels);
+
+ /* In default PSI mode override stall amounts using system properties */
+ if (use_new_strategy) {
+ /* Do not use low pressure level */
+ psi_thresholds[VMPRESS_LEVEL_LOW].threshold_ms = 0;
+ psi_thresholds[VMPRESS_LEVEL_MEDIUM].threshold_ms = psi_partial_stall_ms;
+ psi_thresholds[VMPRESS_LEVEL_CRITICAL].threshold_ms = psi_complete_stall_ms;
+ }
+
+ if (!init_mp_psi(VMPRESS_LEVEL_LOW, use_new_strategy)) {
return false;
}
- if (!init_mp_psi(VMPRESS_LEVEL_MEDIUM)) {
+ if (!init_mp_psi(VMPRESS_LEVEL_MEDIUM, use_new_strategy)) {
destroy_mp_psi(VMPRESS_LEVEL_LOW);
return false;
}
- if (!init_mp_psi(VMPRESS_LEVEL_CRITICAL)) {
+ if (!init_mp_psi(VMPRESS_LEVEL_CRITICAL, use_new_strategy)) {
destroy_mp_psi(VMPRESS_LEVEL_MEDIUM);
destroy_mp_psi(VMPRESS_LEVEL_LOW);
return false;
@@ -1942,74 +2460,17 @@
return false;
}
-#ifdef LMKD_LOG_STATS
-static int kernel_poll_fd = -1;
-static void poll_kernel() {
- if (kernel_poll_fd == -1) {
- // not waiting
- return;
- }
-
- while (1) {
- char rd_buf[256];
- int bytes_read =
- TEMP_FAILURE_RETRY(pread(kernel_poll_fd, (void*)rd_buf, sizeof(rd_buf), 0));
- if (bytes_read <= 0) break;
- rd_buf[bytes_read] = '\0';
-
- int64_t pid;
- int64_t uid;
- int64_t group_leader_pid;
- int64_t min_flt;
- int64_t maj_flt;
- int64_t rss_in_pages;
- int16_t oom_score_adj;
- int16_t min_score_adj;
- int64_t starttime;
- char* taskname = 0;
- int fields_read = sscanf(rd_buf,
- "%" SCNd64 " %" SCNd64 " %" SCNd64 " %" SCNd64 " %" SCNd64
- " %" SCNd64 " %" SCNd16 " %" SCNd16 " %" SCNd64 "\n%m[^\n]",
- &pid, &uid, &group_leader_pid, &min_flt, &maj_flt, &rss_in_pages,
- &oom_score_adj, &min_score_adj, &starttime, &taskname);
-
- /* only the death of the group leader process is logged */
- if (fields_read == 10 && group_leader_pid == pid) {
- int64_t process_start_time_ns = starttime * (NS_PER_SEC / sysconf(_SC_CLK_TCK));
- stats_write_lmk_kill_occurred_pid(log_ctx, LMK_KILL_OCCURRED, uid, pid, oom_score_adj,
- min_flt, maj_flt, rss_in_pages * PAGE_SIZE, 0, 0,
- process_start_time_ns, min_score_adj);
- }
-
- free(taskname);
- }
+static void kernel_event_handler(int data __unused, uint32_t events __unused,
+ struct polling_params *poll_params __unused) {
+ kpoll_info.handler(kpoll_info.poll_fd);
}
-static struct event_handler_info kernel_poll_hinfo = {0, poll_kernel};
-
-static void init_poll_kernel() {
- struct epoll_event epev;
- kernel_poll_fd =
- TEMP_FAILURE_RETRY(open("/proc/lowmemorykiller", O_RDONLY | O_NONBLOCK | O_CLOEXEC));
-
- if (kernel_poll_fd < 0) {
- ALOGE("kernel lmk event file could not be opened; errno=%d", kernel_poll_fd);
- return;
- }
-
- epev.events = EPOLLIN;
- epev.data.ptr = (void*)&kernel_poll_hinfo;
- if (epoll_ctl(epollfd, EPOLL_CTL_ADD, kernel_poll_fd, &epev) != 0) {
- ALOGE("epoll_ctl for lmk events failed; errno=%d", errno);
- close(kernel_poll_fd);
- kernel_poll_fd = -1;
- } else {
- maxevents++;
- }
-}
-#endif
-
static int init(void) {
+ static struct event_handler_info kernel_poll_hinfo = { 0, kernel_event_handler };
+ struct reread_data file_data = {
+ .filename = ZONEINFO_PATH,
+ .fd = -1,
+ };
struct epoll_event epev;
int i;
int ret;
@@ -2056,11 +2517,17 @@
if (use_inkernel_interface) {
ALOGI("Using in-kernel low memory killer interface");
-#ifdef LMKD_LOG_STATS
- if (enable_stats_log) {
- init_poll_kernel();
+ if (init_poll_kernel(&kpoll_info)) {
+ epev.events = EPOLLIN;
+ epev.data.ptr = (void*)&kernel_poll_hinfo;
+ if (epoll_ctl(epollfd, EPOLL_CTL_ADD, kpoll_info.poll_fd, &epev) != 0) {
+ ALOGE("epoll_ctl for lmk events failed (errno=%d)", errno);
+ close(kpoll_info.poll_fd);
+ kpoll_info.poll_fd = -1;
+ } else {
+ maxevents++;
+ }
}
-#endif
} else {
/* Try to use psi monitor first if kernel has it */
use_psi_monitors = property_get_bool("ro.lmk.use_psi", true) &&
@@ -2087,37 +2554,68 @@
memset(killcnt_idx, KILLCNT_INVALID_IDX, sizeof(killcnt_idx));
+ /*
+ * Read zoneinfo as the biggest file we read to create and size the initial
+ * read buffer and avoid memory re-allocations during memory pressure
+ */
+ if (reread_file(&file_data) == NULL) {
+ ALOGE("Failed to read %s: %s", file_data.filename, strerror(errno));
+ }
+
return 0;
}
static void mainloop(void) {
struct event_handler_info* handler_info;
- struct event_handler_info* poll_handler = NULL;
- struct timespec last_report_tm, curr_tm;
+ struct polling_params poll_params;
+ struct timespec curr_tm;
struct epoll_event *evt;
long delay = -1;
- int polling = 0;
+
+ poll_params.poll_handler = NULL;
+ poll_params.update = POLLING_DO_NOT_CHANGE;
while (1) {
struct epoll_event events[maxevents];
int nevents;
int i;
- if (polling) {
+ if (poll_params.poll_handler) {
/* Calculate next timeout */
clock_gettime(CLOCK_MONOTONIC_COARSE, &curr_tm);
- delay = get_time_diff_ms(&last_report_tm, &curr_tm);
- delay = (delay < PSI_POLL_PERIOD_MS) ?
- PSI_POLL_PERIOD_MS - delay : PSI_POLL_PERIOD_MS;
+ delay = get_time_diff_ms(&poll_params.last_poll_tm, &curr_tm);
+ delay = (delay < poll_params.polling_interval_ms) ?
+ poll_params.polling_interval_ms - delay : poll_params.polling_interval_ms;
/* Wait for events until the next polling timeout */
nevents = epoll_wait(epollfd, events, maxevents, delay);
clock_gettime(CLOCK_MONOTONIC_COARSE, &curr_tm);
- if (get_time_diff_ms(&last_report_tm, &curr_tm) >= PSI_POLL_PERIOD_MS) {
- polling--;
- poll_handler->handler(poll_handler->data, 0);
- last_report_tm = curr_tm;
+ if (get_time_diff_ms(&poll_params.last_poll_tm, &curr_tm) >=
+ poll_params.polling_interval_ms) {
+ /* Set input params for the call */
+ poll_params.poll_handler->handler(poll_params.poll_handler->data, 0, &poll_params);
+ poll_params.last_poll_tm = curr_tm;
+
+ if (poll_params.update != POLLING_DO_NOT_CHANGE) {
+ switch (poll_params.update) {
+ case POLLING_START:
+ poll_params.poll_start_tm = curr_tm;
+ break;
+ case POLLING_STOP:
+ poll_params.poll_handler = NULL;
+ break;
+ default:
+ break;
+ }
+ poll_params.update = POLLING_DO_NOT_CHANGE;
+ } else {
+ if (get_time_diff_ms(&poll_params.poll_start_tm, &curr_tm) >
+ PSI_WINDOW_SIZE_MS) {
+ /* Polled for the duration of PSI window, time to stop */
+ poll_params.poll_handler = NULL;
+ }
+ }
}
} else {
/* Wait for events with no timeout */
@@ -2148,25 +2646,37 @@
/* Second pass to handle all other events */
for (i = 0, evt = &events[0]; i < nevents; ++i, evt++) {
- if (evt->events & EPOLLERR)
+ if (evt->events & EPOLLERR) {
ALOGD("EPOLLERR on event #%d", i);
+ }
if (evt->events & EPOLLHUP) {
/* This case was handled in the first pass */
continue;
}
if (evt->data.ptr) {
handler_info = (struct event_handler_info*)evt->data.ptr;
- handler_info->handler(handler_info->data, evt->events);
+ /* Set input params for the call */
+ handler_info->handler(handler_info->data, evt->events, &poll_params);
- if (use_psi_monitors && handler_info->handler == mp_event_common) {
- /*
- * Poll for the duration of PSI_WINDOW_SIZE_MS after the
- * initial PSI event because psi events are rate-limited
- * at one per sec.
- */
- polling = PSI_POLL_COUNT;
- poll_handler = handler_info;
- clock_gettime(CLOCK_MONOTONIC_COARSE, &last_report_tm);
+ if (poll_params.update != POLLING_DO_NOT_CHANGE) {
+ switch (poll_params.update) {
+ case POLLING_START:
+ /*
+ * Poll for the duration of PSI_WINDOW_SIZE_MS after the
+ * initial PSI event because psi events are rate-limited
+ * at one per sec.
+ */
+ clock_gettime(CLOCK_MONOTONIC_COARSE, &curr_tm);
+ poll_params.poll_start_tm = poll_params.last_poll_tm = curr_tm;
+ poll_params.poll_handler = handler_info;
+ break;
+ case POLLING_STOP:
+ poll_params.poll_handler = NULL;
+ break;
+ default:
+ break;
+ }
+ poll_params.update = POLLING_DO_NOT_CHANGE;
}
}
}
@@ -2203,14 +2713,20 @@
property_get_bool("ro.lmk.use_minfree_levels", false);
per_app_memcg =
property_get_bool("ro.config.per_app_memcg", low_ram_device);
- swap_free_low_percentage =
- property_get_int32("ro.lmk.swap_free_low_percentage", 10);
+ swap_free_low_percentage = clamp(0, 100, property_get_int32("ro.lmk.swap_free_low_percentage",
+ low_ram_device ? DEF_LOW_SWAP_LOWRAM : DEF_LOW_SWAP));
+ psi_partial_stall_ms = property_get_int32("ro.lmk.psi_partial_stall_ms",
+ low_ram_device ? DEF_PARTIAL_STALL_LOWRAM : DEF_PARTIAL_STALL);
+ psi_complete_stall_ms = property_get_int32("ro.lmk.psi_complete_stall_ms",
+ DEF_COMPLETE_STALL);
+ thrashing_limit_pct = max(0, property_get_int32("ro.lmk.thrashing_limit",
+ low_ram_device ? DEF_THRASHING_LOWRAM : DEF_THRASHING));
+ thrashing_limit_decay_pct = clamp(0, 100, property_get_int32("ro.lmk.thrashing_limit_decay",
+ low_ram_device ? DEF_THRASHING_DECAY_LOWRAM : DEF_THRASHING_DECAY));
- ctx = create_android_logger(MEMINFO_LOG_TAG);
+ ctx = create_android_logger(KILLINFO_LOG_TAG);
-#ifdef LMKD_LOG_STATS
- statslog_init(&log_ctx, &enable_stats_log);
-#endif
+ statslog_init();
if (!init()) {
if (!use_inkernel_interface) {
@@ -2239,9 +2755,7 @@
mainloop();
}
-#ifdef LMKD_LOG_STATS
- statslog_destroy(&log_ctx);
-#endif
+ statslog_destroy();
android_log_destroy(&ctx);
diff --git a/lmkd/statslog.c b/lmkd/statslog.c
index f3a6e55..c0fd6df 100644
--- a/lmkd/statslog.c
+++ b/lmkd/statslog.c
@@ -18,11 +18,21 @@
#include <errno.h>
#include <log/log_id.h>
#include <stats_event_list.h>
+#include <statslog.h>
+#include <stdlib.h>
+#include <string.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
+#ifdef LMKD_LOG_STATS
+
#define LINE_MAX 128
+#define STRINGIFY(x) STRINGIFY_INTERNAL(x)
+#define STRINGIFY_INTERNAL(x) #x
+
+static bool enable_stats_log;
+static android_log_context log_ctx;
struct proc {
int pid;
@@ -41,34 +51,53 @@
return (int64_t)t.tv_sec * 1000000000LL + t.tv_nsec;
}
+void statslog_init() {
+ enable_stats_log = property_get_bool("ro.lmk.log_stats", false);
+
+ if (enable_stats_log) {
+ log_ctx = create_android_logger(kStatsEventTag);
+ }
+}
+
+void statslog_destroy() {
+ if (log_ctx) {
+ android_log_destroy(&log_ctx);
+ }
+}
+
/**
* Logs the change in LMKD state which is used as start/stop boundaries for logging
* LMK_KILL_OCCURRED event.
* Code: LMK_STATE_CHANGED = 54
*/
int
-stats_write_lmk_state_changed(android_log_context ctx, int32_t code, int32_t state) {
- assert(ctx != NULL);
+stats_write_lmk_state_changed(int32_t code, int32_t state) {
int ret = -EINVAL;
- if (!ctx) {
+
+ if (!enable_stats_log) {
return ret;
}
- reset_log_context(ctx);
-
- if ((ret = android_log_write_int64(ctx, getElapsedRealTimeNs())) < 0) {
+ assert(log_ctx != NULL);
+ if (!log_ctx) {
return ret;
}
- if ((ret = android_log_write_int32(ctx, code)) < 0) {
+ reset_log_context(log_ctx);
+
+ if ((ret = android_log_write_int64(log_ctx, getElapsedRealTimeNs())) < 0) {
return ret;
}
- if ((ret = android_log_write_int32(ctx, state)) < 0) {
+ if ((ret = android_log_write_int32(log_ctx, code)) < 0) {
return ret;
}
- return write_to_logger(ctx, LOG_ID_STATS);
+ if ((ret = android_log_write_int32(log_ctx, state)) < 0) {
+ return ret;
+ }
+
+ return write_to_logger(log_ctx, LOG_ID_STATS);
}
static struct proc* pid_lookup(int pid) {
@@ -87,92 +116,261 @@
* Code: LMK_KILL_OCCURRED = 51
*/
int
-stats_write_lmk_kill_occurred(android_log_context ctx, int32_t code, int32_t uid,
- char const* process_name, int32_t oom_score, int64_t pgfault,
- int64_t pgmajfault, int64_t rss_in_bytes, int64_t cache_in_bytes,
- int64_t swap_in_bytes, int64_t process_start_time_ns,
- int32_t min_oom_score) {
- assert(ctx != NULL);
+stats_write_lmk_kill_occurred(int32_t code, int32_t uid, char const* process_name,
+ int32_t oom_score, int32_t min_oom_score, int tasksize,
+ struct memory_stat *mem_st) {
int ret = -EINVAL;
- if (!ctx) {
+ if (!enable_stats_log) {
return ret;
}
- reset_log_context(ctx);
+ if (!log_ctx) {
+ return ret;
+ }
+ reset_log_context(log_ctx);
- if ((ret = android_log_write_int64(ctx, getElapsedRealTimeNs())) < 0) {
+ if ((ret = android_log_write_int64(log_ctx, getElapsedRealTimeNs())) < 0) {
return ret;
}
- if ((ret = android_log_write_int32(ctx, code)) < 0) {
+ if ((ret = android_log_write_int32(log_ctx, code)) < 0) {
return ret;
}
- if ((ret = android_log_write_int32(ctx, uid)) < 0) {
+ if ((ret = android_log_write_int32(log_ctx, uid)) < 0) {
return ret;
}
- if ((ret = android_log_write_string8(ctx, (process_name == NULL) ? "" : process_name)) < 0) {
+ if ((ret = android_log_write_string8(log_ctx, (process_name == NULL) ? "" : process_name)) < 0) {
return ret;
}
- if ((ret = android_log_write_int32(ctx, oom_score)) < 0) {
+ if ((ret = android_log_write_int32(log_ctx, oom_score)) < 0) {
return ret;
}
- if ((ret = android_log_write_int64(ctx, pgfault)) < 0) {
+ if ((ret = android_log_write_int64(log_ctx, mem_st ? mem_st->pgfault : -1)) < 0) {
return ret;
}
- if ((ret = android_log_write_int64(ctx, pgmajfault)) < 0) {
+ if ((ret = android_log_write_int64(log_ctx, mem_st ? mem_st->pgmajfault : -1)) < 0) {
return ret;
}
- if ((ret = android_log_write_int64(ctx, rss_in_bytes)) < 0) {
+ if ((ret = android_log_write_int64(log_ctx, mem_st ? mem_st->rss_in_bytes
+ : tasksize * BYTES_IN_KILOBYTE)) < 0) {
return ret;
}
- if ((ret = android_log_write_int64(ctx, cache_in_bytes)) < 0) {
+ if ((ret = android_log_write_int64(log_ctx, mem_st ? mem_st->cache_in_bytes : -1)) < 0) {
return ret;
}
- if ((ret = android_log_write_int64(ctx, swap_in_bytes)) < 0) {
+ if ((ret = android_log_write_int64(log_ctx, mem_st ? mem_st->swap_in_bytes : -1)) < 0) {
return ret;
}
- if ((ret = android_log_write_int64(ctx, process_start_time_ns)) < 0) {
+ if ((ret = android_log_write_int64(log_ctx, mem_st ? mem_st->process_start_time_ns
+ : -1)) < 0) {
return ret;
}
- if ((ret = android_log_write_int32(ctx, min_oom_score)) < 0) {
+ if ((ret = android_log_write_int32(log_ctx, min_oom_score)) < 0) {
return ret;
}
- return write_to_logger(ctx, LOG_ID_STATS);
+ return write_to_logger(log_ctx, LOG_ID_STATS);
}
-int stats_write_lmk_kill_occurred_pid(android_log_context ctx, int32_t code, int32_t uid, int pid,
- int32_t oom_score, int64_t pgfault, int64_t pgmajfault,
- int64_t rss_in_bytes, int64_t cache_in_bytes,
- int64_t swap_in_bytes, int64_t process_start_time_ns,
- int32_t min_oom_score) {
+static int stats_write_lmk_kill_occurred_pid(int32_t code, int32_t uid, int pid,
+ int32_t oom_score, int32_t min_oom_score, int tasksize,
+ struct memory_stat *mem_st) {
struct proc* proc = pid_lookup(pid);
if (!proc) return -EINVAL;
- return stats_write_lmk_kill_occurred(ctx, code, uid, proc->taskname, oom_score, pgfault,
- pgmajfault, rss_in_bytes, cache_in_bytes, swap_in_bytes,
- process_start_time_ns, min_oom_score);
+ return stats_write_lmk_kill_occurred(code, uid, proc->taskname, oom_score, min_oom_score,
+ tasksize, mem_st);
+}
+
+static void memory_stat_parse_line(char* line, struct memory_stat* mem_st) {
+ char key[LINE_MAX + 1];
+ int64_t value;
+
+ sscanf(line, "%" STRINGIFY(LINE_MAX) "s %" SCNd64 "", key, &value);
+
+ if (strcmp(key, "total_") < 0) {
+ return;
+ }
+
+ if (!strcmp(key, "total_pgfault"))
+ mem_st->pgfault = value;
+ else if (!strcmp(key, "total_pgmajfault"))
+ mem_st->pgmajfault = value;
+ else if (!strcmp(key, "total_rss"))
+ mem_st->rss_in_bytes = value;
+ else if (!strcmp(key, "total_cache"))
+ mem_st->cache_in_bytes = value;
+ else if (!strcmp(key, "total_swap"))
+ mem_st->swap_in_bytes = value;
+}
+
+static int memory_stat_from_cgroup(struct memory_stat* mem_st, int pid, uid_t uid) {
+ FILE *fp;
+ char buf[PATH_MAX];
+
+ snprintf(buf, sizeof(buf), MEMCG_PROCESS_MEMORY_STAT_PATH, uid, pid);
+
+ fp = fopen(buf, "r");
+
+ if (fp == NULL) {
+ return -1;
+ }
+
+ while (fgets(buf, PAGE_SIZE, fp) != NULL) {
+ memory_stat_parse_line(buf, mem_st);
+ }
+ fclose(fp);
+
+ return 0;
+}
+
+static int memory_stat_from_procfs(struct memory_stat* mem_st, int pid) {
+ char path[PATH_MAX];
+ char buffer[PROC_STAT_BUFFER_SIZE];
+ int fd, ret;
+
+ snprintf(path, sizeof(path), PROC_STAT_FILE_PATH, pid);
+ if ((fd = open(path, O_RDONLY | O_CLOEXEC)) < 0) {
+ return -1;
+ }
+
+ ret = read(fd, buffer, sizeof(buffer));
+ if (ret < 0) {
+ close(fd);
+ return -1;
+ }
+ close(fd);
+
+ // field 10 is pgfault
+ // field 12 is pgmajfault
+ // field 22 is starttime
+ // field 24 is rss_in_pages
+ int64_t pgfault = 0, pgmajfault = 0, starttime = 0, rss_in_pages = 0;
+ if (sscanf(buffer,
+ "%*u %*s %*s %*d %*d %*d %*d %*d %*d %" SCNd64 " %*d "
+ "%" SCNd64 " %*d %*u %*u %*d %*d %*d %*d %*d %*d "
+ "%" SCNd64 " %*d %" SCNd64 "",
+ &pgfault, &pgmajfault, &starttime, &rss_in_pages) != 4) {
+ return -1;
+ }
+ mem_st->pgfault = pgfault;
+ mem_st->pgmajfault = pgmajfault;
+ mem_st->rss_in_bytes = (rss_in_pages * PAGE_SIZE);
+ mem_st->process_start_time_ns = starttime * (NS_PER_SEC / sysconf(_SC_CLK_TCK));
+
+ return 0;
+}
+
+struct memory_stat *stats_read_memory_stat(bool per_app_memcg, int pid, uid_t uid) {
+ static struct memory_stat mem_st = {};
+
+ if (!enable_stats_log) {
+ return NULL;
+ }
+
+ if (per_app_memcg) {
+ if (memory_stat_from_cgroup(&mem_st, pid, uid) == 0) {
+ return &mem_st;
+ }
+ } else {
+ if (memory_stat_from_procfs(&mem_st, pid) == 0) {
+ return &mem_st;
+ }
+ }
+
+ return NULL;
+}
+
+static void poll_kernel(int poll_fd) {
+ if (poll_fd == -1) {
+ // not waiting
+ return;
+ }
+
+ while (1) {
+ char rd_buf[256];
+ int bytes_read =
+ TEMP_FAILURE_RETRY(pread(poll_fd, (void*)rd_buf, sizeof(rd_buf), 0));
+ if (bytes_read <= 0) break;
+ rd_buf[bytes_read] = '\0';
+
+ int64_t pid;
+ int64_t uid;
+ int64_t group_leader_pid;
+ int64_t rss_in_pages;
+ struct memory_stat mem_st = {};
+ int16_t oom_score_adj;
+ int16_t min_score_adj;
+ int64_t starttime;
+ char* taskname = 0;
+
+ int fields_read = sscanf(rd_buf,
+ "%" SCNd64 " %" SCNd64 " %" SCNd64 " %" SCNd64 " %" SCNd64
+ " %" SCNd64 " %" SCNd16 " %" SCNd16 " %" SCNd64 "\n%m[^\n]",
+ &pid, &uid, &group_leader_pid, &mem_st.pgfault,
+ &mem_st.pgmajfault, &rss_in_pages, &oom_score_adj,
+ &min_score_adj, &starttime, &taskname);
+
+ /* only the death of the group leader process is logged */
+ if (fields_read == 10 && group_leader_pid == pid) {
+ mem_st.process_start_time_ns = starttime * (NS_PER_SEC / sysconf(_SC_CLK_TCK));
+ mem_st.rss_in_bytes = rss_in_pages * PAGE_SIZE;
+ stats_write_lmk_kill_occurred_pid(LMK_KILL_OCCURRED, uid, pid, oom_score_adj,
+ min_score_adj, 0, &mem_st);
+ }
+
+ free(taskname);
+ }
+}
+
+bool init_poll_kernel(struct kernel_poll_info *poll_info) {
+ if (!enable_stats_log) {
+ return false;
+ }
+
+ poll_info->poll_fd =
+ TEMP_FAILURE_RETRY(open("/proc/lowmemorykiller", O_RDONLY | O_NONBLOCK | O_CLOEXEC));
+
+ if (poll_info->poll_fd < 0) {
+ ALOGE("kernel lmk event file could not be opened; errno=%d", errno);
+ return false;
+ }
+ poll_info->handler = poll_kernel;
+
+ return true;
}
static void proc_insert(struct proc* procp) {
- if (!pidhash)
+ if (!pidhash) {
pidhash = calloc(PIDHASH_SZ, sizeof(struct proc));
+ }
+
int hval = pid_hashfn(procp->pid);
procp->pidhash_next = pidhash[hval];
pidhash[hval] = procp;
}
-void stats_remove_taskname(int pid) {
- if (!pidhash) return;
+void stats_remove_taskname(int pid, int poll_fd) {
+ if (!enable_stats_log || !pidhash) {
+ return;
+ }
+
+ /*
+ * Perform an extra check before the pid is removed, after which it
+ * will be impossible for poll_kernel to get the taskname. poll_kernel()
+ * is potentially a long-running blocking function; however this method
+ * handles AMS requests but does not block AMS.
+ */
+ poll_kernel(poll_fd);
int hval = pid_hashfn(pid);
struct proc* procp;
@@ -193,12 +391,19 @@
free(procp);
}
-void stats_store_taskname(int pid, const char* taskname) {
- struct proc* procp = pid_lookup(pid);
- if (procp != NULL && strcmp(procp->taskname, taskname) == 0)
+void stats_store_taskname(int pid, const char* taskname, int poll_fd) {
+ if (!enable_stats_log) {
return;
+ }
+
+ struct proc* procp = pid_lookup(pid);
+ if (procp != NULL) {
+ if (strcmp(procp->taskname, taskname) == 0) {
+ return;
+ }
+ stats_remove_taskname(pid, poll_fd);
+ }
procp = malloc(sizeof(struct proc));
- stats_remove_taskname(pid);
procp->pid = pid;
strncpy(procp->taskname, taskname, LINE_MAX - 1);
procp->taskname[LINE_MAX - 1] = '\0';
@@ -206,7 +411,10 @@
}
void stats_purge_tasknames() {
- if (!pidhash) return;
+ if (!enable_stats_log || !pidhash) {
+ return;
+ }
+
struct proc* procp;
struct proc* next;
int i;
@@ -220,3 +428,5 @@
}
memset(pidhash, 0, PIDHASH_SZ * sizeof(struct proc));
}
+
+#endif /* LMKD_LOG_STATS */
diff --git a/lmkd/statslog.h b/lmkd/statslog.h
index 50d69f7..a09c7dd 100644
--- a/lmkd/statslog.h
+++ b/lmkd/statslog.h
@@ -18,6 +18,7 @@
#define _STATSLOG_H_
#include <assert.h>
+#include <inttypes.h>
#include <stats_event_list.h>
#include <stdbool.h>
#include <sys/cdefs.h>
@@ -26,6 +27,20 @@
__BEGIN_DECLS
+struct memory_stat {
+ int64_t pgfault;
+ int64_t pgmajfault;
+ int64_t rss_in_bytes;
+ int64_t cache_in_bytes;
+ int64_t swap_in_bytes;
+ int64_t process_start_time_ns;
+};
+
+struct kernel_poll_info {
+ int poll_fd;
+ void (*handler)(int poll_fd);
+};
+
/*
* These are defined in
* http://cs/android/frameworks/base/cmds/statsd/src/atoms.proto
@@ -35,37 +50,17 @@
#define LMK_STATE_CHANGE_START 1
#define LMK_STATE_CHANGE_STOP 2
+#ifdef LMKD_LOG_STATS
+
/*
* The single event tag id for all stats logs.
* Keep this in sync with system/core/logcat/event.logtags
*/
const static int kStatsEventTag = 1937006964;
-static inline void statslog_init(android_log_context* log_ctx, bool* enable_stats_log) {
- assert(log_ctx != NULL);
- assert(enable_stats_log != NULL);
- *enable_stats_log = property_get_bool("ro.lmk.log_stats", false);
+void statslog_init();
- if (*enable_stats_log) {
- *log_ctx = create_android_logger(kStatsEventTag);
- }
-}
-
-static inline void statslog_destroy(android_log_context* log_ctx) {
- assert(log_ctx != NULL);
- if (*log_ctx) {
- android_log_destroy(log_ctx);
- }
-}
-
-struct memory_stat {
- int64_t pgfault;
- int64_t pgmajfault;
- int64_t rss_in_bytes;
- int64_t cache_in_bytes;
- int64_t swap_in_bytes;
- int64_t process_start_time_ns;
-};
+void statslog_destroy();
#define MEMCG_PROCESS_MEMORY_STAT_PATH "/dev/memcg/apps/uid_%u/pid_%u/memory.stat"
#define PROC_STAT_FILE_PATH "/proc/%d/stat"
@@ -78,47 +73,63 @@
* Code: LMK_STATE_CHANGED = 54
*/
int
-stats_write_lmk_state_changed(android_log_context ctx, int32_t code, int32_t state);
+stats_write_lmk_state_changed(int32_t code, int32_t state);
/**
* Logs the event when LMKD kills a process to reduce memory pressure.
* Code: LMK_KILL_OCCURRED = 51
*/
int
-stats_write_lmk_kill_occurred_pid(android_log_context ctx, int32_t code, int32_t uid, int pid,
- int32_t oom_score, int64_t pgfault, int64_t pgmajfault,
- int64_t rss_in_bytes, int64_t cache_in_bytes,
- int64_t swap_in_bytes, int64_t process_start_time_ns,
- int32_t min_oom_score);
+stats_write_lmk_kill_occurred(int32_t code, int32_t uid,
+ char const* process_name, int32_t oom_score, int32_t min_oom_score,
+ int tasksize, struct memory_stat *mem_st);
-/**
- * Logs the event when LMKD kills a process to reduce memory pressure.
- * Code: LMK_KILL_OCCURRED = 51
- */
-int
-stats_write_lmk_kill_occurred(android_log_context ctx, int32_t code, int32_t uid,
- char const* process_name, int32_t oom_score, int64_t pgfault,
- int64_t pgmajfault, int64_t rss_in_bytes, int64_t cache_in_bytes,
- int64_t swap_in_bytes, int64_t process_start_time_ns,
- int32_t min_oom_score);
+struct memory_stat *stats_read_memory_stat(bool per_app_memcg, int pid, uid_t uid);
/**
* Registers a process taskname by pid, while it is still alive.
*/
-void
-stats_store_taskname(int pid, const char* taskname);
+void stats_store_taskname(int pid, const char* taskname, int poll_fd);
/**
* Unregister all process tasknames.
*/
-void
-stats_purge_tasknames();
+void stats_purge_tasknames();
/**
* Unregister a process taskname, e.g. after it has been killed.
*/
-void
-stats_remove_taskname(int pid);
+void stats_remove_taskname(int pid, int poll_fd);
+
+bool init_poll_kernel(struct kernel_poll_info *poll_info);
+
+#else /* LMKD_LOG_STATS */
+
+static inline void statslog_init() {}
+static inline void statslog_destroy() {}
+
+static inline int
+stats_write_lmk_state_changed(int32_t code __unused, int32_t state __unused) { return -EINVAL; }
+
+static inline int
+stats_write_lmk_kill_occurred(int32_t code __unused, int32_t uid __unused,
+ char const* process_name __unused, int32_t oom_score __unused,
+ int32_t min_oom_score __unused, int tasksize __unused,
+ struct memory_stat *mem_st __unused) { return -EINVAL; }
+
+static inline struct memory_stat *stats_read_memory_stat(bool per_app_memcg __unused,
+ int pid __unused, uid_t uid __unused) { return NULL; }
+
+static inline void stats_store_taskname(int pid __unused, const char* taskname __unused,
+ int poll_fd __unused) {}
+
+static inline void stats_purge_tasknames() {}
+
+static inline void stats_remove_taskname(int pid __unused, int poll_fd __unused) {}
+
+static inline bool init_poll_kernel(struct kernel_poll_info *poll_info __unused) { return false; }
+
+#endif /* LMKD_LOG_STATS */
__END_DECLS
diff --git a/logwrapper/Android.bp b/logwrapper/Android.bp
index e360a85..8851a47 100644
--- a/logwrapper/Android.bp
+++ b/logwrapper/Android.bp
@@ -56,10 +56,10 @@
// ========================================================
cc_benchmark {
- name: "android_fork_execvp_ext_benchmark",
+ name: "logwrap_fork_execvp_benchmark",
defaults: ["logwrapper_defaults"],
srcs: [
- "android_fork_execvp_ext_benchmark.cpp",
+ "logwrap_fork_execvp_benchmark.cpp",
],
shared_libs: [
"libbase",
diff --git a/logwrapper/include/logwrap/logwrap.h b/logwrapper/include/logwrap/logwrap.h
index c329586..cb40ee2 100644
--- a/logwrapper/include/logwrap/logwrap.h
+++ b/logwrapper/include/logwrap/logwrap.h
@@ -59,24 +59,3 @@
int logwrap_fork_execvp(int argc, const char* const* argv, int* status, bool forward_signals,
int log_target, bool abbreviated, const char* file_path);
-
-// TODO: Actually deprecate this and the below.
-static inline int android_fork_execvp_ext(int argc, char* argv[], int* status, bool ignore_int_quit,
- int log_target, bool abbreviated, const char* file_path,
- void* unused_opts, int unused_opts_len) {
- (void)ignore_int_quit;
- (void)unused_opts;
- (void)unused_opts_len;
- return logwrap_fork_execvp(argc, argv, status, false, log_target, abbreviated, file_path);
-}
-
-/* Similar to above, except abbreviated logging is not available, and if logwrap
- * is true, logging is to the Android system log, and if false, there is no
- * logging.
- */
-static inline int android_fork_execvp(int argc, char* argv[], int* status, bool ignore_int_quit,
- bool logwrap) {
- (void)ignore_int_quit;
- return logwrap_fork_execvp(argc, argv, status, false, (logwrap ? LOG_ALOG : LOG_NONE), false,
- nullptr);
-}
diff --git a/logwrapper/android_fork_execvp_ext_benchmark.cpp b/logwrapper/logwrap_fork_execvp_benchmark.cpp
similarity index 81%
rename from logwrapper/android_fork_execvp_ext_benchmark.cpp
rename to logwrapper/logwrap_fork_execvp_benchmark.cpp
index 1abd932..b2d0c71 100644
--- a/logwrapper/android_fork_execvp_ext_benchmark.cpp
+++ b/logwrapper/logwrap_fork_execvp_benchmark.cpp
@@ -23,9 +23,7 @@
const char* argv[] = {"/system/bin/echo", "hello", "world"};
const int argc = 3;
while (state.KeepRunning()) {
- int rc = android_fork_execvp_ext(
- argc, (char**)argv, NULL /* status */, false /* ignore_int_quit */, LOG_NONE,
- false /* abbreviated */, NULL /* file_path */, NULL /* opts */, 0 /* opts_len */);
+ int rc = logwrap_fork_execvp(argc, argv, nullptr, false, LOG_NONE, false, nullptr);
CHECK_EQ(0, rc);
}
}
diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index 7097a12..c8f0a8b 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -58,15 +58,6 @@
endif
#######################################
-# fsverity_init
-
-include $(CLEAR_VARS)
-LOCAL_MODULE:= fsverity_init
-LOCAL_MODULE_CLASS := EXECUTABLES
-LOCAL_SRC_FILES := fsverity_init.sh
-include $(BUILD_PREBUILT)
-
-#######################################
# init.environ.rc
include $(CLEAR_VARS)
@@ -432,6 +423,22 @@
echo $(lib) >> $@;)
#######################################
+# vndkcorevariant.libraries.txt
+include $(CLEAR_VARS)
+LOCAL_MODULE := vndkcorevariant.libraries.txt
+LOCAL_MODULE_CLASS := ETC
+LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)
+LOCAL_MODULE_STEM := $(call append_vndk_version,$(LOCAL_MODULE))
+include $(BUILD_SYSTEM)/base_rules.mk
+$(LOCAL_BUILT_MODULE): PRIVATE_VNDK_CORE_VARIANT_LIBRARIES := $(call module-installed-files-or-guess,$(VNDK_USING_CORE_VARIANT_LIBRARIES),.vendor)
+$(LOCAL_BUILT_MODULE):
+ @echo "Generate: $@"
+ @mkdir -p $(dir $@)
+ $(hide) echo -n > $@
+ $(hide) $(foreach lib,$(PRIVATE_VNDK_CORE_VARIANT_LIBRARIES), \
+ echo $(lib) >> $@;)
+
+#######################################
# adb_debug.prop in debug ramdisk
include $(CLEAR_VARS)
LOCAL_MODULE := adb_debug.prop
diff --git a/rootdir/fsverity_init.sh b/rootdir/fsverity_init.sh
deleted file mode 100644
index 4fee15f..0000000
--- a/rootdir/fsverity_init.sh
+++ /dev/null
@@ -1,32 +0,0 @@
-#!/system/bin/sh
-#
-# 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.
-#
-
-# Enforce fsverity signature checking
-echo 1 > /proc/sys/fs/verity/require_signatures
-
-# Load all keys
-for cert in /product/etc/security/fsverity/*.der; do
- /system/bin/mini-keyctl padd asymmetric fsv_product .fs-verity < "$cert" ||
- log -p e -t fsverity_init "Failed to load $cert"
-done
-
-DEBUGGABLE=$(getprop ro.debuggable)
-if [ $DEBUGGABLE != "1" ]; then
- # Prevent future key links to .fs-verity keyring
- /system/bin/mini-keyctl restrict_keyring .fs-verity ||
- log -p e -t fsverity_init "Failed to restrict .fs-verity keyring"
-fi
diff --git a/rootdir/init.rc b/rootdir/init.rc
index c61fd90..bad0642 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -489,10 +489,6 @@
mkdir /data/bootchart 0755 shell shell
bootchart start
- # Load fsverity keys. This needs to happen before apexd, as post-install of
- # APEXes may rely on keys.
- exec -- /system/bin/fsverity_init
-
# Make sure that apexd is started in the default namespace
enter_default_mount_ns
@@ -760,11 +756,6 @@
write /sys/fs/f2fs/${dev.mnt.blk.data}/cp_interval 200
# Permissions for System Server and daemons.
- chown radio system /sys/android_power/state
- chown radio system /sys/android_power/request_state
- chown radio system /sys/android_power/acquire_full_wake_lock
- chown radio system /sys/android_power/acquire_partial_wake_lock
- chown radio system /sys/android_power/release_wake_lock
chown system system /sys/power/autosleep
chown system system /sys/devices/system/cpu/cpufreq/interactive/timer_rate
@@ -828,6 +819,9 @@
class_start core
+ # Requires keystore (currently a core service) to be ready first.
+ exec -- /system/bin/fsverity_init
+
on nonencrypted
class_start main
class_start late_start
diff --git a/rootdir/init.zygote32.rc b/rootdir/init.zygote32.rc
index bf3fb42..9adbcba 100644
--- a/rootdir/init.zygote32.rc
+++ b/rootdir/init.zygote32.rc
@@ -5,7 +5,6 @@
group root readproc reserved_disk
socket zygote stream 660 root system
socket usap_pool_primary stream 660 root system
- onrestart write /sys/android_power/request_state wake
onrestart write /sys/power/state on
onrestart restart audioserver
onrestart restart cameraserver
diff --git a/rootdir/init.zygote32_64.rc b/rootdir/init.zygote32_64.rc
index 1bab588..f6149c9 100644
--- a/rootdir/init.zygote32_64.rc
+++ b/rootdir/init.zygote32_64.rc
@@ -5,7 +5,6 @@
group root readproc reserved_disk
socket zygote stream 660 root system
socket usap_pool_primary stream 660 root system
- onrestart write /sys/android_power/request_state wake
onrestart write /sys/power/state on
onrestart restart audioserver
onrestart restart cameraserver
diff --git a/rootdir/init.zygote64.rc b/rootdir/init.zygote64.rc
index 6fa210a..0e69b16 100644
--- a/rootdir/init.zygote64.rc
+++ b/rootdir/init.zygote64.rc
@@ -5,7 +5,6 @@
group root readproc reserved_disk
socket zygote stream 660 root system
socket usap_pool_primary stream 660 root system
- onrestart write /sys/android_power/request_state wake
onrestart write /sys/power/state on
onrestart restart audioserver
onrestart restart cameraserver
diff --git a/rootdir/init.zygote64_32.rc b/rootdir/init.zygote64_32.rc
index 48461ec..3e80168 100644
--- a/rootdir/init.zygote64_32.rc
+++ b/rootdir/init.zygote64_32.rc
@@ -5,7 +5,6 @@
group root readproc reserved_disk
socket zygote stream 660 root system
socket usap_pool_primary stream 660 root system
- onrestart write /sys/android_power/request_state wake
onrestart write /sys/power/state on
onrestart restart audioserver
onrestart restart cameraserver