Merge "Support profile guided compilation for secondary dex files" (f01cd5f8) · Commits · e / os / android_frameworks_native

cmds/installd/InstalldNativeService.cpp

+25 −23

Original line number	Diff line number	Diff line
		@@ -351,17 +351,20 @@ binder::Status InstalldNativeService::createAppData(const std::unique_ptr<std::s
		}

		if (property_get_bool("dalvik.vm.usejitprofiles", false)) {
		const std::string profile_path = create_data_user_profile_package_path(userId, pkgname);
		const std::string profile_dir =
		create_primary_current_profile_package_dir_path(userId, pkgname);
		// read-write-execute only for the app user.
		if (fs_prepare_dir_strict(profile_path.c_str(), 0700, uid, uid) != 0) {
		return error("Failed to prepare " + profile_path);
		if (fs_prepare_dir_strict(profile_dir.c_str(), 0700, uid, uid) != 0) {
		return error("Failed to prepare " + profile_dir);
		}
		std::string profile_file = create_primary_profile(profile_path);
		const std::string profile_file = create_current_profile_path(userId, pkgname,
		/is_secondary_dex/false);
		// read-write only for the app user.
		if (fs_prepare_file_strict(profile_file.c_str(), 0600, uid, uid) != 0) {
		return error("Failed to prepare " + profile_path);
		return error("Failed to prepare " + profile_file);
		}
		const std::string ref_profile_path = create_data_ref_profile_package_path(pkgname);
		const std::string ref_profile_path =
		create_primary_reference_profile_package_dir_path(pkgname);
		// dex2oat/profman runs under the shared app gid and it needs to read/write reference
		// profiles.
		int shared_app_gid = multiuser_get_shared_gid(0, appId);
		@@ -425,10 +428,10 @@ binder::Status InstalldNativeService::clearAppProfiles(const std::string& packag
		std::lock_guard<std::recursive_mutex> lock(mLock);

		binder::Status res = ok();
		if (!clear_reference_profile(packageName)) {
		if (!clear_primary_reference_profile(packageName)) {
		res = error("Failed to clear reference profile for " + packageName);
		}
		if (!clear_current_profiles(packageName)) {
		if (!clear_primary_current_profiles(packageName)) {
		res = error("Failed to clear current profiles for " + packageName);
		}
		return res;
		@@ -476,7 +479,7 @@ binder::Status InstalldNativeService::clearAppData(const std::unique_ptr<std::st
		}
		}
		if (!only_cache) {
		if (!clear_current_profile(packageName, userId)) {
		if (!clear_primary_current_profile(packageName, userId)) {
		res = error("Failed to clear current profile for " + packageName);
		}
		}
		@@ -486,13 +489,13 @@ binder::Status InstalldNativeService::clearAppData(const std::unique_ptr<std::st

		static int destroy_app_reference_profile(const std::string& pkgname) {
		return delete_dir_contents_and_dir(
		create_data_ref_profile_package_path(pkgname),
		create_primary_reference_profile_package_dir_path(pkgname),
		/ignore_if_missing/ true);
		}

		static int destroy_app_current_profiles(const std::string& pkgname, userid_t userid) {
		return delete_dir_contents_and_dir(
		create_data_user_profile_package_path(userid, pkgname),
		create_primary_current_profile_package_dir_path(userid, pkgname),
		/ignore_if_missing/ true);
		}

		@@ -719,7 +722,7 @@ binder::Status InstalldNativeService::destroyUserData(const std::unique_ptr<std:
		if (delete_dir_contents_and_dir(path, true) != 0) {
		res = error("Failed to delete " + path);
		}
		path = create_data_user_profile_path(userId);
		path = create_primary_cur_profile_dir_path(userId);
		if (delete_dir_contents_and_dir(path, true) != 0) {
		res = error("Failed to delete " + path);
		}
		@@ -1216,9 +1219,9 @@ binder::Status InstalldNativeService::getAppSize(const std::unique_ptr<std::stri
		ATRACE_END();

		ATRACE_BEGIN("profiles");
		auto userProfilePath = create_data_user_profile_package_path(userId, pkgname);
		auto userProfilePath = create_primary_current_profile_package_dir_path(userId, pkgname);
		calculate_tree_size(userProfilePath, &stats.dataSize);
		auto refProfilePath = create_data_ref_profile_package_path(pkgname);
		auto refProfilePath = create_primary_reference_profile_package_dir_path(pkgname);
		calculate_tree_size(refProfilePath, &stats.codeSize);
		ATRACE_END();

		@@ -1236,7 +1239,7 @@ binder::Status InstalldNativeService::getAppSize(const std::unique_ptr<std::stri
		calculate_tree_size(create_data_dalvik_cache_path(), &stats.codeSize,
		sharedGid, -1);
		}
		calculate_tree_size(create_data_user_profile_path(userId), &stats.dataSize,
		calculate_tree_size(create_primary_cur_profile_dir_path(userId), &stats.dataSize,
		multiuser_get_uid(userId, appId), -1);
		ATRACE_END();
		}
		@@ -1310,9 +1313,9 @@ binder::Status InstalldNativeService::getUserSize(const std::unique_ptr<std::str
		ATRACE_END();

		ATRACE_BEGIN("profile");
		auto userProfilePath = create_data_user_profile_path(userId);
		auto userProfilePath = create_primary_cur_profile_dir_path(userId);
		calculate_tree_size(userProfilePath, &stats.dataSize, -1, -1, true);
		auto refProfilePath = create_data_ref_profile_path();
		auto refProfilePath = create_primary_ref_profile_dir_path();
		calculate_tree_size(refProfilePath, &stats.codeSize, -1, -1, true);
		ATRACE_END();

		@@ -1334,7 +1337,7 @@ binder::Status InstalldNativeService::getUserSize(const std::unique_ptr<std::str
		ATRACE_BEGIN("dalvik");
		calculate_tree_size(create_data_dalvik_cache_path(), &stats.codeSize,
		-1, -1, true);
		calculate_tree_size(create_data_user_profile_path(userId), &stats.dataSize,
		calculate_tree_size(create_primary_cur_profile_dir_path(userId), &stats.dataSize,
		-1, -1, true);
		ATRACE_END();

		@@ -1367,9 +1370,9 @@ binder::Status InstalldNativeService::getUserSize(const std::unique_ptr<std::str
		ATRACE_END();

		ATRACE_BEGIN("profile");
		auto userProfilePath = create_data_user_profile_path(userId);
		auto userProfilePath = create_primary_cur_profile_dir_path(userId);
		calculate_tree_size(userProfilePath, &stats.dataSize);
		auto refProfilePath = create_data_ref_profile_path();
		auto refProfilePath = create_primary_ref_profile_dir_path();
		calculate_tree_size(refProfilePath, &stats.codeSize);
		ATRACE_END();

		@@ -1384,7 +1387,7 @@ binder::Status InstalldNativeService::getUserSize(const std::unique_ptr<std::str

		ATRACE_BEGIN("dalvik");
		calculate_tree_size(create_data_dalvik_cache_path(), &stats.codeSize);
		calculate_tree_size(create_data_user_profile_path(userId), &stats.dataSize);
		calculate_tree_size(create_primary_cur_profile_dir_path(userId), &stats.dataSize);
		ATRACE_END();
		}

		@@ -1549,8 +1552,7 @@ binder::Status InstalldNativeService::mergeProfiles(int32_t uid, const std::stri
		CHECK_ARGUMENT_PACKAGE_NAME(packageName);
		std::lock_guard<std::recursive_mutex> lock(mLock);

		const char* pkgname = packageName.c_str();
		*_aidl_return = analyse_profiles(uid, pkgname);
		*_aidl_return = analyze_primary_profiles(uid, packageName);
		return ok();
		}

cmds/installd/dexopt.cpp

+189 −107

File changed.

Preview size limit exceeded, changes collapsed.

cmds/installd/dexopt.h

+14 −4

Original line number	Diff line number	Diff line
		@@ -32,13 +32,23 @@ static constexpr int DEX2OAT_FOR_FILTER = 3;
		static constexpr int DEX2OAT_FOR_RELOCATION = 4;
		static constexpr int PATCHOAT_FOR_RELOCATION = 5;

		bool clear_reference_profile(const std::string& pkgname);
		bool clear_current_profile(const std::string& pkgname, userid_t user);
		bool clear_current_profiles(const std::string& pkgname);
		// Clear the reference profile for the primary apk of the given package.
		bool clear_primary_reference_profile(const std::string& pkgname);
		// Clear the current profile for the primary apk of the given package and user.
		bool clear_primary_current_profile(const std::string& pkgname, userid_t user);
		// Clear all current profile for the primary apk of the given package.
		bool clear_primary_current_profiles(const std::string& pkgname);

		bool move_ab(const char* apk_path, const char* instruction_set, const char* output_path);

		bool analyse_profiles(uid_t uid, const std::string& pkgname);
		// Decide if profile guided compilation is needed or not based on existing profiles.
		// The analysis is done for the primary apks (base + splits) of the given package.
		// Returns true if there is enough information in the current profiles that makes it
		// worth to recompile the package.
		// If the return value is true all the current profiles would have been merged into
		// the reference profiles accessible with open_reference_profile().
		bool analyze_primary_profiles(uid_t uid, const std::string& pkgname);

		bool dump_profiles(int32_t uid, const std::string& pkgname, const char* code_paths);

		bool delete_odex(const char* apk_path, const char* instruction_set, const char* output_path);

cmds/installd/tests/installd_utils_test.cpp

+30 −9

Original line number	Diff line number	Diff line
		@@ -521,29 +521,50 @@ TEST_F(UtilsTest, IsValidPackageName) {
		}

		TEST_F(UtilsTest, CreateDataUserProfilePath) {
		EXPECT_EQ("/data/misc/profiles/cur/0", create_data_user_profile_path(0));
		EXPECT_EQ("/data/misc/profiles/cur/1", create_data_user_profile_path(1));
		EXPECT_EQ("/data/misc/profiles/cur/0", create_primary_cur_profile_dir_path(0));
		EXPECT_EQ("/data/misc/profiles/cur/1", create_primary_cur_profile_dir_path(1));
		}

		TEST_F(UtilsTest, CreateDataUserProfilePackagePath) {
		EXPECT_EQ("/data/misc/profiles/cur/0/com.example",
		create_data_user_profile_package_path(0, "com.example"));
		create_primary_current_profile_package_dir_path(0, "com.example"));
		EXPECT_EQ("/data/misc/profiles/cur/1/com.example",
		create_data_user_profile_package_path(1, "com.example"));
		create_primary_current_profile_package_dir_path(1, "com.example"));
		}

		TEST_F(UtilsTest, CreateDataRefProfilePath) {
		EXPECT_EQ("/data/misc/profiles/ref", create_data_ref_profile_path());
		EXPECT_EQ("/data/misc/profiles/ref", create_primary_ref_profile_dir_path());
		}

		TEST_F(UtilsTest, CreateDataRefProfilePackagePath) {
		EXPECT_EQ("/data/misc/profiles/ref/com.example",
		create_data_ref_profile_package_path("com.example"));
		create_primary_reference_profile_package_dir_path("com.example"));
		}

		TEST_F(UtilsTest, CreatePrimaryProfile) {
		EXPECT_EQ("/data/misc/profiles/ref/com.example/primary.prof",
		create_primary_profile("/data/misc/profiles/ref/com.example"));
		TEST_F(UtilsTest, CreatePrimaryCurrentProfile) {
		std::string expected =
		create_primary_current_profile_package_dir_path(1, "com.example") + "/primary.prof";
		EXPECT_EQ(expected,
		create_current_profile_path(/user/0, "com.example", /is_secondary/false));
		}

		TEST_F(UtilsTest, CreatePrimaryReferenceProfile) {
		std::string expected =
		create_primary_reference_profile_package_dir_path("com.example") + "/primary.prof";
		EXPECT_EQ(expected,
		create_reference_profile_path("com.example", /is_secondary/false));
		}

		TEST_F(UtilsTest, CreateSecondaryCurrentProfile) {
		EXPECT_EQ("/data/user/0/com.example/secondary.dex.prof",
		create_current_profile_path(/user/0,
		"/data/user/0/com.example/secondary.dex", /is_secondary/true));
		}

		TEST_F(UtilsTest, CreateSecondaryReferenceProfile) {
		EXPECT_EQ("/data/user/0/com.example/oat/secondary.dex.prof",
		create_reference_profile_path(
		"/data/user/0/com.example/secondary.dex", /is_secondary/true));
		}

		} // namespace installd

cmds/installd/utils.cpp

+44 −13

Original line number	Diff line number	Diff line
		@@ -213,20 +213,22 @@ std::string create_data_misc_legacy_path(userid_t userid) {
		return StringPrintf("%s/misc/user/%u", create_data_path(nullptr).c_str(), userid);
		}

		std::string create_data_user_profile_path(userid_t userid) {
		std::string create_primary_cur_profile_dir_path(userid_t userid) {
		return StringPrintf("%s/cur/%u", android_profiles_dir.path, userid);
		}

		std::string create_data_user_profile_package_path(userid_t user, const std::string& package_name) {
		std::string create_primary_current_profile_package_dir_path(userid_t user,
		const std::string& package_name) {
		check_package_name(package_name.c_str());
		return StringPrintf("%s/%s",create_data_user_profile_path(user).c_str(), package_name.c_str());
		return StringPrintf("%s/%s",
		create_primary_cur_profile_dir_path(user).c_str(), package_name.c_str());
		}

		std::string create_data_ref_profile_path() {
		std::string create_primary_ref_profile_dir_path() {
		return StringPrintf("%s/ref", android_profiles_dir.path);
		}

		std::string create_data_ref_profile_package_path(const std::string& package_name) {
		std::string create_primary_reference_profile_package_dir_path(const std::string& package_name) {
		check_package_name(package_name.c_str());
		return StringPrintf("%s/ref/%s", android_profiles_dir.path, package_name.c_str());
		}
		@@ -235,11 +237,38 @@ std::string create_data_dalvik_cache_path() {
		return "/data/dalvik-cache";
		}

		// Keep profile paths in sync with ActivityThread.
		constexpr const char* PRIMARY_PROFILE_NAME = "primary.prof";
		// Keep profile paths in sync with ActivityThread and LoadedApk.
		const std::string PROFILE_EXT = ".prof";
		const std::string PRIMARY_PROFILE_NAME = "primary" + PROFILE_EXT;

		std::string create_current_profile_path(userid_t user, const std::string& location,
		bool is_secondary_dex) {
		if (is_secondary_dex) {
		// Secondary dex profiles are stored next to the dex files using .prof extension.
		return StringPrintf("%s%s", location.c_str(), PROFILE_EXT.c_str());
		} else {
		// Profiles for primary apks are under /data/misc/profiles/cur.
		std::string profile_dir = create_primary_current_profile_package_dir_path(user, location);
		return StringPrintf("%s/%s", profile_dir.c_str(), PRIMARY_PROFILE_NAME.c_str());
		}
		}

		std::string create_reference_profile_path(const std::string& location, bool is_secondary_dex) {
		if (is_secondary_dex) {
		// Secondary dex reference profiles are stored next to the dex files under the oat folder.
		size_t dirIndex = location.rfind('/');
		CHECK(dirIndex != std::string::npos)
		<< "Unexpected dir structure for secondary dex " << location;

		std::string create_primary_profile(const std::string& profile_dir) {
		return StringPrintf("%s/%s", profile_dir.c_str(), PRIMARY_PROFILE_NAME);
		std::string dex_dir = location.substr(0, dirIndex);
		std::string dex_name = location.substr(dirIndex +1);
		return StringPrintf("%s/oat/%s%s",
		dex_dir.c_str(), dex_name.c_str(), PROFILE_EXT.c_str());
		} else {
		// Reference profiles for primary apks are stored in /data/misc/profile/ref.
		std::string profile_dir = create_primary_reference_profile_package_dir_path(location);
		return StringPrintf("%s/%s", profile_dir.c_str(), PRIMARY_PROFILE_NAME.c_str());
		}
		}

		std::vector<userid_t> get_known_users(const char* volume_uuid) {
		@@ -1163,13 +1192,15 @@ int validate_system_app_path(const char* path) {
		return -1;
		}

		bool validate_secondary_dex_path(const char* pkgname, const char* path,
		bool validate_secondary_dex_path(const std::string& pkgname, const std::string& dex_path,
		const char* volume_uuid, int uid, int storage_flag) {
		CHECK(storage_flag == FLAG_STORAGE_CE \|\| storage_flag == FLAG_STORAGE_DE);

		std::string app_private_dir = storage_flag == FLAG_STORAGE_CE
		? create_data_user_ce_package_path(volume_uuid, multiuser_get_user_id(uid), pkgname)
		: create_data_user_de_package_path(volume_uuid, multiuser_get_user_id(uid), pkgname);
		? create_data_user_ce_package_path(
		volume_uuid, multiuser_get_user_id(uid), pkgname.c_str())
		: create_data_user_de_package_path(
		volume_uuid, multiuser_get_user_id(uid), pkgname.c_str());
		dir_rec_t dir;
		if (get_path_from_string(&dir, app_private_dir.c_str()) != 0) {
		LOG(WARNING) << "Could not get dir rec for " << app_private_dir;
		@@ -1179,7 +1210,7 @@ bool validate_secondary_dex_path(const char* pkgname, const char* path,
		// Pick at most 10 subdirectories when validating (arbitrary value).
		// If the secondary dex file is >10 directory nested then validation will
		// fail and the file will not be compiled.
		return validate_path(&dir, path, /max_subdirs/ 10) == 0;
		return validate_path(&dir, dex_path.c_str(), /max_subdirs/ 10) == 0;
		}

		/**