From d035dbbecf44191af398261b722d72026678eea8 Mon Sep 17 00:00:00 2001 From: Mark Salyzyn Date: Mon, 26 Mar 2018 08:23:00 -0700 Subject: llkd: default enabled for userdebug If LLK_ENABLE_DEFAULT is false, then check "ro.llk.enable" for "eng", also the default value if not set, and then check if userdebug build to establish a default of true for enable. Same for ro.khungtask.enable. Test: llkd_unit_test report eng status on "userdebug" or "user" builds Bug: 33808187 Bug: 72838192 Change-Id: I2adb23c7629dccaa2856c50bccbf4e363703c82c --- llkd/README.md | 6 ++++++ llkd/include/llkd.h | 8 +++++--- llkd/libllkd.cpp | 4 ++++ llkd/llkd.rc | 34 ++++++++++++++++++++++++++++++++-- llkd/tests/llkd_test.cpp | 25 ++++++++++++++++++++----- 5 files changed, 67 insertions(+), 10 deletions(-) (limited to 'llkd') diff --git a/llkd/README.md b/llkd/README.md index 146a99895..71319c8af 100644 --- a/llkd/README.md +++ b/llkd/README.md @@ -66,9 +66,15 @@ default false, if true do not sysrq t (dump all threads). #### ro.llk.enable default false, allow live-lock daemon to be enabled. +#### llk.enable +default ro.llk.enable, and evaluated for eng. + #### ro.khungtask.enable default false, allow [khungtask] daemon to be enabled. +#### khungtask.enable +default ro.khungtask.enable and evaluated for eng. + #### ro.llk.mlockall default false, enable call to mlockall(). diff --git a/llkd/include/llkd.h b/llkd/include/llkd.h index 2ae28ed77..bd0739bb0 100644 --- a/llkd/include/llkd.h +++ b/llkd/include/llkd.h @@ -30,9 +30,11 @@ bool llkInit(const char* threadname); /* threadname NULL, not spawned */ unsigned llkCheckMilliseconds(void); /* clang-format off */ -#define LLK_ENABLE_PROPERTY "ro.llk.enable" -#define LLK_ENABLE_DEFAULT false -#define KHT_ENABLE_PROPERTY "ro.khungtask.enable" +#define LLK_ENABLE_WRITEABLE_PROPERTY "llk.enable" +#define LLK_ENABLE_PROPERTY "ro." LLK_ENABLE_WRITEABLE_PROPERTY +#define LLK_ENABLE_DEFAULT false /* "eng" and userdebug true */ +#define KHT_ENABLE_WRITEABLE_PROPERTY "khungtask.enable" +#define KHT_ENABLE_PROPERTY "ro." KHT_ENABLE_WRITEABLE_PROPERTY #define LLK_MLOCKALL_PROPERTY "ro.llk.mlockall" #define LLK_MLOCKALL_DEFAULT true #define LLK_TIMEOUT_MS_PROPERTY "ro.llk.timeout_ms" diff --git a/llkd/libllkd.cpp b/llkd/libllkd.cpp index b25eb06c0..d82810572 100644 --- a/llkd/libllkd.cpp +++ b/llkd/libllkd.cpp @@ -1032,6 +1032,10 @@ unsigned llkCheckMilliseconds() { bool llkInit(const char* threadname) { llkLowRam = android::base::GetBoolProperty("ro.config.low_ram", false); + if (!LLK_ENABLE_DEFAULT && android::base::GetBoolProperty("ro.debuggable", false)) { + llkEnable = android::base::GetProperty(LLK_ENABLE_PROPERTY, "eng") == "eng"; + khtEnable = android::base::GetProperty(KHT_ENABLE_PROPERTY, "eng") == "eng"; + } llkEnable = android::base::GetBoolProperty(LLK_ENABLE_PROPERTY, llkEnable); if (llkEnable && !llkTopDirectory.reset(procdir)) { // Most likely reason we could be here is llkd was started diff --git a/llkd/llkd.rc b/llkd/llkd.rc index a257e76e1..f762a5ced 100644 --- a/llkd/llkd.rc +++ b/llkd/llkd.rc @@ -1,11 +1,41 @@ +# eng default for ro.llk.enable and ro.khungtask.enable +on property:ro.debuggable=* + setprop llk.enable ${ro.llk.enable:-0} + setprop khungtask.enable ${ro.khungtask.enable:-0} + +on property:ro.debuggable=1 + setprop llk.enable ${ro.llk.enable:-1} + setprop khungtask.enable ${ro.khungtask.enable:-1} + +on property:ro.llk.enable=eng + setprop llk.enable ${ro.debuggable:-0} + +on property:ro.khungtask.enable=eng + setprop khungtask.enable ${ro.debuggable:-0} + +on property:llk.enable=1 + setprop llk.enable true + +on property:llk.enable=0 + setprop llk.enable false + +on property:khungtask.enable=1 + setprop khungtask.enable true + +on property:khungtask.enable=0 + setprop khungtask.enable false + # Configure [khungtaskd] -on property:ro.khungtask.enable=true +on property:khungtask.enable=true write /proc/sys/kernel/hung_task_timeout_secs ${ro.khungtask.timeout:-720} write /proc/sys/kernel/hung_task_warnings 65535 write /proc/sys/kernel/hung_task_check_count 65535 write /proc/sys/kernel/hung_task_panic 1 -on property:ro.llk.enable=true +on property:khungtask.enable=false + write /proc/sys/kernel/hung_task_panic 0 + +on property:llk.enable=true start llkd service llkd /system/bin/llkd diff --git a/llkd/tests/llkd_test.cpp b/llkd/tests/llkd_test.cpp index e3c95eba3..2de18205c 100644 --- a/llkd/tests/llkd_test.cpp +++ b/llkd/tests/llkd_test.cpp @@ -64,10 +64,16 @@ void execute(const char* command) { } seconds llkdSleepPeriod(char state) { - auto default_enable = android::base::GetBoolProperty(LLK_ENABLE_PROPERTY, LLK_ENABLE_DEFAULT); - if (android::base::GetProperty(LLK_ENABLE_PROPERTY, "nothing") == "nothing") { - GTEST_LOG_INFO << LLK_ENABLE_PROPERTY " defaults to " << (default_enable ? "true" : "false") - << "\n"; + auto default_eng = android::base::GetProperty(LLK_ENABLE_PROPERTY, "eng") == "eng"; + auto default_enable = LLK_ENABLE_DEFAULT; + if (!LLK_ENABLE_DEFAULT && default_eng && + android::base::GetBoolProperty("ro.debuggable", false)) { + default_enable = true; + } + default_enable = android::base::GetBoolProperty(LLK_ENABLE_PROPERTY, default_enable); + if (default_eng) { + GTEST_LOG_INFO << LLK_ENABLE_PROPERTY " defaults to \"eng\" thus " + << (default_enable ? "true" : "false") << "\n"; } // Hail Mary hope is unconfigured. if ((GetUintProperty(LLK_TIMEOUT_MS_PROPERTY, LLK_TIMEOUT_MS_DEFAULT) != @@ -78,6 +84,8 @@ seconds llkdSleepPeriod(char state) { execute("stop llkd"); rest(); std::string setprop("setprop "); + execute((setprop + LLK_ENABLE_WRITEABLE_PROPERTY + " false").c_str()); + rest(); execute((setprop + LLK_TIMEOUT_MS_PROPERTY + " 120000").c_str()); rest(); execute((setprop + KHT_TIMEOUT_PROPERTY + " 130").c_str()); @@ -86,8 +94,15 @@ seconds llkdSleepPeriod(char state) { rest(); execute((setprop + LLK_ENABLE_PROPERTY + " true").c_str()); rest(); + execute((setprop + LLK_ENABLE_WRITEABLE_PROPERTY + " true").c_str()); + rest(); + } + default_enable = LLK_ENABLE_DEFAULT; + if (!LLK_ENABLE_DEFAULT && (android::base::GetProperty(LLK_ENABLE_PROPERTY, "eng") == "eng") && + android::base::GetBoolProperty("ro.debuggable", false)) { + default_enable = true; } - default_enable = android::base::GetBoolProperty(LLK_ENABLE_PROPERTY, false); + default_enable = android::base::GetBoolProperty(LLK_ENABLE_PROPERTY, default_enable); if (default_enable) { execute("start llkd"); rest(); -- cgit v1.2.3-54-g00ecf