Merge changes from topic "kill-hwc1-fb"
* changes:
surfaceflinger: remove USE_HWC2
surfaceflinger: remove TARGET_USES_HWC2
diff --git a/cmds/installd/dexopt.cpp b/cmds/installd/dexopt.cpp
index 20b7728..af2c527 100644
--- a/cmds/installd/dexopt.cpp
+++ b/cmds/installd/dexopt.cpp
@@ -1385,6 +1385,8 @@
oat_dir.c_str(),
is_secondary_dex,
oat_path)) {
+ LOG(ERROR) << "Could not create oat out path for "
+ << apk_path << " with oat dir " << oat_dir;
return false;
}
oat_file_fd->reset(open(oat_path, O_RDONLY));
@@ -1489,7 +1491,7 @@
// Prepares the oat dir for the secondary dex files.
static bool prepare_secondary_dex_oat_dir(const std::string& dex_path, int uid,
- const char* instruction_set, std::string* oat_dir_out) {
+ const char* instruction_set) {
unsigned long dirIndex = dex_path.rfind('/');
if (dirIndex == std::string::npos) {
LOG(ERROR ) << "Unexpected dir structure for secondary dex " << dex_path;
@@ -1506,10 +1508,8 @@
char oat_dir[PKG_PATH_MAX];
snprintf(oat_dir, PKG_PATH_MAX, "%s/oat", dex_dir.c_str());
- oat_dir_out->assign(oat_dir);
- // Create oat/isa output directory.
- if (prepare_app_cache_dir(*oat_dir_out, instruction_set, oat_dir_mode, uid, uid) != 0) {
+ if (prepare_app_cache_dir(oat_dir, instruction_set, oat_dir_mode, uid, uid) != 0) {
LOG(ERROR) << "Could not prepare oat/isa dir for secondary dex: " << dex_path;
return false;
}
@@ -1517,39 +1517,128 @@
return true;
}
-static int constexpr DEXOPTANALYZER_BIN_EXEC_ERROR = 200;
+// Return codes for identifying the reason why dexoptanalyzer was not invoked when processing
+// secondary dex files. This return codes are returned by the child process created for
+// analyzing secondary dex files in process_secondary_dex_dexopt.
-// Verifies the result of dexoptanalyzer executed for the apk_path.
+// The dexoptanalyzer was not invoked because of validation or IO errors.
+static int constexpr SECONDARY_DEX_DEXOPTANALYZER_SKIPPED = 200;
+// The dexoptanalyzer was not invoked because the dex file does not exist anymore.
+static int constexpr SECONDARY_DEX_DEXOPTANALYZER_SKIPPED_NO_FILE = 201;
+
+// Verifies the result of analyzing secondary dex files from process_secondary_dex_dexopt.
// If the result is valid returns true and sets dexopt_needed_out to a valid value.
// Returns false for errors or unexpected result values.
-static bool process_dexoptanalyzer_result(const std::string& dex_path, int result,
+// The result is expected to be either one of SECONDARY_DEX_* codes or a valid exit code
+// of dexoptanalyzer.
+static bool process_secondary_dexoptanalyzer_result(const std::string& dex_path, int result,
int* dexopt_needed_out) {
// The result values are defined in dexoptanalyzer.
switch (result) {
- case 0: // no_dexopt_needed
+ case 0: // dexoptanalyzer: no_dexopt_needed
*dexopt_needed_out = NO_DEXOPT_NEEDED; return true;
- case 1: // dex2oat_from_scratch
+ case 1: // dexoptanalyzer: dex2oat_from_scratch
*dexopt_needed_out = DEX2OAT_FROM_SCRATCH; return true;
- case 5: // dex2oat_for_bootimage_odex
+ case 5: // dexoptanalyzer: dex2oat_for_bootimage_odex
*dexopt_needed_out = -DEX2OAT_FOR_BOOT_IMAGE; return true;
- case 6: // dex2oat_for_filter_odex
+ case 6: // dexoptanalyzer: dex2oat_for_filter_odex
*dexopt_needed_out = -DEX2OAT_FOR_FILTER; return true;
- case 7: // dex2oat_for_relocation_odex
+ case 7: // dexoptanalyzer: dex2oat_for_relocation_odex
*dexopt_needed_out = -DEX2OAT_FOR_RELOCATION; return true;
- case 2: // dex2oat_for_bootimage_oat
- case 3: // dex2oat_for_filter_oat
- case 4: // dex2oat_for_relocation_oat
+ case 2: // dexoptanalyzer: dex2oat_for_bootimage_oat
+ case 3: // dexoptanalyzer: dex2oat_for_filter_oat
+ case 4: // dexoptanalyzer: dex2oat_for_relocation_oat
LOG(ERROR) << "Dexoptnalyzer return the status of an oat file."
<< " Expected odex file status for secondary dex " << dex_path
<< " : dexoptanalyzer result=" << result;
return false;
+ case SECONDARY_DEX_DEXOPTANALYZER_SKIPPED_NO_FILE:
+ // If the file does not exist there's no need for dexopt.
+ *dexopt_needed_out = NO_DEXOPT_NEEDED;
+ return true;
+ case SECONDARY_DEX_DEXOPTANALYZER_SKIPPED:
+ return false;
default:
- LOG(ERROR) << "Unexpected result for dexoptanalyzer " << dex_path
- << " exec_dexoptanalyzer result=" << result;
+ LOG(ERROR) << "Unexpected result from analyzing secondary dex " << dex_path
+ << " result=" << result;
return false;
}
}
+enum SecondaryDexAccess {
+ kSecondaryDexAccessReadOk = 0,
+ kSecondaryDexAccessDoesNotExist = 1,
+ kSecondaryDexAccessPermissionError = 2,
+ kSecondaryDexAccessIOError = 3
+};
+
+static SecondaryDexAccess check_secondary_dex_access(const std::string& dex_path) {
+ // Check if the path exists and can be read. If not, there's nothing to do.
+ if (access(dex_path.c_str(), R_OK) == 0) {
+ return kSecondaryDexAccessReadOk;
+ } else {
+ if (errno == ENOENT) {
+ LOG(INFO) << "Secondary dex does not exist: " << dex_path;
+ return kSecondaryDexAccessDoesNotExist;
+ } else {
+ PLOG(ERROR) << "Could not access secondary dex " << dex_path;
+ return errno == EACCES
+ ? kSecondaryDexAccessPermissionError
+ : kSecondaryDexAccessIOError;
+ }
+ }
+}
+
+static bool is_file_public(const std::string& filename) {
+ struct stat file_stat;
+ if (stat(filename.c_str(), &file_stat) == 0) {
+ return (file_stat.st_mode & S_IROTH) != 0;
+ }
+ return false;
+}
+
+// Create the oat file structure for the secondary dex 'dex_path' and assign
+// the individual path component to the 'out_' parameters.
+static bool create_secondary_dex_oat_layout(const std::string& dex_path, const std::string& isa,
+ char* out_oat_dir, char* out_oat_isa_dir, char* out_oat_path) {
+ size_t dirIndex = dex_path.rfind('/');
+ if (dirIndex == std::string::npos) {
+ LOG(ERROR) << "Unexpected dir structure for dex file " << dex_path;
+ return false;
+ }
+ // TODO(calin): we have similar computations in at lest 3 other places
+ // (InstalldNativeService, otapropt and dexopt). Unify them and get rid of snprintf by
+ // using string append.
+ std::string apk_dir = dex_path.substr(0, dirIndex);
+ snprintf(out_oat_dir, PKG_PATH_MAX, "%s/oat", apk_dir.c_str());
+ snprintf(out_oat_isa_dir, PKG_PATH_MAX, "%s/%s", out_oat_dir, isa.c_str());
+
+ if (!create_oat_out_path(dex_path.c_str(), isa.c_str(), out_oat_dir,
+ /*is_secondary_dex*/true, out_oat_path)) {
+ LOG(ERROR) << "Could not create oat path for secondary dex " << dex_path;
+ return false;
+ }
+ return true;
+}
+
+// Validate that the dexopt_flags contain a valid storage flag and convert that to an installd
+// recognized storage flags (FLAG_STORAGE_CE or FLAG_STORAGE_DE).
+static bool validate_dexopt_storage_flags(int dexopt_flags, int* out_storage_flag) {
+ if ((dexopt_flags & DEXOPT_STORAGE_CE) != 0) {
+ *out_storage_flag = FLAG_STORAGE_CE;
+ if ((dexopt_flags & DEXOPT_STORAGE_DE) != 0) {
+ LOG(ERROR) << "Ambiguous secondary dex storage flag. Both, CE and DE, flags are set";
+ return false;
+ }
+ } else if ((dexopt_flags & DEXOPT_STORAGE_DE) != 0) {
+ *out_storage_flag = FLAG_STORAGE_DE;
+ } else {
+ LOG(ERROR) << "Secondary dex storage flag must be set";
+ return false;
+ }
+ return true;
+}
+
// Processes the dex_path as a secondary dex files and return true if the path dex file should
// be compiled. Returns false for errors (logged) or true if the secondary dex path was process
// successfully.
@@ -1557,126 +1646,107 @@
// - is_public_out: whether or not the oat file should not be made public
// - dexopt_needed_out: valid OatFileAsssitant::DexOptNeeded
// - oat_dir_out: the oat dir path where the oat file should be stored
-// - dex_path_out: the real path of the dex file
-static bool process_secondary_dex_dexopt(const char* original_dex_path, const char* pkgname,
+static bool process_secondary_dex_dexopt(const std::string& dex_path, const char* pkgname,
int dexopt_flags, const char* volume_uuid, int uid, const char* instruction_set,
const char* compiler_filter, bool* is_public_out, int* dexopt_needed_out,
- std::string* oat_dir_out, std::string* dex_path_out, bool downgrade,
- const char* class_loader_context) {
+ std::string* oat_dir_out, bool downgrade, const char* class_loader_context) {
+ LOG(DEBUG) << "Processing secondary dex path " << dex_path;
int storage_flag;
-
- if ((dexopt_flags & DEXOPT_STORAGE_CE) != 0) {
- storage_flag = FLAG_STORAGE_CE;
- if ((dexopt_flags & DEXOPT_STORAGE_DE) != 0) {
- LOG(ERROR) << "Ambiguous secondary dex storage flag. Both, CE and DE, flags are set";
- return false;
- }
- } else if ((dexopt_flags & DEXOPT_STORAGE_DE) != 0) {
- storage_flag = FLAG_STORAGE_DE;
- } else {
- LOG(ERROR) << "Secondary dex storage flag must be set";
+ if (!validate_dexopt_storage_flags(dexopt_flags, &storage_flag)) {
return false;
}
-
- {
- // As opposed to the primary apk, secondary dex files might contain symlinks.
- // Resolve the path before passing it to the validate method to
- // make sure the verification is done on the real location.
- UniqueCPtr<char> dex_real_path_cstr(realpath(original_dex_path, nullptr));
- if (dex_real_path_cstr == nullptr) {
- PLOG(ERROR) << "Could not get the real path of the secondary dex file "
- << original_dex_path;
- return false;
- } else {
- dex_path_out->assign(dex_real_path_cstr.get());
- }
- }
- const std::string& dex_path = *dex_path_out;
- if (!validate_dex_path_size(dex_path)) {
+ // Compute the oat dir as it's not easy to extract it from the child computation.
+ char oat_path[PKG_PATH_MAX];
+ char oat_dir[PKG_PATH_MAX];
+ char oat_isa_dir[PKG_PATH_MAX];
+ if (!create_secondary_dex_oat_layout(
+ dex_path, instruction_set, oat_dir, oat_isa_dir, oat_path)) {
+ LOG(ERROR) << "Could not create secondary odex layout: " << dex_path;
return false;
}
- if (!validate_secondary_dex_path(pkgname, dex_path, volume_uuid, uid, storage_flag)) {
- LOG(ERROR) << "Could not validate secondary dex path " << dex_path;
- return false;
- }
-
- // Check if the path exist. If not, there's nothing to do.
- struct stat dex_path_stat;
- if (stat(dex_path.c_str(), &dex_path_stat) != 0) {
- if (errno == ENOENT) {
- // Secondary dex files might be deleted any time by the app.
- // Nothing to do if that's the case
- ALOGV("Secondary dex does not exist %s", dex_path.c_str());
- return NO_DEXOPT_NEEDED;
- } else {
- PLOG(ERROR) << "Could not access secondary dex " << dex_path;
- }
- }
-
- // Check if we should make the oat file public.
- // Note that if the dex file is not public the compiled code cannot be made public.
- *is_public_out = ((dexopt_flags & DEXOPT_PUBLIC) != 0) &&
- ((dex_path_stat.st_mode & S_IROTH) != 0);
-
- // Prepare the oat directories.
- if (!prepare_secondary_dex_oat_dir(dex_path, uid, instruction_set, oat_dir_out)) {
- return false;
- }
-
- // Analyze profiles.
- bool profile_was_updated = analyze_profiles(uid, dex_path, /*is_secondary_dex*/true);
-
- unique_fd oat_file_fd;
- unique_fd vdex_file_fd;
- unique_fd zip_fd;
- zip_fd.reset(open(dex_path.c_str(), O_RDONLY));
- if (zip_fd.get() < 0) {
- PLOG(ERROR) << "installd cannot open " << dex_path << " for input during dexopt";
- return false;
- }
- if (!maybe_open_oat_and_vdex_file(dex_path,
- *oat_dir_out,
- instruction_set,
- true /* is_secondary_dex */,
- &oat_file_fd,
- &vdex_file_fd)) {
- return false;
- }
+ oat_dir_out->assign(oat_dir);
pid_t pid = fork();
if (pid == 0) {
// child -- drop privileges before continuing.
drop_capabilities(uid);
- // Run dexoptanalyzer to get dexopt_needed code.
+
+ // Validate the path structure.
+ if (!validate_secondary_dex_path(pkgname, dex_path, volume_uuid, uid, storage_flag)) {
+ LOG(ERROR) << "Could not validate secondary dex path " << dex_path;
+ _exit(SECONDARY_DEX_DEXOPTANALYZER_SKIPPED);
+ }
+
+ // Open the dex file.
+ unique_fd zip_fd;
+ zip_fd.reset(open(dex_path.c_str(), O_RDONLY));
+ if (zip_fd.get() < 0) {
+ if (errno == ENOENT) {
+ _exit(SECONDARY_DEX_DEXOPTANALYZER_SKIPPED_NO_FILE);
+ } else {
+ _exit(SECONDARY_DEX_DEXOPTANALYZER_SKIPPED);
+ }
+ }
+
+ // Prepare the oat directories.
+ if (!prepare_secondary_dex_oat_dir(dex_path, uid, instruction_set)) {
+ _exit(SECONDARY_DEX_DEXOPTANALYZER_SKIPPED);
+ }
+
+ // Open the vdex/oat files if any.
+ unique_fd oat_file_fd;
+ unique_fd vdex_file_fd;
+ if (!maybe_open_oat_and_vdex_file(dex_path,
+ *oat_dir_out,
+ instruction_set,
+ true /* is_secondary_dex */,
+ &oat_file_fd,
+ &vdex_file_fd)) {
+ _exit(SECONDARY_DEX_DEXOPTANALYZER_SKIPPED);
+ }
+
+ // Analyze profiles.
+ bool profile_was_updated = analyze_profiles(uid, dex_path, /*is_secondary_dex*/true);
+
+ // Run dexoptanalyzer to get dexopt_needed code. This is not expected to return.
exec_dexoptanalyzer(dex_path,
vdex_file_fd.get(),
oat_file_fd.get(),
zip_fd.get(),
instruction_set,
- compiler_filter,
- profile_was_updated,
- downgrade, class_loader_context);
- exit(DEXOPTANALYZER_BIN_EXEC_ERROR);
+ compiler_filter, profile_was_updated,
+ downgrade,
+ class_loader_context);
+ PLOG(ERROR) << "Failed to exec dexoptanalyzer";
+ _exit(SECONDARY_DEX_DEXOPTANALYZER_SKIPPED);
}
/* parent */
-
int result = wait_child(pid);
if (!WIFEXITED(result)) {
LOG(ERROR) << "dexoptanalyzer failed for path " << dex_path << ": " << result;
return false;
}
result = WEXITSTATUS(result);
- bool success = process_dexoptanalyzer_result(dex_path, result, dexopt_needed_out);
+ // Check that we successfully executed dexoptanalyzer.
+ bool success = process_secondary_dexoptanalyzer_result(dex_path, result, dexopt_needed_out);
+
+ LOG(DEBUG) << "Processed secondary dex file " << dex_path << " result=" << result;
+
// Run dexopt only if needed or forced.
- // Note that dexoptanalyzer is executed even if force compilation is enabled.
- // We ignore its valid dexopNeeded result, but still check (in process_dexoptanalyzer_result)
- // that we only get results for odex files (apk_dir/oat/isa/code.odex) and not
- // for oat files from dalvik-cache.
- if (success && ((dexopt_flags & DEXOPT_FORCE) != 0)) {
+ // Note that dexoptanalyzer is executed even if force compilation is enabled (because it
+ // makes the code simpler; force compilation is only needed during tests).
+ if (success &&
+ (result != SECONDARY_DEX_DEXOPTANALYZER_SKIPPED_NO_FILE) &&
+ ((dexopt_flags & DEXOPT_FORCE) != 0)) {
*dexopt_needed_out = DEX2OAT_FROM_SCRATCH;
}
+ // Check if we should make the oat file public.
+ // Note that if the dex file is not public the compiled code cannot be made public.
+ // It is ok to check this flag outside in the parent process.
+ *is_public_out = ((dexopt_flags & DEXOPT_PUBLIC) != 0) && is_file_public(dex_path);
+
return success;
}
@@ -1708,13 +1778,11 @@
// Check if we're dealing with a secondary dex file and if we need to compile it.
std::string oat_dir_str;
- std::string dex_real_path;
if (is_secondary_dex) {
if (process_secondary_dex_dexopt(dex_path, pkgname, dexopt_flags, volume_uuid, uid,
instruction_set, compiler_filter, &is_public, &dexopt_needed, &oat_dir_str,
- &dex_real_path, downgrade, class_loader_context)) {
+ downgrade, class_loader_context)) {
oat_dir = oat_dir_str.c_str();
- dex_path = dex_real_path.c_str();
if (dexopt_needed == NO_DEXOPT_NEEDED) {
return 0; // Nothing to do, report success.
}
@@ -1852,29 +1920,13 @@
return false;
}
-// Create the oat file structure for the secondary dex 'dex_path' and assign
-// the individual path component to the 'out_' parameters.
-static bool create_secondary_dex_oat_layout(const std::string& dex_path, const std::string& isa,
- /*out*/char* out_oat_dir, /*out*/char* out_oat_isa_dir, /*out*/char* out_oat_path) {
- size_t dirIndex = dex_path.rfind('/');
- if (dirIndex == std::string::npos) {
- LOG(ERROR) << "Unexpected dir structure for dex file " << dex_path;
- return false;
- }
- // TODO(calin): we have similar computations in at lest 3 other places
- // (InstalldNativeService, otapropt and dexopt). Unify them and get rid of snprintf by
- // use string append.
- std::string apk_dir = dex_path.substr(0, dirIndex);
- snprintf(out_oat_dir, PKG_PATH_MAX, "%s/oat", apk_dir.c_str());
- snprintf(out_oat_isa_dir, PKG_PATH_MAX, "%s/%s", out_oat_dir, isa.c_str());
-
- if (!create_oat_out_path(dex_path.c_str(), isa.c_str(), out_oat_dir,
- /*is_secondary_dex*/true, out_oat_path)) {
- LOG(ERROR) << "Could not create oat path for secondary dex " << dex_path;
- return false;
- }
- return true;
-}
+enum ReconcileSecondaryDexResult {
+ kReconcileSecondaryDexExists = 0,
+ kReconcileSecondaryDexCleanedUp = 1,
+ kReconcileSecondaryDexValidationError = 2,
+ kReconcileSecondaryDexCleanUpError = 3,
+ kReconcileSecondaryDexAccessIOError = 4,
+};
// Reconcile the secondary dex 'dex_path' and its generated oat files.
// Return true if all the parameters are valid and the secondary dex file was
@@ -1888,36 +1940,15 @@
const std::string& pkgname, int uid, const std::vector<std::string>& isas,
const std::unique_ptr<std::string>& volume_uuid, int storage_flag,
/*out*/bool* out_secondary_dex_exists) {
- // Set out to false to start with, just in case we have validation errors.
- *out_secondary_dex_exists = false;
- if (!validate_dex_path_size(dex_path)) {
- return false;
- }
-
+ *out_secondary_dex_exists = false; // start by assuming the file does not exist.
if (isas.size() == 0) {
LOG(ERROR) << "reconcile_secondary_dex_file called with empty isas vector";
return false;
}
- const char* volume_uuid_cstr = volume_uuid == nullptr ? nullptr : volume_uuid->c_str();
-
- // Note that we cannot validate the package path here because the file might not exist
- // and we cannot call realpath to resolve system symlinks. Since /data/user/0 symlinks to
- // /data/data/ a lot of validations will fail if we attempt to check the package path.
- // It is still ok to be more relaxed because any file removal is done after forking and
- // dropping capabilities.
- if (!validate_secondary_dex_path(pkgname.c_str(), dex_path.c_str(), volume_uuid_cstr,
- uid, storage_flag, /*validate_package_path*/ false)) {
- LOG(ERROR) << "Could not validate secondary dex path " << dex_path;
- return false;
- }
-
- if (access(dex_path.c_str(), F_OK) == 0) {
- // The path exists, nothing to do. The odex files (if any) will be left untouched.
- *out_secondary_dex_exists = true;
- return true;
- } else if (errno != ENOENT) {
- PLOG(ERROR) << "Failed to check access to secondary dex " << dex_path;
+ if (storage_flag != FLAG_STORAGE_CE && storage_flag != FLAG_STORAGE_DE) {
+ LOG(ERROR) << "reconcile_secondary_dex_file called with invalid storage_flag: "
+ << storage_flag;
return false;
}
@@ -1925,23 +1956,39 @@
// of the package user id. So we fork and drop capabilities in the child.
pid_t pid = fork();
if (pid == 0) {
- // The secondary dex does not exist anymore. Clear any generated files.
+ /* child -- drop privileges before continuing */
+ drop_capabilities(uid);
+
+ const char* volume_uuid_cstr = volume_uuid == nullptr ? nullptr : volume_uuid->c_str();
+ if (!validate_secondary_dex_path(pkgname.c_str(), dex_path.c_str(), volume_uuid_cstr,
+ uid, storage_flag)) {
+ LOG(ERROR) << "Could not validate secondary dex path " << dex_path;
+ _exit(kReconcileSecondaryDexValidationError);
+ }
+
+ SecondaryDexAccess access_check = check_secondary_dex_access(dex_path);
+ switch (access_check) {
+ case kSecondaryDexAccessDoesNotExist:
+ // File does not exist. Proceed with cleaning.
+ break;
+ case kSecondaryDexAccessReadOk: _exit(kReconcileSecondaryDexExists);
+ case kSecondaryDexAccessIOError: _exit(kReconcileSecondaryDexAccessIOError);
+ case kSecondaryDexAccessPermissionError: _exit(kReconcileSecondaryDexValidationError);
+ default:
+ LOG(ERROR) << "Unexpected result from check_secondary_dex_access: " << access_check;
+ _exit(kReconcileSecondaryDexValidationError);
+ }
+
+ // The secondary dex does not exist anymore or it's. Clear any generated files.
char oat_path[PKG_PATH_MAX];
char oat_dir[PKG_PATH_MAX];
char oat_isa_dir[PKG_PATH_MAX];
bool result = true;
- /* child -- drop privileges before continuing */
- drop_capabilities(uid);
for (size_t i = 0; i < isas.size(); i++) {
- if (!create_secondary_dex_oat_layout(dex_path,
- isas[i],
- oat_dir,
- oat_isa_dir,
- oat_path)) {
- LOG(ERROR) << "Could not create secondary odex layout: "
- << dex_path;
- result = false;
- continue;
+ if (!create_secondary_dex_oat_layout(
+ dex_path,isas[i], oat_dir, oat_isa_dir, oat_path)) {
+ LOG(ERROR) << "Could not create secondary odex layout: " << dex_path;
+ _exit(kReconcileSecondaryDexValidationError);
}
// Delete oat/vdex/art files.
@@ -1966,11 +2013,43 @@
result = rmdir_if_empty(oat_isa_dir) && result;
result = rmdir_if_empty(oat_dir) && result;
}
- result ? _exit(0) : _exit(1);
+ if (!result) {
+ PLOG(ERROR) << "Failed to clean secondary dex artifacts for location " << dex_path;
+ }
+ _exit(result ? kReconcileSecondaryDexCleanedUp : kReconcileSecondaryDexAccessIOError);
}
int return_code = wait_child(pid);
- return return_code == 0;
+ if (!WIFEXITED(return_code)) {
+ LOG(WARNING) << "reconcile dex failed for location " << dex_path << ": " << return_code;
+ } else {
+ return_code = WEXITSTATUS(return_code);
+ }
+
+ LOG(DEBUG) << "Reconcile secondary dex path " << dex_path << " result=" << return_code;
+
+ switch (return_code) {
+ case kReconcileSecondaryDexCleanedUp:
+ case kReconcileSecondaryDexValidationError:
+ // If we couldn't validate assume the dex file does not exist.
+ // This will purge the entry from the PM records.
+ *out_secondary_dex_exists = false;
+ return true;
+ case kReconcileSecondaryDexExists:
+ *out_secondary_dex_exists = true;
+ return true;
+ case kReconcileSecondaryDexAccessIOError:
+ // We had an access IO error.
+ // Return false so that we can try again.
+ // The value of out_secondary_dex_exists does not matter in this case and by convention
+ // is set to false.
+ *out_secondary_dex_exists = false;
+ return false;
+ default:
+ LOG(ERROR) << "Unexpected code from reconcile_secondary_dex_file: " << return_code;
+ *out_secondary_dex_exists = false;
+ return false;
+ }
}
// Helper for move_ab, so that we can have common failure-case cleanup.
diff --git a/cmds/installd/tests/Android.bp b/cmds/installd/tests/Android.bp
index 89c11aa..1a22992 100644
--- a/cmds/installd/tests/Android.bp
+++ b/cmds/installd/tests/Android.bp
@@ -55,3 +55,23 @@
"liblogwrap",
],
}
+
+cc_test {
+ name: "installd_dexopt_test",
+ clang: true,
+ srcs: ["installd_dexopt_test.cpp"],
+ cflags: ["-Wall", "-Werror"],
+ shared_libs: [
+ "libbase",
+ "libbinder",
+ "libcutils",
+ "libselinux",
+ "libutils",
+ ],
+ static_libs: [
+ "libdiskusage",
+ "libinstalld",
+ "liblog",
+ "liblogwrap",
+ ],
+}
diff --git a/cmds/installd/tests/installd_dexopt_test.cpp b/cmds/installd/tests/installd_dexopt_test.cpp
new file mode 100644
index 0000000..821b96f
--- /dev/null
+++ b/cmds/installd/tests/installd_dexopt_test.cpp
@@ -0,0 +1,359 @@
+/*
+ * 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.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <android-base/logging.h>
+#include <android-base/stringprintf.h>
+#include <cutils/properties.h>
+#include <gtest/gtest.h>
+
+#include "dexopt.h"
+#include "InstalldNativeService.h"
+#include "globals.h"
+#include "tests/test_utils.h"
+#include "utils.h"
+
+namespace android {
+namespace installd {
+
+// TODO(calin): try to dedup this code.
+#if defined(__arm__)
+static const std::string kRuntimeIsa = "arm";
+#elif defined(__aarch64__)
+static const std::string kRuntimeIsa = "arm64";
+#elif defined(__mips__) && !defined(__LP64__)
+static const std::string kRuntimeIsa = "mips";
+#elif defined(__mips__) && defined(__LP64__)
+static const std::string kRuntimeIsa = "mips64";
+#elif defined(__i386__)
+static const std::string kRuntimeIsa = "x86";
+#elif defined(__x86_64__)
+static const std::string kRuntimeIsa = "x86_64";
+#else
+static const std::string kRuntimeIsa = "none";
+#endif
+
+int get_property(const char *key, char *value, const char *default_value) {
+ return property_get(key, value, default_value);
+}
+
+bool calculate_oat_file_path(char path[PKG_PATH_MAX], const char *oat_dir, const char *apk_path,
+ const char *instruction_set) {
+ return calculate_oat_file_path_default(path, oat_dir, apk_path, instruction_set);
+}
+
+bool calculate_odex_file_path(char path[PKG_PATH_MAX], const char *apk_path,
+ const char *instruction_set) {
+ return calculate_odex_file_path_default(path, apk_path, instruction_set);
+}
+
+bool create_cache_path(char path[PKG_PATH_MAX], const char *src, const char *instruction_set) {
+ return create_cache_path_default(path, src, instruction_set);
+}
+
+static void run_cmd(const std::string& cmd) {
+ system(cmd.c_str());
+}
+
+static void mkdir(const std::string& path, uid_t owner, gid_t group, mode_t mode) {
+ ::mkdir(path.c_str(), mode);
+ ::chown(path.c_str(), owner, group);
+ ::chmod(path.c_str(), mode);
+}
+
+// Base64 encoding of a simple dex files with 2 methods.
+static const char kDexFile[] =
+ "UEsDBBQAAAAIAOiOYUs9y6BLCgEAABQCAAALABwAY2xhc3Nlcy5kZXhVVAkAA/Ns+lkOHv1ZdXgL"
+ "AAEEI+UCAASIEwAAS0mt4DIwNmX4qpn7j/2wA7v7N+ZvoQpCJRlVx5SWa4YaiDAxMBQwMDBUhJkI"
+ "MUBBDyMDAzsDRJwFxAdioBDDHAYEYAbiFUAM1M5wAIhFGCGKDIDYAogdgNgDiH2BOAiI0xghekDm"
+ "sQIxGxQzM6ACRijNhCbOhCZfyohdPYyuh8szgtVkMkLsLhAAqeCDi+ejibPZZOZlltgxsDnqZSWW"
+ "JTKwOUFoZh9HayDhZM0g5AMS0M9JzEvX90/KSk0usWZgDAMaws5nAyXBzmpoYGlgAjsAyJoBMp0b"
+ "zQ8gGhbOTEhhzYwU3qxIYc2GFN6MClC/AhUyKUDMAYU9M1Qc5F8GKBscVgIQM0FxCwBQSwECHgMU"
+ "AAAACADojmFLPcugSwoBAAAUAgAACwAYAAAAAAAAAAAAoIEAAAAAY2xhc3Nlcy5kZXhVVAUAA/Ns"
+ "+ll1eAsAAQQj5QIABIgTAABQSwUGAAAAAAEAAQBRAAAATwEAAAAA";
+
+
+class DexoptTest : public testing::Test {
+protected:
+ static constexpr bool kDebug = false;
+ static constexpr uid_t kSystemUid = 1000;
+ static constexpr uid_t kSystemGid = 1000;
+ static constexpr int32_t kOSdkVersion = 25;
+ static constexpr int32_t kAppDataFlags = FLAG_STORAGE_CE | FLAG_STORAGE_DE;
+ static constexpr uid_t kTestAppUid = 19999;
+ static constexpr gid_t kTestAppGid = 19999;
+ static constexpr int32_t kTestUserId = 0;
+
+ InstalldNativeService* service_;
+ std::unique_ptr<std::string> volume_uuid_;
+ std::string package_name_;
+ std::string app_apk_dir_;
+ std::string app_private_dir_ce_;
+ std::string app_private_dir_de_;
+ std::string se_info_;
+
+ int64_t ce_data_inode_;
+
+ std::string secondary_dex_ce_;
+ std::string secondary_dex_ce_link_;
+ std::string secondary_dex_de_;
+
+ virtual void SetUp() {
+ setenv("ANDROID_LOG_TAGS", "*:v", 1);
+ android::base::InitLogging(nullptr);
+
+ service_ = new InstalldNativeService();
+
+ volume_uuid_ = nullptr;
+ package_name_ = "com.installd.test.dexopt";
+ se_info_ = "default";
+
+ init_globals_from_data_and_root();
+
+ app_apk_dir_ = android_app_dir + package_name_;
+
+ create_mock_app();
+ }
+
+ virtual void TearDown() {
+ if (!kDebug) {
+ service_->destroyAppData(
+ volume_uuid_, package_name_, kTestUserId, kAppDataFlags, ce_data_inode_);
+ run_cmd("rm -rf " + app_apk_dir_);
+ run_cmd("rm -rf " + app_private_dir_ce_);
+ run_cmd("rm -rf " + app_private_dir_de_);
+ }
+ delete service_;
+ }
+
+ void create_mock_app() {
+ // Create the oat dir.
+ std::string app_oat_dir = app_apk_dir_ + "/oat";
+ mkdir(app_apk_dir_, kSystemUid, kSystemGid, 0755);
+ service_->createOatDir(app_oat_dir, kRuntimeIsa);
+
+ // Copy the primary apk.
+ std::string apk_path = app_apk_dir_ + "/base.jar";
+ ASSERT_TRUE(WriteBase64ToFile(kDexFile, apk_path, kSystemUid, kSystemGid, 0644));
+
+ // Create the app user data.
+ ASSERT_TRUE(service_->createAppData(
+ volume_uuid_,
+ package_name_,
+ kTestUserId,
+ kAppDataFlags,
+ kTestAppUid,
+ se_info_,
+ kOSdkVersion,
+ &ce_data_inode_).isOk());
+
+ // Create a secondary dex file on CE storage
+ const char* volume_uuid_cstr = volume_uuid_ == nullptr ? nullptr : volume_uuid_->c_str();
+ app_private_dir_ce_ = create_data_user_ce_package_path(
+ volume_uuid_cstr, kTestUserId, package_name_.c_str());
+ secondary_dex_ce_ = app_private_dir_ce_ + "/secondary_ce.jar";
+ ASSERT_TRUE(WriteBase64ToFile(kDexFile, secondary_dex_ce_, kTestAppUid, kTestAppGid, 0600));
+ std::string app_private_dir_ce_link = create_data_user_ce_package_path_as_user_link(
+ volume_uuid_cstr, kTestUserId, package_name_.c_str());
+ secondary_dex_ce_link_ = app_private_dir_ce_link + "/secondary_ce.jar";
+
+ // Create a secondary dex file on DE storage.
+ app_private_dir_de_ = create_data_user_de_package_path(
+ volume_uuid_cstr, kTestUserId, package_name_.c_str());
+ secondary_dex_de_ = app_private_dir_de_ + "/secondary_de.jar";
+ ASSERT_TRUE(WriteBase64ToFile(kDexFile, secondary_dex_de_, kTestAppUid, kTestAppGid, 0600));
+
+ // Fix app data uid.
+ ASSERT_TRUE(service_->fixupAppData(volume_uuid_, kTestUserId).isOk());
+ }
+
+
+ std::string get_secondary_dex_artifact(const std::string& path, const std::string& type) {
+ std::string::size_type end = path.rfind('.');
+ std::string::size_type start = path.rfind('/', end);
+ return path.substr(0, start) + "/oat/" + kRuntimeIsa + "/" +
+ path.substr(start + 1, end - start) + type;
+ }
+
+ void compile_secondary_dex(const std::string& path, int32_t dex_storage_flag,
+ bool should_binder_call_succeed, bool should_dex_be_compiled = true,
+ int uid = kTestAppUid) {
+ std::unique_ptr<std::string> package_name_ptr(new std::string(package_name_));
+ int32_t dexopt_needed = 0; // does not matter;
+ std::unique_ptr<std::string> out_path = nullptr; // does not matter
+ int32_t dex_flags = DEXOPT_SECONDARY_DEX | dex_storage_flag;
+ std::string compiler_filter = "speed-profile";
+ std::unique_ptr<std::string> class_loader_context_ptr(new std::string("&"));
+ std::unique_ptr<std::string> se_info_ptr(new std::string(se_info_));
+ bool downgrade = false;
+
+ binder::Status result = service_->dexopt(path,
+ uid,
+ package_name_ptr,
+ kRuntimeIsa,
+ dexopt_needed,
+ out_path,
+ dex_flags,
+ compiler_filter,
+ volume_uuid_,
+ class_loader_context_ptr,
+ se_info_ptr,
+ downgrade);
+ ASSERT_EQ(should_binder_call_succeed, result.isOk());
+ int expected_access = should_dex_be_compiled ? 0 : -1;
+ std::string odex = get_secondary_dex_artifact(path, "odex");
+ std::string vdex = get_secondary_dex_artifact(path, "vdex");
+ std::string art = get_secondary_dex_artifact(path, "art");
+ ASSERT_EQ(expected_access, access(odex.c_str(), R_OK));
+ ASSERT_EQ(expected_access, access(vdex.c_str(), R_OK));
+ ASSERT_EQ(-1, access(art.c_str(), R_OK)); // empty profiles do not generate an image.
+ }
+
+ void reconcile_secondary_dex(const std::string& path, int32_t storage_flag,
+ bool should_binder_call_succeed, bool should_dex_exist, bool should_dex_be_deleted,
+ int uid = kTestAppUid, std::string* package_override = nullptr) {
+ std::vector<std::string> isas;
+ isas.push_back(kRuntimeIsa);
+ bool out_secondary_dex_exists = false;
+ binder::Status result = service_->reconcileSecondaryDexFile(
+ path,
+ package_override == nullptr ? package_name_ : *package_override,
+ uid,
+ isas,
+ volume_uuid_,
+ storage_flag,
+ &out_secondary_dex_exists);
+
+ ASSERT_EQ(should_binder_call_succeed, result.isOk());
+ ASSERT_EQ(should_dex_exist, out_secondary_dex_exists);
+
+ int expected_access = should_dex_be_deleted ? -1 : 0;
+ std::string odex = get_secondary_dex_artifact(path, "odex");
+ std::string vdex = get_secondary_dex_artifact(path, "vdex");
+ std::string art = get_secondary_dex_artifact(path, "art");
+ ASSERT_EQ(expected_access, access(odex.c_str(), F_OK));
+ ASSERT_EQ(expected_access, access(vdex.c_str(), F_OK));
+ ASSERT_EQ(-1, access(art.c_str(), R_OK)); // empty profiles do not generate an image.
+ }
+};
+
+
+TEST_F(DexoptTest, DexoptSecondaryCe) {
+ LOG(INFO) << "DexoptSecondaryCe";
+ compile_secondary_dex(secondary_dex_ce_, DEXOPT_STORAGE_CE,
+ /*binder_ok*/ true, /*compile_ok*/ true);
+}
+
+TEST_F(DexoptTest, DexoptSecondaryCeLink) {
+ LOG(INFO) << "DexoptSecondaryCeLink";
+ compile_secondary_dex(secondary_dex_ce_link_, DEXOPT_STORAGE_CE,
+ /*binder_ok*/ true, /*compile_ok*/ true);
+}
+
+TEST_F(DexoptTest, DexoptSecondaryDe) {
+ LOG(INFO) << "DexoptSecondaryDe";
+ compile_secondary_dex(secondary_dex_de_, DEXOPT_STORAGE_DE,
+ /*binder_ok*/ true, /*compile_ok*/ true);
+}
+
+TEST_F(DexoptTest, DexoptSecondaryDoesNotExist) {
+ LOG(INFO) << "DexoptSecondaryDoesNotExist";
+ // If the file validates but does not exist we do not treat it as an error.
+ compile_secondary_dex(secondary_dex_ce_ + "not.there", DEXOPT_STORAGE_CE,
+ /*binder_ok*/ true, /*compile_ok*/ false);
+}
+
+TEST_F(DexoptTest, DexoptSecondaryStorageValidationError) {
+ LOG(INFO) << "DexoptSecondaryStorageValidationError";
+ compile_secondary_dex(secondary_dex_ce_, DEXOPT_STORAGE_DE,
+ /*binder_ok*/ false, /*compile_ok*/ false);
+}
+
+TEST_F(DexoptTest, DexoptSecondaryAppOwnershipValidationError) {
+ LOG(INFO) << "DexoptSecondaryAppOwnershipValidationError";
+ compile_secondary_dex("/data/data/random.app/secondary.jar", DEXOPT_STORAGE_CE,
+ /*binder_ok*/ false, /*compile_ok*/ false);
+}
+
+TEST_F(DexoptTest, DexoptSecondaryAcessViaDifferentUidError) {
+ LOG(INFO) << "DexoptSecondaryAcessViaDifferentUidError";
+ compile_secondary_dex(secondary_dex_ce_, DEXOPT_STORAGE_CE,
+ /*binder_ok*/ false, /*compile_ok*/ false, kSystemUid);
+}
+
+
+class ReconcileTest : public DexoptTest {
+ virtual void SetUp() {
+ DexoptTest::SetUp();
+ compile_secondary_dex(secondary_dex_ce_, DEXOPT_STORAGE_CE,
+ /*binder_ok*/ true, /*compile_ok*/ true);
+ compile_secondary_dex(secondary_dex_de_, DEXOPT_STORAGE_DE,
+ /*binder_ok*/ true, /*compile_ok*/ true);
+ }
+};
+
+TEST_F(ReconcileTest, ReconcileSecondaryCeExists) {
+ LOG(INFO) << "ReconcileSecondaryCeExists";
+ reconcile_secondary_dex(secondary_dex_ce_, FLAG_STORAGE_CE,
+ /*binder_ok*/ true, /*dex_ok */ true, /*odex_deleted*/ false);
+}
+
+TEST_F(ReconcileTest, ReconcileSecondaryCeLinkExists) {
+ LOG(INFO) << "ReconcileSecondaryCeLinkExists";
+ reconcile_secondary_dex(secondary_dex_ce_link_, FLAG_STORAGE_CE,
+ /*binder_ok*/ true, /*dex_ok */ true, /*odex_deleted*/ false);
+}
+
+TEST_F(ReconcileTest, ReconcileSecondaryDeExists) {
+ LOG(INFO) << "ReconcileSecondaryDeExists";
+ reconcile_secondary_dex(secondary_dex_de_, FLAG_STORAGE_DE,
+ /*binder_ok*/ true, /*dex_ok */ true, /*odex_deleted*/ false);
+}
+
+TEST_F(ReconcileTest, ReconcileSecondaryDeDoesNotExist) {
+ LOG(INFO) << "ReconcileSecondaryDeDoesNotExist";
+ run_cmd("rm -rf " + secondary_dex_de_);
+ reconcile_secondary_dex(secondary_dex_de_, FLAG_STORAGE_DE,
+ /*binder_ok*/ true, /*dex_ok */ false, /*odex_deleted*/ true);
+}
+
+TEST_F(ReconcileTest, ReconcileSecondaryStorageValidationError) {
+ // Validation errors will not clean the odex/vdex/art files but will mark
+ // the file as non existent so that the PM knows it should purge it from its
+ // records.
+ LOG(INFO) << "ReconcileSecondaryStorageValidationError";
+ reconcile_secondary_dex(secondary_dex_ce_, FLAG_STORAGE_DE,
+ /*binder_ok*/ true, /*dex_ok */ false, /*odex_deleted*/ false);
+}
+
+TEST_F(ReconcileTest, ReconcileSecondaryAppOwnershipValidationError) {
+ LOG(INFO) << "ReconcileSecondaryAppOwnershipValidationError";
+ // Attempt to reconcile the dex files of the test app from a different app.
+ std::string another_app = "another.app";
+ reconcile_secondary_dex(secondary_dex_ce_, FLAG_STORAGE_CE,
+ /*binder_ok*/ true, /*dex_ok */ false, /*odex_deleted*/ false, kSystemUid, &another_app);
+}
+
+TEST_F(ReconcileTest, ReconcileSecondaryAcessViaDifferentUidError) {
+ LOG(INFO) << "ReconcileSecondaryAcessViaDifferentUidError";
+ reconcile_secondary_dex(secondary_dex_ce_, FLAG_STORAGE_CE,
+ /*binder_ok*/ true, /*dex_ok */ false, /*odex_deleted*/ false, kSystemUid);
+}
+
+} // namespace installd
+} // namespace android
diff --git a/cmds/installd/tests/installd_utils_test.cpp b/cmds/installd/tests/installd_utils_test.cpp
index 2ca7ac2..a6a4451 100644
--- a/cmds/installd/tests/installd_utils_test.cpp
+++ b/cmds/installd/tests/installd_utils_test.cpp
@@ -379,6 +379,7 @@
TEST_F(UtilsTest, ValidateSecondaryDexFilesPath) {
std::string package_name = "com.test.app";
std::string app_dir_ce_user_0 = "/data/data/" + package_name;
+ std::string app_dir_ce_user_0_link = "/data/user/0/" + package_name;
std::string app_dir_ce_user_10 = "/data/user/10/" + package_name;
std::string app_dir_de_user_0 = "/data/user_de/0/" + package_name;
@@ -400,6 +401,8 @@
// Standard path for user 0 on CE storage.
pass_secondary_dex_validation(
package_name, app_dir_ce_user_0 + "/ce0.dex", app_uid_for_user_0, FLAG_STORAGE_CE);
+ pass_secondary_dex_validation(
+ package_name, app_dir_ce_user_0_link + "/ce0.dex", app_uid_for_user_0, FLAG_STORAGE_CE);
// Standard path for user 10 on CE storage.
pass_secondary_dex_validation(
package_name, app_dir_ce_user_10 + "/ce10.dex", app_uid_for_user_10, FLAG_STORAGE_CE);
diff --git a/cmds/installd/tests/test_utils.h b/cmds/installd/tests/test_utils.h
new file mode 100644
index 0000000..7d1162e
--- /dev/null
+++ b/cmds/installd/tests/test_utils.h
@@ -0,0 +1,107 @@
+#include <android-base/logging.h>
+#include <stdlib.h>
+#include <string.h>
+
+uint8_t kBase64Map[256] = {
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 62, 255, 255, 255, 63,
+ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 255, 255,
+ 255, 254, 255, 255, 255, 0, 1, 2, 3, 4, 5, 6,
+ 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+ 19, 20, 21, 22, 23, 24, 25, 255, 255, 255, 255, 255,
+ 255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
+ 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
+ 49, 50, 51, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255
+};
+
+uint8_t* DecodeBase64(const char* src, size_t* dst_size) {
+ CHECK(dst_size != nullptr);
+ std::vector<uint8_t> tmp;
+ uint32_t t = 0, y = 0;
+ int g = 3;
+ for (size_t i = 0; src[i] != '\0'; ++i) {
+ uint8_t c = kBase64Map[src[i] & 0xFF];
+ if (c == 255) continue;
+ // the final = symbols are read and used to trim the remaining bytes
+ if (c == 254) {
+ c = 0;
+ // prevent g < 0 which would potentially allow an overflow later
+ if (--g < 0) {
+ *dst_size = 0;
+ return nullptr;
+ }
+ } else if (g != 3) {
+ // we only allow = to be at the end
+ *dst_size = 0;
+ return nullptr;
+ }
+ t = (t << 6) | c;
+ if (++y == 4) {
+ tmp.push_back((t >> 16) & 255);
+ if (g > 1) {
+ tmp.push_back((t >> 8) & 255);
+ }
+ if (g > 2) {
+ tmp.push_back(t & 255);
+ }
+ y = t = 0;
+ }
+ }
+ if (y != 0) {
+ *dst_size = 0;
+ return nullptr;
+ }
+ std::unique_ptr<uint8_t[]> dst(new uint8_t[tmp.size()]);
+ *dst_size = tmp.size();
+ std::copy(tmp.begin(), tmp.end(), dst.get());
+ return dst.release();
+}
+
+bool WriteBase64ToFile(const char* base64, const std::string& file,
+ uid_t uid, gid_t gid, int mode) {
+ CHECK(base64 != nullptr);
+ size_t length;
+ std::unique_ptr<uint8_t[]> bytes(DecodeBase64(base64, &length));
+ CHECK(bytes != nullptr);
+
+
+ int fd = open(file.c_str(), O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
+
+ if (fd < 0) {
+ PLOG(ERROR) << "Could not open file " << file;
+ return false;
+ }
+
+ size_t wrote = 0;
+ while (wrote < length) {
+ ssize_t cur = write(fd, bytes.get() + wrote, length - wrote);
+ if (cur == -1) {
+ PLOG(ERROR) << "Could not write file " << file;
+ return false;
+ }
+ wrote += cur;
+ }
+
+ if (::chown(file.c_str(), uid, gid) != 0) {
+ PLOG(ERROR) << "Could not chown file " << file;
+ return false;
+ }
+ if (::chmod(file.c_str(), mode) != 0) {
+ PLOG(ERROR) << "Could not chmod file " << file;
+ return false;
+ }
+ return true;
+}
diff --git a/cmds/installd/utils.cpp b/cmds/installd/utils.cpp
index ca0a82e..7dca7c6 100644
--- a/cmds/installd/utils.cpp
+++ b/cmds/installd/utils.cpp
@@ -87,6 +87,20 @@
create_data_user_ce_path(volume_uuid, user).c_str(), package_name);
}
+/**
+ * Create the path name where package data should be stored for the given
+ * volume UUID, package name, and user ID. An empty UUID is assumed to be
+ * internal storage.
+ * Compared to create_data_user_ce_package_path this method always return the
+ * ".../user/..." directory.
+ */
+std::string create_data_user_ce_package_path_as_user_link(
+ const char* volume_uuid, userid_t userid, const char* package_name) {
+ check_package_name(package_name);
+ std::string data(create_data_path(volume_uuid));
+ return StringPrintf("%s/user/%u/%s", data.c_str(), userid, package_name);
+}
+
std::string create_data_user_ce_package_path(const char* volume_uuid, userid_t user,
const char* package_name, ino_t ce_data_inode) {
// For testing purposes, rely on the inode when defined; this could be
@@ -786,7 +800,7 @@
}
bool validate_secondary_dex_path(const std::string& pkgname, const std::string& dex_path,
- const char* volume_uuid, int uid, int storage_flag, bool validate_package_path) {
+ const char* volume_uuid, int uid, int storage_flag) {
CHECK(storage_flag == FLAG_STORAGE_CE || storage_flag == FLAG_STORAGE_DE);
// Empty paths are not allowed.
@@ -800,16 +814,20 @@
// The path should be at most PKG_PATH_MAX long.
if (dex_path.size() > PKG_PATH_MAX) { return false; }
- if (validate_package_path) {
- // If we are asked to validate the package path check that
- // the dex_path is under the app data directory.
- std::string app_private_dir = storage_flag == FLAG_STORAGE_CE
+ // The dex_path should be under the app data directory.
+ std::string app_private_dir = storage_flag == FLAG_STORAGE_CE
? 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());
- if (strncmp(dex_path.c_str(), app_private_dir.c_str(), app_private_dir.size()) != 0) {
+ if (strncmp(dex_path.c_str(), app_private_dir.c_str(), app_private_dir.size()) != 0) {
+ // The check above might fail if the dex file is accessed via the /data/user/0 symlink.
+ // If that's the case, attempt to validate against the user data link.
+ std::string app_private_dir_symlink = create_data_user_ce_package_path_as_user_link(
+ volume_uuid, multiuser_get_user_id(uid), pkgname.c_str());
+ if (strncmp(dex_path.c_str(), app_private_dir_symlink.c_str(),
+ app_private_dir_symlink.size()) != 0) {
return false;
}
}
diff --git a/cmds/installd/utils.h b/cmds/installd/utils.h
index 3e04af9..b90caf9 100644
--- a/cmds/installd/utils.h
+++ b/cmds/installd/utils.h
@@ -60,6 +60,8 @@
userid_t user, const char* package_name, ino_t ce_data_inode);
std::string create_data_user_de_package_path(const char* volume_uuid,
userid_t user, const char* package_name);
+std::string create_data_user_ce_package_path_as_user_link(
+ const char* volume_uuid, userid_t userid, const char* package_name);
std::string create_data_media_path(const char* volume_uuid, userid_t userid);
std::string create_data_media_obb_path(const char* volume_uuid, const char* package_name);
@@ -114,7 +116,7 @@
int validate_system_app_path(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, bool validate_package_path = true);
+ const char* volume_uuid, int uid, int storage_flag);
int validate_apk_path(const char *path);
int validate_apk_path_subdirs(const char *path);
diff --git a/docs/Doxyfile b/docs/Doxyfile
index bb0ca32..0ec4551 100644
--- a/docs/Doxyfile
+++ b/docs/Doxyfile
@@ -677,7 +677,7 @@
# directories like "/usr/src/myproject". Separate the files or directories
# with spaces.
-INPUT = ../include/android ../../av/include/ndk ../../av/include/camera/ndk
+INPUT = ../include/android ../../av/media/ndk/include ../../av/camera/ndk/include
# This tag can be used to specify the character encoding of the source files
# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
diff --git a/libs/vr/libbufferhub/Android.bp b/libs/vr/libbufferhub/Android.bp
index e3cb494..9481c37 100644
--- a/libs/vr/libbufferhub/Android.bp
+++ b/libs/vr/libbufferhub/Android.bp
@@ -29,6 +29,7 @@
sharedLibraries = [
"libbase",
+ "libbinder",
"libcutils",
"libhardware",
"liblog",
@@ -48,6 +49,8 @@
"-DLOG_TAG=\"libbufferhub\"",
"-DTRACE=0",
"-DATRACE_TAG=ATRACE_TAG_GRAPHICS",
+ "-Wall",
+ "-Werror",
],
export_include_dirs: localIncludeFiles,
static_libs: staticLibraries,
diff --git a/libs/vr/libbufferhubqueue/Android.bp b/libs/vr/libbufferhubqueue/Android.bp
index 93ccd0f..8241809 100644
--- a/libs/vr/libbufferhubqueue/Android.bp
+++ b/libs/vr/libbufferhubqueue/Android.bp
@@ -14,6 +14,7 @@
sourceFiles = [
"buffer_hub_queue_client.cpp",
+ "buffer_hub_queue_parcelable.cpp",
"buffer_hub_queue_producer.cpp",
]
@@ -49,6 +50,11 @@
"-DLOG_TAG=\"libbufferhubqueue\"",
"-DTRACE=0",
"-DATRACE_TAG=ATRACE_TAG_GRAPHICS",
+ "-Wall",
+ "-Werror",
+ "-Wno-format",
+ "-Wno-unused-parameter",
+ "-Wno-unused-variable",
],
srcs: sourceFiles,
export_include_dirs: includeFiles,
diff --git a/libs/vr/libbufferhubqueue/buffer_hub_queue_client.cpp b/libs/vr/libbufferhubqueue/buffer_hub_queue_client.cpp
index 8bea0cd..a5cefd9 100644
--- a/libs/vr/libbufferhubqueue/buffer_hub_queue_client.cpp
+++ b/libs/vr/libbufferhubqueue/buffer_hub_queue_client.cpp
@@ -137,6 +137,28 @@
return status;
}
+pdx::Status<ConsumerQueueParcelable>
+BufferHubQueue::CreateConsumerQueueParcelable(bool silent) {
+ auto status = CreateConsumerQueueHandle(silent);
+ if (!status)
+ return status.error_status();
+
+ // A temporary consumer queue client to pull its channel parcelable.
+ auto consumer_queue =
+ std::unique_ptr<ConsumerQueue>(new ConsumerQueue(status.take()));
+ ConsumerQueueParcelable queue_parcelable(
+ consumer_queue->GetChannel()->TakeChannelParcelable());
+
+ if (!queue_parcelable.IsValid()) {
+ ALOGE(
+ "BufferHubQueue::CreateConsumerQueueParcelable: Failed to create "
+ "consumer queue parcelable.");
+ return ErrorStatus(EINVAL);
+ }
+
+ return {std::move(queue_parcelable)};
+}
+
bool BufferHubQueue::WaitForBuffers(int timeout) {
ATRACE_NAME("BufferHubQueue::WaitForBuffers");
std::array<epoll_event, kMaxEvents> events;
@@ -555,6 +577,25 @@
return {std::move(buffer)};
}
+pdx::Status<ProducerQueueParcelable> ProducerQueue::TakeAsParcelable() {
+ if (capacity() != 0) {
+ ALOGE(
+ "ProducerQueue::TakeAsParcelable: producer queue can only be taken out"
+ " as a parcelable when empty. Current queue capacity: %zu",
+ capacity());
+ return ErrorStatus(EINVAL);
+ }
+
+ std::unique_ptr<pdx::ClientChannel> channel = TakeChannel();
+ ProducerQueueParcelable queue_parcelable(channel->TakeChannelParcelable());
+
+ // Here the queue parcelable is returned and holds the underlying system
+ // resources backing the queue; while the original client channel of this
+ // producer queue is destroyed in place so that this client can no longer
+ // provide producer operations.
+ return {std::move(queue_parcelable)};
+}
+
ConsumerQueue::ConsumerQueue(LocalChannelHandle handle)
: BufferHubQueue(std::move(handle)) {
auto status = ImportQueue();
diff --git a/libs/vr/libbufferhubqueue/buffer_hub_queue_parcelable.cpp b/libs/vr/libbufferhubqueue/buffer_hub_queue_parcelable.cpp
new file mode 100644
index 0000000..2cd7c45
--- /dev/null
+++ b/libs/vr/libbufferhubqueue/buffer_hub_queue_parcelable.cpp
@@ -0,0 +1,82 @@
+#include "include/private/dvr/buffer_hub_queue_parcelable.h"
+
+#include <binder/Parcel.h>
+#include <pdx/default_transport/channel_parcelable.h>
+
+namespace android {
+namespace dvr {
+
+template <BufferHubQueueParcelableMagic Magic>
+bool BufferHubQueueParcelable<Magic>::IsValid() const {
+ return !!channel_parcelable_ && channel_parcelable_->IsValid();
+}
+
+template <BufferHubQueueParcelableMagic Magic>
+pdx::LocalChannelHandle BufferHubQueueParcelable<Magic>::TakeChannelHandle() {
+ if (!IsValid()) {
+ ALOGE(
+ "BufferHubQueueParcelable::TakeChannelHandle: Invalid channel parcel.");
+ return {}; // Returns an empty channel handle.
+ }
+
+ // Take channel handle out of the parcelable and reset the parcelable.
+ pdx::LocalChannelHandle handle = channel_parcelable_->TakeChannelHandle();
+ // Now channel_parcelable_ should already be invalid, but reset it to release
+ // the invalid parcelable object from unique_ptr.
+ channel_parcelable_ = nullptr;
+ return handle;
+}
+
+template <BufferHubQueueParcelableMagic Magic>
+status_t BufferHubQueueParcelable<Magic>::writeToParcel(Parcel* parcel) const {
+ if (!IsValid()) {
+ ALOGE("BufferHubQueueParcelable::writeToParcel: Invalid channel.");
+ return -EINVAL;
+ }
+
+ status_t res = parcel->writeUint32(Magic);
+ if (res != NO_ERROR) {
+ ALOGE("BufferHubQueueParcelable::writeToParcel: Cannot write magic.");
+ return res;
+ }
+
+ return channel_parcelable_->writeToParcel(parcel);
+}
+
+template <BufferHubQueueParcelableMagic Magic>
+status_t BufferHubQueueParcelable<Magic>::readFromParcel(const Parcel* parcel) {
+ if (IsValid()) {
+ ALOGE(
+ "BufferHubQueueParcelable::readFromParcel: This parcelable object has "
+ "been initialized already.");
+ return -EINVAL;
+ }
+
+ uint32_t out_magic = 0;
+ status_t res = NO_ERROR;
+
+ res = parcel->readUint32(&out_magic);
+ if (res != NO_ERROR)
+ return res;
+
+ if (out_magic != Magic) {
+ ALOGE(
+ "BufferHubQueueParcelable::readFromParcel: Unexpected magic: 0x%x, "
+ "epxected: 0x%x",
+ out_magic, Magic);
+ return -EINVAL;
+ }
+
+ // (Re)Alocate channel parcelable object.
+ channel_parcelable_ =
+ std::make_unique<pdx::default_transport::ChannelParcelable>();
+ return channel_parcelable_->readFromParcel(parcel);
+}
+
+template class BufferHubQueueParcelable<
+ BufferHubQueueParcelableMagic::Producer>;
+template class BufferHubQueueParcelable<
+ BufferHubQueueParcelableMagic::Consumer>;
+
+} // namespace dvr
+} // namespace android
diff --git a/libs/vr/libbufferhubqueue/include/private/dvr/buffer_hub_queue_client.h b/libs/vr/libbufferhubqueue/include/private/dvr/buffer_hub_queue_client.h
index 6962d6c..c8e31c7 100644
--- a/libs/vr/libbufferhubqueue/include/private/dvr/buffer_hub_queue_client.h
+++ b/libs/vr/libbufferhubqueue/include/private/dvr/buffer_hub_queue_client.h
@@ -6,6 +6,7 @@
#include <pdx/client.h>
#include <pdx/status.h>
#include <private/dvr/buffer_hub_client.h>
+#include <private/dvr/buffer_hub_queue_parcelable.h>
#include <private/dvr/bufferhub_rpc.h>
#include <private/dvr/epoll_file_descriptor.h>
#include <private/dvr/ring_buffer.h>
@@ -54,6 +55,11 @@
pdx::Status<pdx::LocalChannelHandle> CreateConsumerQueueHandle(
bool silent = false);
+ // Creates a new consumer in parcelable form for immediate transport over
+ // Binder.
+ pdx::Status<ConsumerQueueParcelable> CreateConsumerQueueParcelable(
+ bool silent = false);
+
// Returns the number of buffers avaiable for dequeue.
size_t count() const { return available_buffers_.size(); }
@@ -337,6 +343,11 @@
return BufferHubQueue::Enqueue({buffer, slot, index});
}
+ // Takes out the current producer queue as a binder parcelable object. Note
+ // that the queue must be empty to be exportable. After successful export, the
+ // producer queue client should no longer be used.
+ pdx::Status<ProducerQueueParcelable> TakeAsParcelable();
+
private:
friend BASE;
diff --git a/libs/vr/libbufferhubqueue/include/private/dvr/buffer_hub_queue_parcelable.h b/libs/vr/libbufferhubqueue/include/private/dvr/buffer_hub_queue_parcelable.h
new file mode 100644
index 0000000..89baf92
--- /dev/null
+++ b/libs/vr/libbufferhubqueue/include/private/dvr/buffer_hub_queue_parcelable.h
@@ -0,0 +1,60 @@
+#ifndef ANDROID_DVR_BUFFER_HUB_QUEUE_PARCELABLE_H_
+#define ANDROID_DVR_BUFFER_HUB_QUEUE_PARCELABLE_H_
+
+#include <pdx/channel_parcelable.h>
+
+namespace android {
+namespace dvr {
+
+enum BufferHubQueueParcelableMagic : uint32_t {
+ Producer = 0x62687170, // 'bhqp'
+ Consumer = 0x62687163, // 'bhqc'
+};
+
+template <BufferHubQueueParcelableMagic Magic>
+class BufferHubQueueParcelable : public Parcelable {
+ public:
+ BufferHubQueueParcelable() = default;
+
+ BufferHubQueueParcelable(BufferHubQueueParcelable&& other) = default;
+ BufferHubQueueParcelable& operator=(BufferHubQueueParcelable&& other) =
+ default;
+
+ // Constructs an parcelable contains the channel parcelable.
+ BufferHubQueueParcelable(
+ std::unique_ptr<pdx::ChannelParcelable> channel_parcelable)
+ : channel_parcelable_(std::move(channel_parcelable)) {}
+
+ BufferHubQueueParcelable(const BufferHubQueueParcelable&) = delete;
+ void operator=(const BufferHubQueueParcelable&) = delete;
+
+ bool IsValid() const;
+
+ // Returns a channel handle constructed from this parcelable object and takes
+ // the ownership of all resources from the parcelable object.
+ pdx::LocalChannelHandle TakeChannelHandle();
+
+ // Serializes the queue parcelable into the given parcel. Note that no system
+ // resources are getting duplicated, nor did the parcel takes ownership of the
+ // queue parcelable. Thus, the parcelable object must remain valid for the
+ // lifetime of the parcel.
+ status_t writeToParcel(Parcel* parcel) const override;
+
+ // Deserialize the queue parcelable from the given parcel. Note that system
+ // resources are duplicated from the parcel into the queue parcelable. Returns
+ // error if the targeting parcelable object is already valid.
+ status_t readFromParcel(const Parcel* parcel) override;
+
+ private:
+ std::unique_ptr<pdx::ChannelParcelable> channel_parcelable_;
+};
+
+using ProducerQueueParcelable =
+ BufferHubQueueParcelable<BufferHubQueueParcelableMagic::Producer>;
+using ConsumerQueueParcelable =
+ BufferHubQueueParcelable<BufferHubQueueParcelableMagic::Consumer>;
+
+} // namespace dvr
+} // namespace android
+
+#endif // ANDROID_DVR_BUFFER_HUB_QUEUE_PARCELABLE_H_
diff --git a/libs/vr/libbufferhubqueue/tests/Android.bp b/libs/vr/libbufferhubqueue/tests/Android.bp
index 5e4df84..abeb719 100644
--- a/libs/vr/libbufferhubqueue/tests/Android.bp
+++ b/libs/vr/libbufferhubqueue/tests/Android.bp
@@ -34,6 +34,9 @@
"-DTRACE=0",
"-O0",
"-g",
+ "-Wall",
+ "-Werror",
+ "-Wno-error=sign-compare", // to fix later
],
name: "buffer_hub_queue-test",
tags: ["optional"],
@@ -49,6 +52,8 @@
"-DTRACE=0",
"-O0",
"-g",
+ "-Wall",
+ "-Werror",
],
name: "buffer_hub_queue_producer-test",
tags: ["optional"],
diff --git a/libs/vr/libbufferhubqueue/tests/buffer_hub_queue-test.cpp b/libs/vr/libbufferhubqueue/tests/buffer_hub_queue-test.cpp
index 8a72531..f67ef37 100644
--- a/libs/vr/libbufferhubqueue/tests/buffer_hub_queue-test.cpp
+++ b/libs/vr/libbufferhubqueue/tests/buffer_hub_queue-test.cpp
@@ -1,4 +1,5 @@
#include <base/logging.h>
+#include <binder/Parcel.h>
#include <private/dvr/buffer_hub_client.h>
#include <private/dvr/buffer_hub_queue_client.h>
@@ -14,6 +15,7 @@
namespace android {
namespace dvr {
+using pdx::LocalChannelHandle;
using pdx::LocalHandle;
namespace {
@@ -680,6 +682,156 @@
#undef CHECK_NO_BUFFER_THEN_ALLOCATE
}
+TEST_F(BufferHubQueueTest, TestProducerToParcelableNotEmpty) {
+ ASSERT_TRUE(CreateQueues(config_builder_.SetMetadata<uint64_t>().Build(),
+ UsagePolicy{}));
+
+ // Allocate only one buffer.
+ AllocateBuffer();
+
+ // Export should fail as the queue is not empty.
+ auto status = producer_queue_->TakeAsParcelable();
+ EXPECT_FALSE(status.ok());
+}
+
+TEST_F(BufferHubQueueTest, TestProducerExportToParcelable) {
+ ASSERT_TRUE(CreateQueues(config_builder_.Build(), UsagePolicy{}));
+
+ auto s1 = producer_queue_->TakeAsParcelable();
+ EXPECT_TRUE(s1.ok());
+
+ ProducerQueueParcelable output_parcelable = s1.take();
+ EXPECT_TRUE(output_parcelable.IsValid());
+
+ Parcel parcel;
+ status_t res;
+ res = output_parcelable.writeToParcel(&parcel);
+ EXPECT_EQ(res, NO_ERROR);
+
+ // After written into parcelable, the output_parcelable is still valid has
+ // keeps the producer channel alive.
+ EXPECT_TRUE(output_parcelable.IsValid());
+
+ // Creating producer buffer should fail.
+ auto s2 = producer_queue_->AllocateBuffer(kBufferWidth, kBufferHeight,
+ kBufferLayerCount, kBufferFormat,
+ kBufferUsage);
+ ASSERT_FALSE(s2.ok());
+
+ // Reset the data position so that we can read back from the same parcel
+ // without doing actually Binder IPC.
+ parcel.setDataPosition(0);
+ producer_queue_ = nullptr;
+
+ // Recreate the producer queue from the parcel.
+ ProducerQueueParcelable input_parcelable;
+ EXPECT_FALSE(input_parcelable.IsValid());
+
+ res = input_parcelable.readFromParcel(&parcel);
+ EXPECT_EQ(res, NO_ERROR);
+ EXPECT_TRUE(input_parcelable.IsValid());
+
+ EXPECT_EQ(producer_queue_, nullptr);
+ producer_queue_ = ProducerQueue::Import(input_parcelable.TakeChannelHandle());
+ EXPECT_FALSE(input_parcelable.IsValid());
+ ASSERT_NE(producer_queue_, nullptr);
+
+ // Newly created queue from the parcel can allocate buffer, post buffer to
+ // consumer.
+ EXPECT_NO_FATAL_FAILURE(AllocateBuffer());
+ EXPECT_EQ(producer_queue_->count(), 1U);
+ EXPECT_EQ(producer_queue_->capacity(), 1U);
+
+ size_t slot;
+ DvrNativeBufferMetadata producer_meta;
+ DvrNativeBufferMetadata consumer_meta;
+ LocalHandle fence;
+ auto s3 = producer_queue_->Dequeue(0, &slot, &producer_meta, &fence);
+ EXPECT_TRUE(s3.ok());
+
+ std::shared_ptr<BufferProducer> p1 = s3.take();
+ EXPECT_NE(p1, nullptr);
+
+ producer_meta.timestamp = 42;
+ EXPECT_EQ(p1->PostAsync(&producer_meta, LocalHandle()), 0);
+
+ // Make sure the buffer can be dequeued from consumer side.
+ auto s4 = consumer_queue_->Dequeue(100, &slot, &consumer_meta, &fence);
+ EXPECT_TRUE(s4.ok());
+ EXPECT_EQ(consumer_queue_->capacity(), 1U);
+
+ auto consumer = s4.take();
+ EXPECT_NE(consumer, nullptr);
+ EXPECT_EQ(producer_meta.timestamp, consumer_meta.timestamp);
+}
+
+TEST_F(BufferHubQueueTest, TestCreateConsumerParcelable) {
+ ASSERT_TRUE(CreateProducerQueue(config_builder_.Build(), UsagePolicy{}));
+
+ auto s1 = producer_queue_->CreateConsumerQueueParcelable();
+ EXPECT_TRUE(s1.ok());
+ ConsumerQueueParcelable output_parcelable = s1.take();
+ EXPECT_TRUE(output_parcelable.IsValid());
+
+ // Write to a Parcel new object.
+ Parcel parcel;
+ status_t res;
+ res = output_parcelable.writeToParcel(&parcel);
+
+ // Reset the data position so that we can read back from the same parcel
+ // without doing actually Binder IPC.
+ parcel.setDataPosition(0);
+
+ // No consumer queue created yet.
+ EXPECT_EQ(consumer_queue_, nullptr);
+
+ // If the parcel contains a consumer queue, read into a
+ // ProducerQueueParcelable should fail.
+ ProducerQueueParcelable wrongly_typed_parcelable;
+ EXPECT_FALSE(wrongly_typed_parcelable.IsValid());
+ res = wrongly_typed_parcelable.readFromParcel(&parcel);
+ EXPECT_EQ(res, -EINVAL);
+ parcel.setDataPosition(0);
+
+ // Create the consumer queue from the parcel.
+ ConsumerQueueParcelable input_parcelable;
+ EXPECT_FALSE(input_parcelable.IsValid());
+
+ res = input_parcelable.readFromParcel(&parcel);
+ EXPECT_EQ(res, NO_ERROR);
+ EXPECT_TRUE(input_parcelable.IsValid());
+
+ consumer_queue_ = ConsumerQueue::Import(input_parcelable.TakeChannelHandle());
+ EXPECT_FALSE(input_parcelable.IsValid());
+ ASSERT_NE(consumer_queue_, nullptr);
+
+ EXPECT_NO_FATAL_FAILURE(AllocateBuffer());
+ EXPECT_EQ(producer_queue_->count(), 1U);
+ EXPECT_EQ(producer_queue_->capacity(), 1U);
+
+ size_t slot;
+ DvrNativeBufferMetadata producer_meta;
+ DvrNativeBufferMetadata consumer_meta;
+ LocalHandle fence;
+ auto s2 = producer_queue_->Dequeue(0, &slot, &producer_meta, &fence);
+ EXPECT_TRUE(s2.ok());
+
+ std::shared_ptr<BufferProducer> p1 = s2.take();
+ EXPECT_NE(p1, nullptr);
+
+ producer_meta.timestamp = 42;
+ EXPECT_EQ(p1->PostAsync(&producer_meta, LocalHandle()), 0);
+
+ // Make sure the buffer can be dequeued from consumer side.
+ auto s3 = consumer_queue_->Dequeue(100, &slot, &consumer_meta, &fence);
+ EXPECT_TRUE(s3.ok());
+ EXPECT_EQ(consumer_queue_->capacity(), 1U);
+
+ auto consumer = s3.take();
+ EXPECT_NE(consumer, nullptr);
+ EXPECT_EQ(producer_meta.timestamp, consumer_meta.timestamp);
+}
+
} // namespace
} // namespace dvr
diff --git a/libs/vr/libdisplay/Android.bp b/libs/vr/libdisplay/Android.bp
index e3ab7fa..69dbc84 100644
--- a/libs/vr/libdisplay/Android.bp
+++ b/libs/vr/libdisplay/Android.bp
@@ -26,6 +26,7 @@
sharedLibraries = [
"libbase",
+ "libbinder",
"libcutils",
"liblog",
"libutils",
@@ -57,6 +58,8 @@
"-DATRACE_TAG=ATRACE_TAG_GRAPHICS",
"-DGL_GLEXT_PROTOTYPES",
"-DEGL_EGLEXT_PROTOTYPES",
+ "-Wall",
+ "-Werror",
], // + [ "-UNDEBUG", "-DDEBUG", "-O0", "-g" ],
export_include_dirs: localIncludeFiles,
shared_libs: sharedLibraries,
diff --git a/libs/vr/libdvr/Android.bp b/libs/vr/libdvr/Android.bp
index 9fe161d..04418d2 100644
--- a/libs/vr/libdvr/Android.bp
+++ b/libs/vr/libdvr/Android.bp
@@ -22,6 +22,8 @@
cflags = [
"-DLOG_TAG=\"libdvr\"",
"-DTRACE=0",
+ "-Wall",
+ "-Werror",
]
srcs = [
diff --git a/libs/vr/libdvrcommon/Android.bp b/libs/vr/libdvrcommon/Android.bp
index 62aeb79..c7d808b 100644
--- a/libs/vr/libdvrcommon/Android.bp
+++ b/libs/vr/libdvrcommon/Android.bp
@@ -40,6 +40,8 @@
cflags: [
"-DLOG_TAG=\"libdvrcommon\"",
"-DTRACE=0",
+ "-Wall",
+ "-Werror",
],
export_include_dirs: localIncludeFiles,
@@ -59,6 +61,11 @@
tags: ["optional"],
srcs: testFiles,
+ cflags: [
+ "-Wall",
+ "-Werror",
+ "-Wno-unused-parameter",
+ ],
shared_libs: sharedLibraries,
diff --git a/libs/vr/libpdx/private/pdx/channel_parcelable.h b/libs/vr/libpdx/private/pdx/channel_parcelable.h
new file mode 100644
index 0000000..59ef9d3
--- /dev/null
+++ b/libs/vr/libpdx/private/pdx/channel_parcelable.h
@@ -0,0 +1,31 @@
+#ifndef ANDROID_PDX_CHANNEL_PARCELABLE_H_
+#define ANDROID_PDX_CHANNEL_PARCELABLE_H_
+
+#include <binder/Parcelable.h>
+#include <pdx/channel_handle.h>
+
+namespace android {
+namespace pdx {
+
+/**
+ * A parcelable object holds all necessary objects to recreate a ClientChannel.
+ * In addition to the android::Parcelable interface, this interface exposees
+ * more PDX-related interface.
+ */
+class ChannelParcelable : public Parcelable {
+ public:
+ virtual ~ChannelParcelable() = default;
+
+ // Returns whether the parcelable object holds a valid client channel.
+ virtual bool IsValid() const = 0;
+
+ // Returns a channel handle constructed from this parcelable object and takes
+ // the ownership of all resources from the parcelable object. In another word,
+ // the parcelable object will become invalid after TakeChannelHandle returns.
+ virtual LocalChannelHandle TakeChannelHandle() = 0;
+};
+
+} // namespace pdx
+} // namespace android
+
+#endif // ANDROID_PDX_CHANNEL_PARCELABLE_H_
diff --git a/libs/vr/libpdx/private/pdx/client_channel.h b/libs/vr/libpdx/private/pdx/client_channel.h
index 10a49bb..8f5fdfe 100644
--- a/libs/vr/libpdx/private/pdx/client_channel.h
+++ b/libs/vr/libpdx/private/pdx/client_channel.h
@@ -4,6 +4,7 @@
#include <vector>
#include <pdx/channel_handle.h>
+#include <pdx/channel_parcelable.h>
#include <pdx/file_handle.h>
#include <pdx/status.h>
@@ -61,6 +62,11 @@
LocalHandle* handle) const = 0;
virtual bool GetChannelHandle(void* transaction_state, ChannelReference ref,
LocalChannelHandle* handle) const = 0;
+
+ // Returns the internal state of the channel as a parcelable object. The
+ // ClientChannel is invalidated however, the channel is kept alive by the
+ // parcelable object and may be transferred to another process.
+ virtual std::unique_ptr<ChannelParcelable> TakeChannelParcelable() = 0;
};
} // namespace pdx
diff --git a/libs/vr/libpdx/private/pdx/mock_client_channel.h b/libs/vr/libpdx/private/pdx/mock_client_channel.h
index 49e0682..ecc20b3 100644
--- a/libs/vr/libpdx/private/pdx/mock_client_channel.h
+++ b/libs/vr/libpdx/private/pdx/mock_client_channel.h
@@ -49,6 +49,7 @@
MOCK_CONST_METHOD3(GetChannelHandle,
bool(void* transaction_state, ChannelReference ref,
LocalChannelHandle* handle));
+ MOCK_METHOD0(TakeChannelParcelable, std::unique_ptr<ChannelParcelable>());
};
} // namespace pdx
diff --git a/libs/vr/libpdx_default_transport/Android.bp b/libs/vr/libpdx_default_transport/Android.bp
index f891c59..cda3c95 100644
--- a/libs/vr/libpdx_default_transport/Android.bp
+++ b/libs/vr/libpdx_default_transport/Android.bp
@@ -42,6 +42,7 @@
"pdx_tool.cpp",
],
shared_libs: [
+ "libbinder",
"libcutils",
"liblog",
],
@@ -59,6 +60,7 @@
],
shared_libs: [
"libbase",
+ "libbinder",
"libchrome",
"libcutils",
"liblog",
diff --git a/libs/vr/libpdx_default_transport/private/servicefs/pdx/default_transport/channel_parcelable.h b/libs/vr/libpdx_default_transport/private/servicefs/pdx/default_transport/channel_parcelable.h
new file mode 100644
index 0000000..a8623b2
--- /dev/null
+++ b/libs/vr/libpdx_default_transport/private/servicefs/pdx/default_transport/channel_parcelable.h
@@ -0,0 +1,17 @@
+#ifndef ANDROID_PDX_DEFAULT_TRANSPORT_SERVICEFS_CHANNEL_PARCELABLE_H_
+#define ANDROID_PDX_DEFAULT_TRANSPORT_SERVICEFS_CHANNEL_PARCELABLE_H_
+
+#include <servicefs/channel_parcelable.h>
+
+namespace android {
+namespace pdx {
+namespace default_transport {
+
+using ChannelParcelable = ::android::pdx::servicefs::ChannelParcelable;
+
+} // namespace default_transport
+} // namespace pdx
+} // namespace android
+
+
+#endif // ANDROID_PDX_DEFAULT_TRANSPORT_SERVICEFS_CHANNEL_PARCELABLE_H_
diff --git a/libs/vr/libpdx_default_transport/private/uds/pdx/default_transport/channel_parcelable.h b/libs/vr/libpdx_default_transport/private/uds/pdx/default_transport/channel_parcelable.h
new file mode 100644
index 0000000..bcd74e6
--- /dev/null
+++ b/libs/vr/libpdx_default_transport/private/uds/pdx/default_transport/channel_parcelable.h
@@ -0,0 +1,17 @@
+#ifndef ANDROID_PDX_DEFAULT_TRANSPORT_UDS_CHANNEL_PARCELABLE_H_
+#define ANDROID_PDX_DEFAULT_TRANSPORT_UDS_CHANNEL_PARCELABLE_H_
+
+#include <uds/channel_parcelable.h>
+
+namespace android {
+namespace pdx {
+namespace default_transport {
+
+using ChannelParcelable = ::android::pdx::uds::ChannelParcelable;
+
+} // namespace default_transport
+} // namespace pdx
+} // namespace android
+
+
+#endif // ANDROID_PDX_DEFAULT_TRANSPORT_UDS_CHANNEL_PARCELABLE_H_
diff --git a/libs/vr/libpdx_uds/Android.bp b/libs/vr/libpdx_uds/Android.bp
index d0b7cab..d640950 100644
--- a/libs/vr/libpdx_uds/Android.bp
+++ b/libs/vr/libpdx_uds/Android.bp
@@ -13,6 +13,7 @@
srcs: [
"channel_event_set.cpp",
"channel_manager.cpp",
+ "channel_parcelable.cpp",
"client_channel_factory.cpp",
"client_channel.cpp",
"ipc_helper.cpp",
@@ -23,6 +24,9 @@
"libbase",
"libpdx",
],
+ shared_libs: [
+ "libbinder",
+ ],
whole_static_libs: [
"libselinux",
],
@@ -52,5 +56,6 @@
"libcutils",
"liblog",
"libutils",
+ "libbinder",
],
}
diff --git a/libs/vr/libpdx_uds/channel_parcelable.cpp b/libs/vr/libpdx_uds/channel_parcelable.cpp
new file mode 100644
index 0000000..e7bce27
--- /dev/null
+++ b/libs/vr/libpdx_uds/channel_parcelable.cpp
@@ -0,0 +1,125 @@
+#include "uds/channel_parcelable.h"
+
+#include <binder/Parcel.h>
+#include <uds/channel_manager.h>
+
+namespace android {
+namespace pdx {
+namespace uds {
+
+namespace {
+
+static constexpr uint32_t kUdsMagicParcelHeader = 0x7564736d; // 'udsm'.
+
+} // namespace
+
+ChannelParcelable::ChannelParcelable(LocalHandle data_fd,
+ LocalHandle pollin_event_fd,
+ LocalHandle pollhup_event_fd)
+ : data_fd_{std::move(data_fd)},
+ pollin_event_fd_{std::move(pollin_event_fd)},
+ pollhup_event_fd_{std::move(pollhup_event_fd)} {}
+
+bool ChannelParcelable::IsValid() const {
+ return !!data_fd_ && !!pollin_event_fd_ && !!pollhup_event_fd_;
+}
+
+LocalChannelHandle ChannelParcelable::TakeChannelHandle() {
+ if (!IsValid()) {
+ ALOGE("ChannelParcelable::TakeChannelHandle: Invalid channel parcel.");
+ return {}; // Returns an empty channel handle.
+ }
+
+ return ChannelManager::Get().CreateHandle(std::move(data_fd_),
+ std::move(pollin_event_fd_),
+ std::move(pollhup_event_fd_));
+}
+
+status_t ChannelParcelable::writeToParcel(Parcel* parcel) const {
+ status_t res = NO_ERROR;
+
+ if (!IsValid()) {
+ ALOGE("ChannelParcelable::writeToParcel: Invalid channel parcel.");
+ return BAD_VALUE;
+ }
+
+ res = parcel->writeUint32(kUdsMagicParcelHeader);
+ if (res != NO_ERROR) {
+ ALOGE("ChannelParcelable::writeToParcel: Cannot write magic: res=%d.", res);
+ return res;
+ }
+
+ res = parcel->writeFileDescriptor(data_fd_.Get());
+ if (res != NO_ERROR) {
+ ALOGE("ChannelParcelable::writeToParcel: Cannot write data fd: res=%d.",
+ res);
+ return res;
+ }
+
+ res = parcel->writeFileDescriptor(pollin_event_fd_.Get());
+ if (res != NO_ERROR) {
+ ALOGE(
+ "ChannelParcelable::writeToParcel: Cannot write pollin event fd: "
+ "res=%d.",
+ res);
+ return res;
+ }
+
+ res = parcel->writeFileDescriptor(pollhup_event_fd_.Get());
+ if (res != NO_ERROR) {
+ ALOGE(
+ "ChannelParcelable::writeToParcel: Cannot write pollhup event fd: "
+ "res=%d.",
+ res);
+ return res;
+ }
+
+ return res;
+}
+
+status_t ChannelParcelable::readFromParcel(const Parcel* parcel) {
+ uint32_t magic = 0;
+ status_t res = NO_ERROR;
+
+ if (IsValid()) {
+ ALOGE(
+ "ChannelParcelable::readFromParcel: This channel parcel is already "
+ "initailzied.");
+ return ALREADY_EXISTS;
+ }
+
+ res = parcel->readUint32(&magic);
+ if (res != NO_ERROR) {
+ ALOGE("ChannelParcelable::readFromParcel: Failed to read magic: res=%d.",
+ res);
+ return res;
+ }
+
+ if (magic != kUdsMagicParcelHeader) {
+ ALOGE(
+ "ChannelParcelable::readFromParcel: Unknown magic: 0x%x, epxected: "
+ "0x%x",
+ magic, kUdsMagicParcelHeader);
+ return BAD_VALUE;
+ }
+
+ // TODO(b/69010509): We have to dup() the FD from android::Parcel as it
+ // doesn't support taking out the FD's ownership. We can remove the dup() here
+ // once android::Parcel support such operation.
+ data_fd_.Reset(dup(parcel->readFileDescriptor()));
+ pollin_event_fd_.Reset(dup(parcel->readFileDescriptor()));
+ pollhup_event_fd_.Reset(dup(parcel->readFileDescriptor()));
+ if (!IsValid()) {
+ ALOGE(
+ "ChannelParcelable::readFromParcel: Cannot read fd from parcel: "
+ "data_fd=%d, pollin_event_fd=%d, pollhup_event_fd=%d.",
+ data_fd_.Get(), pollin_event_fd_.Get(), pollhup_event_fd_.Get());
+ return DEAD_OBJECT;
+ }
+
+ return res;
+}
+
+} // namespace uds
+} // namespace pdx
+} // namespace android
diff --git a/libs/vr/libpdx_uds/client_channel.cpp b/libs/vr/libpdx_uds/client_channel.cpp
index 2e9c1de..6073c3c 100644
--- a/libs/vr/libpdx_uds/client_channel.cpp
+++ b/libs/vr/libpdx_uds/client_channel.cpp
@@ -1,3 +1,4 @@
+#include "uds/channel_parcelable.h"
#include "uds/client_channel.h"
#include <errno.h>
@@ -292,6 +293,29 @@
return state->GetLocalChannelHandle(ref, handle);
}
+std::unique_ptr<pdx::ChannelParcelable> ClientChannel::TakeChannelParcelable()
+ {
+ if (!channel_handle_)
+ return nullptr;
+
+ if (auto* channel_data =
+ ChannelManager::Get().GetChannelData(channel_handle_.value())) {
+ auto fds = channel_data->TakeFds();
+ auto parcelable = std::make_unique<ChannelParcelable>(
+ std::move(std::get<0>(fds)), std::move(std::get<1>(fds)),
+ std::move(std::get<2>(fds)));
+
+ // Here we need to explicitly close the channel handle so that the channel
+ // won't get shutdown in the destructor, while the FDs in ChannelParcelable
+ // can keep the channel alive so that new client can be created from it
+ // later.
+ channel_handle_.Close();
+ return parcelable;
+ } else {
+ return nullptr;
+ }
+}
+
} // namespace uds
} // namespace pdx
} // namespace android
diff --git a/libs/vr/libpdx_uds/private/uds/channel_parcelable.h b/libs/vr/libpdx_uds/private/uds/channel_parcelable.h
new file mode 100644
index 0000000..1c3fae9
--- /dev/null
+++ b/libs/vr/libpdx_uds/private/uds/channel_parcelable.h
@@ -0,0 +1,35 @@
+#ifndef ANDROID_PDX_UDS_CHANNEL_PARCELABLE_H_
+#define ANDROID_PDX_UDS_CHANNEL_PARCELABLE_H_
+
+#include <pdx/channel_parcelable.h>
+#include <pdx/file_handle.h>
+
+namespace android {
+namespace pdx {
+namespace uds {
+
+class ChannelParcelable : public pdx::ChannelParcelable {
+ public:
+ ChannelParcelable() = default;
+ ChannelParcelable(LocalHandle data_fd, LocalHandle pollin_event_fd,
+ LocalHandle pollhup_event_fd);
+
+ // Implements pdx::ChannelParcelable interface.
+ bool IsValid() const override;
+ LocalChannelHandle TakeChannelHandle() override;
+
+ // Implements android::Parcelable interface.
+ status_t writeToParcel(Parcel* parcel) const override;
+ status_t readFromParcel(const Parcel* parcel) override;
+
+ private:
+ LocalHandle data_fd_;
+ LocalHandle pollin_event_fd_;
+ LocalHandle pollhup_event_fd_;
+};
+
+} // namespace uds
+} // namespace pdx
+} // namespace android
+
+#endif // ANDROID_PDX_UDS_CHANNEL_PARCELABLE_H_
diff --git a/libs/vr/libpdx_uds/private/uds/client_channel.h b/libs/vr/libpdx_uds/private/uds/client_channel.h
index 7a5ddf4..b5524d8 100644
--- a/libs/vr/libpdx_uds/private/uds/client_channel.h
+++ b/libs/vr/libpdx_uds/private/uds/client_channel.h
@@ -74,6 +74,8 @@
bool GetChannelHandle(void* transaction_state, ChannelReference ref,
LocalChannelHandle* handle) const override;
+ std::unique_ptr<pdx::ChannelParcelable> TakeChannelParcelable() override;
+
private:
explicit ClientChannel(LocalChannelHandle channel_handle);
diff --git a/libs/vr/libperformance/Android.bp b/libs/vr/libperformance/Android.bp
index 364873d..7c32dbb 100644
--- a/libs/vr/libperformance/Android.bp
+++ b/libs/vr/libperformance/Android.bp
@@ -23,6 +23,7 @@
sharedLibraries = [
"libbase",
+ "libbinder",
"libcutils",
"liblog",
"libutils",
@@ -32,7 +33,9 @@
srcs: sourceFiles,
cflags: [
"-DLOG_TAG=\"libperformance\"",
- "-DTRACE=0"
+ "-DTRACE=0",
+ "-Wall",
+ "-Werror",
],
export_include_dirs: includeFiles,
static_libs: staticLibraries,
diff --git a/libs/vr/libvrflinger/Android.bp b/libs/vr/libvrflinger/Android.bp
index 0fb2d84..4d80e91 100644
--- a/libs/vr/libvrflinger/Android.bp
+++ b/libs/vr/libvrflinger/Android.bp
@@ -77,6 +77,10 @@
"-DATRACE_TAG=ATRACE_TAG_GRAPHICS",
"-DGL_GLEXT_PROTOTYPES",
"-DEGL_EGLEXT_PROTOTYPES",
+ "-Wall",
+ "-Werror",
+ "-Wno-error=sign-compare", // to fix later
+ "-Wno-unused-variable",
],
shared_libs: sharedLibraries,
whole_static_libs: staticLibraries,
diff --git a/libs/vr/libvrsensor/Android.bp b/libs/vr/libvrsensor/Android.bp
index d022adf..ec36088 100644
--- a/libs/vr/libvrsensor/Android.bp
+++ b/libs/vr/libvrsensor/Android.bp
@@ -33,6 +33,7 @@
sharedLibraries = [
"libbase",
+ "libbinder",
"libcutils",
"libhardware",
"liblog",
@@ -42,6 +43,11 @@
cc_library {
srcs: sourceFiles,
+ cflags: [
+ "-Wall",
+ "-Werror",
+ "-Wno-macro-redefined",
+ ],
export_include_dirs: includeFiles,
static_libs: staticLibraries,
shared_libs: sharedLibraries,
diff --git a/libs/vr/libvrsensor/include/dvr/pose_client.h b/libs/vr/libvrsensor/include/dvr/pose_client.h
index bb25f1d..b663a67 100644
--- a/libs/vr/libvrsensor/include/dvr/pose_client.h
+++ b/libs/vr/libvrsensor/include/dvr/pose_client.h
@@ -7,7 +7,7 @@
#ifndef __FLOAT32X4T_86
#define __FLOAT32X4T_86
typedef float float32x4_t __attribute__ ((__vector_size__ (16)));
-typedef struct float32x4x4_t { float32x4_t val[4]; };
+typedef struct float32x4x4_t { float32x4_t val[4]; } float32x4x4_t;
#endif
#endif
diff --git a/opengl/tools/glgen/stubs/egl/EGL14cHeader.cpp b/opengl/tools/glgen/stubs/egl/EGL14cHeader.cpp
index 66836b5..f90e3ec 100644
--- a/opengl/tools/glgen/stubs/egl/EGL14cHeader.cpp
+++ b/opengl/tools/glgen/stubs/egl/EGL14cHeader.cpp
@@ -17,7 +17,6 @@
// This source file is automatically generated
#pragma GCC diagnostic ignored "-Wunused-variable"
-#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#pragma GCC diagnostic ignored "-Wunused-function"
#include "jni.h"
diff --git a/opengl/tools/glgen/stubs/egl/EGLExtcHeader.cpp b/opengl/tools/glgen/stubs/egl/EGLExtcHeader.cpp
index fb75d81..12b96f4 100644
--- a/opengl/tools/glgen/stubs/egl/EGLExtcHeader.cpp
+++ b/opengl/tools/glgen/stubs/egl/EGLExtcHeader.cpp
@@ -17,7 +17,6 @@
// This source file is automatically generated
#pragma GCC diagnostic ignored "-Wunused-variable"
-#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#pragma GCC diagnostic ignored "-Wunused-function"
#include "jni.h"
diff --git a/opengl/tools/glgen/stubs/gles11/GLES10ExtcHeader.cpp b/opengl/tools/glgen/stubs/gles11/GLES10ExtcHeader.cpp
index 1fa9275..dd17ca4 100644
--- a/opengl/tools/glgen/stubs/gles11/GLES10ExtcHeader.cpp
+++ b/opengl/tools/glgen/stubs/gles11/GLES10ExtcHeader.cpp
@@ -18,7 +18,6 @@
// This source file is automatically generated
#pragma GCC diagnostic ignored "-Wunused-variable"
-#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#pragma GCC diagnostic ignored "-Wunused-function"
#include <GLES/gl.h>
diff --git a/opengl/tools/glgen/stubs/gles11/GLES10cHeader.cpp b/opengl/tools/glgen/stubs/gles11/GLES10cHeader.cpp
index 1fa9275..dd17ca4 100644
--- a/opengl/tools/glgen/stubs/gles11/GLES10cHeader.cpp
+++ b/opengl/tools/glgen/stubs/gles11/GLES10cHeader.cpp
@@ -18,7 +18,6 @@
// This source file is automatically generated
#pragma GCC diagnostic ignored "-Wunused-variable"
-#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#pragma GCC diagnostic ignored "-Wunused-function"
#include <GLES/gl.h>
diff --git a/opengl/tools/glgen/stubs/gles11/GLES11ExtcHeader.cpp b/opengl/tools/glgen/stubs/gles11/GLES11ExtcHeader.cpp
index 1fa9275..dd17ca4 100644
--- a/opengl/tools/glgen/stubs/gles11/GLES11ExtcHeader.cpp
+++ b/opengl/tools/glgen/stubs/gles11/GLES11ExtcHeader.cpp
@@ -18,7 +18,6 @@
// This source file is automatically generated
#pragma GCC diagnostic ignored "-Wunused-variable"
-#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#pragma GCC diagnostic ignored "-Wunused-function"
#include <GLES/gl.h>
diff --git a/opengl/tools/glgen/stubs/gles11/GLES11cHeader.cpp b/opengl/tools/glgen/stubs/gles11/GLES11cHeader.cpp
index 1fa9275..dd17ca4 100644
--- a/opengl/tools/glgen/stubs/gles11/GLES11cHeader.cpp
+++ b/opengl/tools/glgen/stubs/gles11/GLES11cHeader.cpp
@@ -18,7 +18,6 @@
// This source file is automatically generated
#pragma GCC diagnostic ignored "-Wunused-variable"
-#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#pragma GCC diagnostic ignored "-Wunused-function"
#include <GLES/gl.h>
diff --git a/opengl/tools/glgen/stubs/gles11/GLES20cHeader.cpp b/opengl/tools/glgen/stubs/gles11/GLES20cHeader.cpp
index 4004a7d..b2bbdf6 100644
--- a/opengl/tools/glgen/stubs/gles11/GLES20cHeader.cpp
+++ b/opengl/tools/glgen/stubs/gles11/GLES20cHeader.cpp
@@ -18,7 +18,6 @@
// This source file is automatically generated
#pragma GCC diagnostic ignored "-Wunused-variable"
-#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#pragma GCC diagnostic ignored "-Wunused-function"
#include <GLES2/gl2.h>
diff --git a/opengl/tools/glgen/stubs/gles11/GLES30cHeader.cpp b/opengl/tools/glgen/stubs/gles11/GLES30cHeader.cpp
index c5bdf32..b039bc9 100644
--- a/opengl/tools/glgen/stubs/gles11/GLES30cHeader.cpp
+++ b/opengl/tools/glgen/stubs/gles11/GLES30cHeader.cpp
@@ -18,7 +18,6 @@
// This source file is automatically generated
#pragma GCC diagnostic ignored "-Wunused-variable"
-#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#pragma GCC diagnostic ignored "-Wunused-function"
#include <GLES3/gl3.h>
diff --git a/opengl/tools/glgen/stubs/gles11/GLES31ExtcHeader.cpp b/opengl/tools/glgen/stubs/gles11/GLES31ExtcHeader.cpp
index 2260a80..dd00e92 100644
--- a/opengl/tools/glgen/stubs/gles11/GLES31ExtcHeader.cpp
+++ b/opengl/tools/glgen/stubs/gles11/GLES31ExtcHeader.cpp
@@ -17,7 +17,6 @@
// This source file is automatically generated
#pragma GCC diagnostic ignored "-Wunused-variable"
-#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#pragma GCC diagnostic ignored "-Wunused-function"
#include <GLES3/gl31.h>
diff --git a/opengl/tools/glgen/stubs/gles11/GLES31cHeader.cpp b/opengl/tools/glgen/stubs/gles11/GLES31cHeader.cpp
index 130612d..88e00be 100644
--- a/opengl/tools/glgen/stubs/gles11/GLES31cHeader.cpp
+++ b/opengl/tools/glgen/stubs/gles11/GLES31cHeader.cpp
@@ -17,7 +17,6 @@
// This source file is automatically generated
#pragma GCC diagnostic ignored "-Wunused-variable"
-#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#pragma GCC diagnostic ignored "-Wunused-function"
#include <stdint.h>
diff --git a/opengl/tools/glgen/stubs/gles11/GLES32cHeader.cpp b/opengl/tools/glgen/stubs/gles11/GLES32cHeader.cpp
index e9c5fc7..3e7ec8b 100644
--- a/opengl/tools/glgen/stubs/gles11/GLES32cHeader.cpp
+++ b/opengl/tools/glgen/stubs/gles11/GLES32cHeader.cpp
@@ -17,8 +17,7 @@
// This source file is automatically generated
#pragma GCC diagnostic ignored "-Wunused-variable"
-#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#pragma GCC diagnostic ignored "-Wunused-function"
#include <stdint.h>
-#include <GLES3/gl32.h>
\ No newline at end of file
+#include <GLES3/gl32.h>
diff --git a/opengl/tools/glgen/stubs/jsr239/GLCHeader.cpp b/opengl/tools/glgen/stubs/jsr239/GLCHeader.cpp
index 03e16e9..29296ff 100644
--- a/opengl/tools/glgen/stubs/jsr239/GLCHeader.cpp
+++ b/opengl/tools/glgen/stubs/jsr239/GLCHeader.cpp
@@ -17,7 +17,6 @@
// This source file is automatically generated
#pragma GCC diagnostic ignored "-Wunused-variable"
-#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#pragma GCC diagnostic ignored "-Wunused-function"
#include "jni.h"
diff --git a/services/inputflinger/InputDispatcher.cpp b/services/inputflinger/InputDispatcher.cpp
index 906794a..8ab30e8 100644
--- a/services/inputflinger/InputDispatcher.cpp
+++ b/services/inputflinger/InputDispatcher.cpp
@@ -2903,7 +2903,7 @@
for (size_t d = 0; d < mTouchStatesByDisplay.size(); d++) {
TouchState& state = mTouchStatesByDisplay.editValueAt(d);
- for (size_t i = 0; i < state.windows.size(); i++) {
+ for (size_t i = 0; i < state.windows.size(); ) {
TouchedWindow& touchedWindow = state.windows.editItemAt(i);
if (!hasWindowHandleLocked(touchedWindow.windowHandle)) {
#if DEBUG_FOCUS
@@ -2918,7 +2918,9 @@
synthesizeCancelationEventsForInputChannelLocked(
touchedInputChannel, options);
}
- state.windows.removeAt(i--);
+ state.windows.removeAt(i);
+ } else {
+ ++i;
}
}
}
diff --git a/services/inputflinger/InputReader.cpp b/services/inputflinger/InputReader.cpp
index 4304982..591f8d7 100644
--- a/services/inputflinger/InputReader.cpp
+++ b/services/inputflinger/InputReader.cpp
@@ -1174,7 +1174,7 @@
// gamepad button presses are handled by different mappers but they should be dispatched
// in the order received.
size_t numMappers = mMappers.size();
- for (const RawEvent* rawEvent = rawEvents; count--; rawEvent++) {
+ for (const RawEvent* rawEvent = rawEvents; count != 0; rawEvent++) {
#if DEBUG_RAW_EVENTS
ALOGD("Input event: device=%d type=0x%04x code=0x%04x value=0x%08x when=%" PRId64,
rawEvent->deviceId, rawEvent->type, rawEvent->code, rawEvent->value,
@@ -1202,6 +1202,7 @@
mapper->process(rawEvent);
}
}
+ --count;
}
}
diff --git a/services/vr/bufferhubd/Android.mk b/services/vr/bufferhubd/Android.mk
index 28cf53d..e1997d7 100644
--- a/services/vr/bufferhubd/Android.mk
+++ b/services/vr/bufferhubd/Android.mk
@@ -32,6 +32,7 @@
sharedLibraries := \
libbase \
+ libbinder \
libcutils \
liblog \
libsync \
diff --git a/services/vr/hardware_composer/Android.bp b/services/vr/hardware_composer/Android.bp
index e92b8d8..76ec42d 100644
--- a/services/vr/hardware_composer/Android.bp
+++ b/services/vr/hardware_composer/Android.bp
@@ -20,6 +20,7 @@
"android.hardware.graphics.composer@2.1",
"android.hardware.graphics.mapper@2.0",
"libbase",
+ "libbinder",
"libcutils",
"libfmq",
"libhardware",