Snap for 4422293 from 026bb7e036acdeb32e2a1d6bcd90f7031299aee5 to pi-release (5c58c2be) · Commits · e / os / platform_frameworks_native

cmds/dumpstate/dumpstate.cpp

+1 −0

Original line number	Diff line number	Diff line
		@@ -1613,6 +1613,7 @@ int main(int argc, char *argv[]) {
		do_fb = 0;
		} else if (ds.extra_options_ == "bugreportwear") {
		ds.update_progress_ = true;
		do_zip_file = 1;
		} else if (ds.extra_options_ == "bugreporttelephony") {
		telephony_only = true;
		} else {

cmds/dumpsys/dumpsys.cpp

+29 −13

Original line number	Diff line number	Diff line
		@@ -62,6 +62,8 @@ static void usage() {
		" --help: shows this help\n"
		" -l: only list services, do not dump them\n"
		" -t TIMEOUT: TIMEOUT to use in seconds instead of default 10 seconds\n"
		" --proto: filter services that support dumping data in proto format. Dumps"
		" will be in proto format.\n"
		" --priority LEVEL: filter services based on specified priority\n"
		" LEVEL must be one of CRITICAL \| HIGH \| NORMAL\n"
		" --skip SERVICES: dumps all services but SERVICES (comma-separated list)\n"
		@@ -77,17 +79,17 @@ static bool IsSkipped(const Vector<String16>& skipped, const String16& service)
		return false;
		}

		static bool ConvertPriorityTypeToBitmask(String16& type, int& bitmask) {
		if (type == PRIORITY_ARG_CRITICAL) {
		bitmask = IServiceManager::DUMP_PRIORITY_CRITICAL;
		static bool ConvertPriorityTypeToBitmask(const String16& type, int& bitmask) {
		if (type == PriorityDumper::PRIORITY_ARG_CRITICAL) {
		bitmask = IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL;
		return true;
		}
		if (type == PRIORITY_ARG_HIGH) {
		bitmask = IServiceManager::DUMP_PRIORITY_HIGH;
		if (type == PriorityDumper::PRIORITY_ARG_HIGH) {
		bitmask = IServiceManager::DUMP_FLAG_PRIORITY_HIGH;
		return true;
		}
		if (type == PRIORITY_ARG_NORMAL) {
		bitmask = IServiceManager::DUMP_PRIORITY_NORMAL;
		if (type == PriorityDumper::PRIORITY_ARG_NORMAL) {
		bitmask = IServiceManager::DUMP_FLAG_PRIORITY_NORMAL;
		return true;
		}
		return false;
		@@ -98,11 +100,14 @@ int Dumpsys::main(int argc, char* const argv[]) {
		Vector<String16> args;
		String16 priorityType;
		Vector<String16> skippedServices;
		Vector<String16> protoServices;
		bool showListOnly = false;
		bool skipServices = false;
		bool filterByProto = false;
		int timeoutArg = 10;
		int dumpPriority = IServiceManager::DUMP_PRIORITY_ALL;
		int dumpPriorityFlags = IServiceManager::DUMP_FLAG_PRIORITY_ALL;
		static struct option longOptions[] = {{"priority", required_argument, 0, 0},
		{"proto", no_argument, 0, 0},
		{"skip", no_argument, 0, 0},
		{"help", no_argument, 0, 0},
		{0, 0, 0, 0}};
		@@ -124,12 +129,14 @@ int Dumpsys::main(int argc, char* const argv[]) {
		case 0:
		if (!strcmp(longOptions[optionIndex].name, "skip")) {
		skipServices = true;
		} else if (!strcmp(longOptions[optionIndex].name, "proto")) {
		filterByProto = true;
		} else if (!strcmp(longOptions[optionIndex].name, "help")) {
		usage();
		return 0;
		} else if (!strcmp(longOptions[optionIndex].name, "priority")) {
		priorityType = String16(String8(optarg));
		if (!ConvertPriorityTypeToBitmask(priorityType, dumpPriority)) {
		if (!ConvertPriorityTypeToBitmask(priorityType, dumpPriorityFlags)) {
		fprintf(stderr, "\n");
		usage();
		return -1;
		@@ -179,10 +186,19 @@ int Dumpsys::main(int argc, char* const argv[]) {

		if (services.empty() \|\| showListOnly) {
		// gets all services
		services = sm_->listServices(dumpPriority);
		services = sm_->listServices(dumpPriorityFlags);
		services.sort(sort_func);
		if (dumpPriority != IServiceManager::DUMP_PRIORITY_ALL) {
		args.insertAt(String16(PRIORITY_ARG), 0);
		if (filterByProto) {
		protoServices = sm_->listServices(IServiceManager::DUMP_FLAG_PROTO);
		protoServices.sort(sort_func);
		Vector<String16> intersection;
		std::set_intersection(services.begin(), services.end(), protoServices.begin(),
		protoServices.end(), std::back_inserter(intersection));
		services = std::move(intersection);
		args.insertAt(String16(PriorityDumper::PROTO_ARG), 0);
		}
		if (dumpPriorityFlags != IServiceManager::DUMP_FLAG_PRIORITY_ALL) {
		args.insertAt(String16(PriorityDumper::PRIORITY_ARG), 0);
		args.insertAt(priorityType, 1);
		} else {
		args.add(String16("-a"));
		@@ -230,7 +246,7 @@ int Dumpsys::main(int argc, char* const argv[]) {
		if (N > 1) {
		aout << "------------------------------------------------------------"
		"-------------------" << endl;
		if (dumpPriority == IServiceManager::DUMP_PRIORITY_ALL) {
		if (dumpPriorityFlags == IServiceManager::DUMP_FLAG_PRIORITY_ALL) {
		aout << "DUMP OF SERVICE " << service_name << ":" << endl;
		} else {
		aout << "DUMP OF SERVICE " << priorityType << " " << service_name << ":" << endl;

cmds/dumpsys/tests/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -15,6 +15,7 @@ cc_test {
		static_libs: [
		"libdumpsys",
		"libgmock",
		"libserviceutils",
		],

		clang: true,

cmds/dumpsys/tests/dumpsys_test.cpp

+71 −17

Original line number	Diff line number	Diff line
		@@ -22,6 +22,7 @@
		#include <gtest/gtest.h>

		#include <android-base/file.h>
		#include <serviceutils/PriorityDumper.h>
		#include <utils/String16.h>
		#include <utils/String8.h>
		#include <utils/Vector.h>
		@@ -131,16 +132,16 @@ class DumpsysTest : public Test {
		for (auto& service : services) {
		services16.add(String16(service.c_str()));
		}
		EXPECT_CALL(sm_, listServices(IServiceManager::DUMP_PRIORITY_ALL))
		EXPECT_CALL(sm_, listServices(IServiceManager::DUMP_FLAG_PRIORITY_ALL))
		.WillRepeatedly(Return(services16));
		}

		void ExpectListServicesWithPriority(std::vector<std::string> services, int dumpPriority) {
		void ExpectListServicesWithPriority(std::vector<std::string> services, int dumpFlags) {
		Vector<String16> services16;
		for (auto& service : services) {
		services16.add(String16(service.c_str()));
		}
		EXPECT_CALL(sm_, listServices(dumpPriority)).WillRepeatedly(Return(services16));
		EXPECT_CALL(sm_, listServices(dumpFlags)).WillRepeatedly(Return(services16));
		}

		sp<BinderMock> ExpectCheckService(const char* name, bool running = true) {
		@@ -210,6 +211,13 @@ class DumpsysTest : public Test {
		EXPECT_THAT(stdout_, HasSubstr("DUMP OF SERVICE " + service + ":\n" + dump));
		}

		void AssertDumpedWithPriority(const std::string& service, const std::string& dump,
		const char16_t* priorityType) {
		std::string priority = String8(priorityType).c_str();
		EXPECT_THAT(stdout_,
		HasSubstr("DUMP OF SERVICE " + priority + " " + service + ":\n" + dump));
		}

		void AssertNotDumped(const std::string& dump) {
		EXPECT_THAT(stdout_, Not(HasSubstr(dump)));
		}
		@@ -250,7 +258,7 @@ TEST_F(DumpsysTest, ListRunningServices) {

		// Tests 'dumpsys -l --priority HIGH'
		TEST_F(DumpsysTest, ListAllServicesWithPriority) {
		ExpectListServicesWithPriority({"Locksmith", "Valet"}, IServiceManager::DUMP_PRIORITY_HIGH);
		ExpectListServicesWithPriority({"Locksmith", "Valet"}, IServiceManager::DUMP_FLAG_PRIORITY_HIGH);
		ExpectCheckService("Locksmith");
		ExpectCheckService("Valet");

		@@ -261,13 +269,26 @@ TEST_F(DumpsysTest, ListAllServicesWithPriority) {

		// Tests 'dumpsys -l --priority HIGH' with and empty list
		TEST_F(DumpsysTest, ListEmptyServicesWithPriority) {
		ExpectListServicesWithPriority({}, IServiceManager::DUMP_PRIORITY_HIGH);
		ExpectListServicesWithPriority({}, IServiceManager::DUMP_FLAG_PRIORITY_HIGH);

		CallMain({"-l", "--priority", "HIGH"});

		AssertRunningServices({});
		}

		// Tests 'dumpsys -l --proto'
		TEST_F(DumpsysTest, ListAllServicesWithProto) {
		ExpectListServicesWithPriority({"Locksmith", "Valet", "Car"},
		IServiceManager::DUMP_FLAG_PRIORITY_ALL);
		ExpectListServicesWithPriority({"Valet", "Car"}, IServiceManager::DUMP_FLAG_PROTO);
		ExpectCheckService("Car");
		ExpectCheckService("Valet");

		CallMain({"-l", "--proto"});

		AssertRunningServices({"Car", "Valet"});
		}

		// Tests 'dumpsys service_name' on a service is running
		TEST_F(DumpsysTest, DumpRunningService) {
		ExpectDump("Valet", "Here's your car");
		@@ -336,7 +357,7 @@ TEST_F(DumpsysTest, DumpWithSkip) {
		// Tests 'dumpsys --skip skipped3 skipped5 --priority CRITICAL', which should skip these services
		TEST_F(DumpsysTest, DumpWithSkipAndPriority) {
		ExpectListServicesWithPriority({"running1", "stopped2", "skipped3", "running4", "skipped5"},
		IServiceManager::DUMP_PRIORITY_CRITICAL);
		IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL);
		ExpectDump("running1", "dump1");
		ExpectCheckService("stopped2", false);
		ExpectDump("skipped3", "dump3");
		@@ -346,8 +367,8 @@ TEST_F(DumpsysTest, DumpWithSkipAndPriority) {
		CallMain({"--priority", "CRITICAL", "--skip", "skipped3", "skipped5"});

		AssertRunningServices({"running1", "running4", "skipped3 (skipped)", "skipped5 (skipped)"});
		AssertDumped("running1", "dump1");
		AssertDumped("running4", "dump4");
		AssertDumpedWithPriority("running1", "dump1", PriorityDumper::PRIORITY_ARG_CRITICAL);
		AssertDumpedWithPriority("running4", "dump4", PriorityDumper::PRIORITY_ARG_CRITICAL);
		AssertStopped("stopped2");
		AssertNotDumped("dump3");
		AssertNotDumped("dump5");
		@@ -356,41 +377,74 @@ TEST_F(DumpsysTest, DumpWithSkipAndPriority) {
		// Tests 'dumpsys --priority CRITICAL'
		TEST_F(DumpsysTest, DumpWithPriorityCritical) {
		ExpectListServicesWithPriority({"runningcritical1", "runningcritical2"},
		IServiceManager::DUMP_PRIORITY_CRITICAL);
		IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL);
		ExpectDump("runningcritical1", "dump1");
		ExpectDump("runningcritical2", "dump2");

		CallMain({"--priority", "CRITICAL"});

		AssertRunningServices({"runningcritical1", "runningcritical2"});
		AssertDumped("runningcritical1", "dump1");
		AssertDumped("runningcritical2", "dump2");
		AssertDumpedWithPriority("runningcritical1", "dump1", PriorityDumper::PRIORITY_ARG_CRITICAL);
		AssertDumpedWithPriority("runningcritical2", "dump2", PriorityDumper::PRIORITY_ARG_CRITICAL);
		}

		// Tests 'dumpsys --priority HIGH'
		TEST_F(DumpsysTest, DumpWithPriorityHigh) {
		ExpectListServicesWithPriority({"runninghigh1", "runninghigh2"},
		IServiceManager::DUMP_PRIORITY_HIGH);
		IServiceManager::DUMP_FLAG_PRIORITY_HIGH);
		ExpectDump("runninghigh1", "dump1");
		ExpectDump("runninghigh2", "dump2");

		CallMain({"--priority", "HIGH"});

		AssertRunningServices({"runninghigh1", "runninghigh2"});
		AssertDumped("runninghigh1", "dump1");
		AssertDumped("runninghigh2", "dump2");
		AssertDumpedWithPriority("runninghigh1", "dump1", PriorityDumper::PRIORITY_ARG_HIGH);
		AssertDumpedWithPriority("runninghigh2", "dump2", PriorityDumper::PRIORITY_ARG_HIGH);
		}

		// Tests 'dumpsys --priority NORMAL'
		TEST_F(DumpsysTest, DumpWithPriorityNormal) {
		ExpectListServicesWithPriority({"runningnormal1", "runningnormal2"},
		IServiceManager::DUMP_PRIORITY_NORMAL);
		IServiceManager::DUMP_FLAG_PRIORITY_NORMAL);
		ExpectDump("runningnormal1", "dump1");
		ExpectDump("runningnormal2", "dump2");

		CallMain({"--priority", "NORMAL"});

		AssertRunningServices({"runningnormal1", "runningnormal2"});
		AssertDumped("runningnormal1", "dump1");
		AssertDumped("runningnormal2", "dump2");
		AssertDumpedWithPriority("runningnormal1", "dump1", PriorityDumper::PRIORITY_ARG_NORMAL);
		AssertDumpedWithPriority("runningnormal2", "dump2", PriorityDumper::PRIORITY_ARG_NORMAL);
		}

		// Tests 'dumpsys --proto'
		TEST_F(DumpsysTest, DumpWithProto) {
		ExpectListServicesWithPriority({"run8", "run1", "run2", "run5"},
		IServiceManager::DUMP_FLAG_PRIORITY_ALL);
		ExpectListServicesWithPriority({"run3", "run2", "run4", "run8"},
		IServiceManager::DUMP_FLAG_PROTO);
		ExpectDump("run2", "dump1");
		ExpectDump("run8", "dump2");

		CallMain({"--proto"});

		AssertRunningServices({"run2", "run8"});
		AssertDumped("run2", "dump1");
		AssertDumped("run8", "dump2");
		}

		// Tests 'dumpsys --priority HIGH --proto'
		TEST_F(DumpsysTest, DumpWithPriorityHighAndProto) {
		ExpectListServicesWithPriority({"runninghigh1", "runninghigh2"},
		IServiceManager::DUMP_FLAG_PRIORITY_HIGH);
		ExpectListServicesWithPriority({"runninghigh1", "runninghigh2", "runninghigh3"},
		IServiceManager::DUMP_FLAG_PROTO);

		ExpectDump("runninghigh1", "dump1");
		ExpectDump("runninghigh2", "dump2");

		CallMain({"--priority", "HIGH", "--proto"});

		AssertRunningServices({"runninghigh1", "runninghigh2"});
		AssertDumpedWithPriority("runninghigh1", "dump1", PriorityDumper::PRIORITY_ARG_HIGH);
		AssertDumpedWithPriority("runninghigh2", "dump2", PriorityDumper::PRIORITY_ARG_HIGH);
		}

cmds/installd/dexopt.cpp

+15 −3

Original line number	Diff line number	Diff line
		@@ -73,6 +73,10 @@ static bool is_debug_runtime() {
		return android::base::GetProperty("persist.sys.dalvik.vm.lib.2", "") == "libartd.so";
		}

		static bool is_debuggable_build() {
		return android::base::GetBoolProperty("ro.debuggable", false);
		}

		static bool clear_profile(const std::string& profile) {
		unique_fd ufd(open(profile.c_str(), O_WRONLY \| O_NOFOLLOW \| O_CLOEXEC));
		if (ufd.get() < 0) {
		@@ -197,7 +201,8 @@ static const char* get_location_from_path(const char* path) {
		static void run_dex2oat(int zip_fd, int oat_fd, int input_vdex_fd, int output_vdex_fd, int image_fd,
		const char* input_file_name, const char* output_file_name, int swap_fd,
		const char* instruction_set, const char* compiler_filter,
		bool debuggable, bool post_bootcomplete, int profile_fd, const char* class_loader_context) {
		bool debuggable, bool post_bootcomplete, bool try_debug_for_background, int profile_fd,
		const char* class_loader_context) {
		static const unsigned int MAX_INSTRUCTION_SET_LEN = 7;

		if (strlen(instruction_set) >= MAX_INSTRUCTION_SET_LEN) {
		@@ -274,7 +279,12 @@ static void run_dex2oat(int zip_fd, int oat_fd, int input_vdex_fd, int output_vd
		}

		// If the runtime was requested to use libartd.so, we'll run dex2oatd, otherwise dex2oat.
		const char* dex2oat_bin = is_debug_runtime() ? "/system/bin/dex2oatd" : "/system/bin/dex2oat";
		const char* dex2oat_bin = "/system/bin/dex2oat";
		static const char* kDex2oatDebugPath = "/system/bin/dex2oatd";
		if (is_debug_runtime() \|\| (try_debug_for_background && is_debuggable_build())) {
		DCHECK(access(kDex2oatDebugPath, X_OK) == 0);
		dex2oat_bin = kDex2oatDebugPath;
		}

		static const char* RUNTIME_ARG = "--runtime-arg";

		@@ -1407,7 +1417,7 @@ static void exec_dexoptanalyzer(const std::string& dex_file, const std::string&
		argv[i++] = downgrade_flag;
		}
		if (class_loader_context != nullptr) {
		argv[i++] = class_loader_context;
		argv[i++] = class_loader_context_arg.c_str();
		}
		argv[i] = NULL;

		@@ -1609,6 +1619,7 @@ int dexopt(const char* dex_path, uid_t uid, const char* pkgname, const char* ins
		bool boot_complete = (dexopt_flags & DEXOPT_BOOTCOMPLETE) != 0;
		bool profile_guided = (dexopt_flags & DEXOPT_PROFILE_GUIDED) != 0;
		bool is_secondary_dex = (dexopt_flags & DEXOPT_SECONDARY_DEX) != 0;
		bool try_debug_for_background = (dexopt_flags & DEXOPT_IDLE_BACKGROUND_JOB) != 0;

		// Check if we're dealing with a secondary dex file and if we need to compile it.
		std::string oat_dir_str;
		@@ -1704,6 +1715,7 @@ int dexopt(const char* dex_path, uid_t uid, const char* pkgname, const char* ins
		compiler_filter,
		debuggable,
		boot_complete,
		try_debug_for_background,
		reference_profile_fd.get(),
		class_loader_context);
		_exit(68); /* only get here on exec failure */