Merge "Let gr_init proceed even if we failed to load a font file"
diff --git a/Android.mk b/Android.mk
index 6aa91ea..24da8b2 100644
--- a/Android.mk
+++ b/Android.mk
@@ -132,6 +132,7 @@
LOCAL_SRC_FILES := \
adb_install.cpp \
+ fsck_unshare_blocks.cpp \
fuse_sdcard_provider.cpp \
install.cpp \
recovery.cpp \
@@ -192,6 +193,13 @@
endif
endif
+# e2fsck is needed for adb remount -R.
+ifeq ($(BOARD_EXT4_SHARE_DUP_BLOCKS),true)
+ifneq (,$(filter userdebug eng,$(TARGET_BUILD_VARIANT)))
+LOCAL_REQUIRED_MODULES += e2fsck_static
+endif
+endif
+
ifeq ($(BOARD_CACHEIMAGE_PARTITION_SIZE),)
LOCAL_REQUIRED_MODULES += \
recovery-persist \
diff --git a/fsck_unshare_blocks.cpp b/fsck_unshare_blocks.cpp
new file mode 100644
index 0000000..a100368
--- /dev/null
+++ b/fsck_unshare_blocks.cpp
@@ -0,0 +1,163 @@
+/*
+ * Copyright (C) 2018 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 "fsck_unshare_blocks.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <spawn.h>
+#include <string.h>
+#include <sys/mount.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <android-base/logging.h>
+#include <android-base/properties.h>
+#include <android-base/unique_fd.h>
+#include <fstab/fstab.h>
+
+#include "roots.h"
+
+static constexpr const char* SYSTEM_E2FSCK_BIN = "/system/bin/e2fsck_static";
+static constexpr const char* TMP_E2FSCK_BIN = "/tmp/e2fsck.bin";
+
+static bool copy_file(const char* source, const char* dest) {
+ android::base::unique_fd source_fd(open(source, O_RDONLY));
+ if (source_fd < 0) {
+ PLOG(ERROR) << "open %s failed" << source;
+ return false;
+ }
+
+ android::base::unique_fd dest_fd(open(dest, O_CREAT | O_WRONLY, S_IRWXU));
+ if (dest_fd < 0) {
+ PLOG(ERROR) << "open %s failed" << dest;
+ return false;
+ }
+
+ for (;;) {
+ char buf[4096];
+ ssize_t rv = read(source_fd, buf, sizeof(buf));
+ if (rv < 0) {
+ PLOG(ERROR) << "read failed";
+ return false;
+ }
+ if (rv == 0) {
+ break;
+ }
+ if (write(dest_fd, buf, rv) != rv) {
+ PLOG(ERROR) << "write failed";
+ return false;
+ }
+ }
+ return true;
+}
+
+static bool run_e2fsck(const std::string& partition) {
+ Volume* volume = volume_for_mount_point(partition);
+ if (!volume) {
+ LOG(INFO) << "No fstab entry for " << partition << ", skipping.";
+ return true;
+ }
+
+ LOG(INFO) << "Running e2fsck on device " << volume->blk_device;
+
+ std::vector<std::string> args = { TMP_E2FSCK_BIN, "-p", "-E", "unshare_blocks",
+ volume->blk_device };
+ std::vector<char*> argv(args.size());
+ std::transform(args.cbegin(), args.cend(), argv.begin(),
+ [](const std::string& arg) { return const_cast<char*>(arg.c_str()); });
+ argv.push_back(nullptr);
+
+ pid_t child;
+ char* env[] = { nullptr };
+ if (posix_spawn(&child, argv[0], nullptr, nullptr, argv.data(), env)) {
+ PLOG(ERROR) << "posix_spawn failed";
+ return false;
+ }
+
+ int status = 0;
+ int ret = TEMP_FAILURE_RETRY(waitpid(child, &status, 0));
+ if (ret < 0) {
+ PLOG(ERROR) << "waitpid failed";
+ return false;
+ }
+ if (!WIFEXITED(status)) {
+ LOG(ERROR) << "e2fsck exited abnormally: " << status;
+ return false;
+ }
+ int return_code = WEXITSTATUS(status);
+ if (return_code >= 8) {
+ LOG(ERROR) << "e2fsck could not unshare blocks: " << return_code;
+ return false;
+ }
+
+ LOG(INFO) << "Successfully unshared blocks on " << partition;
+ return true;
+}
+
+static const char* get_system_root() {
+ if (android::base::GetBoolProperty("ro.build.system_root_image", false)) {
+ return "/system_root";
+ } else {
+ return "/system";
+ }
+}
+
+bool do_fsck_unshare_blocks() {
+ // List of partitions we will try to e2fsck -E unshare_blocks.
+ std::vector<std::string> partitions = { "/odm", "/oem", "/product", "/vendor" };
+
+ // Temporarily mount system so we can copy e2fsck_static.
+ bool mounted = false;
+ if (android::base::GetBoolProperty("ro.build.system_root_image", false)) {
+ mounted = ensure_path_mounted_at("/", "/system_root") != -1;
+ partitions.push_back("/");
+ } else {
+ mounted = ensure_path_mounted("/system") != -1;
+ partitions.push_back("/system");
+ }
+ if (!mounted) {
+ LOG(ERROR) << "Failed to mount system image.";
+ return false;
+ }
+ if (!copy_file(SYSTEM_E2FSCK_BIN, TMP_E2FSCK_BIN)) {
+ LOG(ERROR) << "Could not copy e2fsck to /tmp.";
+ return false;
+ }
+ if (umount(get_system_root()) < 0) {
+ PLOG(ERROR) << "umount failed";
+ return false;
+ }
+
+ bool ok = true;
+ for (const auto& partition : partitions) {
+ ok &= run_e2fsck(partition);
+ }
+
+ if (ok) {
+ LOG(INFO) << "Finished running e2fsck.";
+ } else {
+ LOG(ERROR) << "Finished running e2fsck, but not all partitions succceeded.";
+ }
+ return ok;
+}
diff --git a/fsck_unshare_blocks.h b/fsck_unshare_blocks.h
new file mode 100644
index 0000000..9de8ef9
--- /dev/null
+++ b/fsck_unshare_blocks.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _FILESYSTEM_CMDS_H
+#define _FILESYSTEM_CMDS_H
+
+bool do_fsck_unshare_blocks();
+
+#endif // _FILESYSTEM_CMDS_H
diff --git a/recovery.cpp b/recovery.cpp
index 56b2567..98cbfed 100644
--- a/recovery.cpp
+++ b/recovery.cpp
@@ -55,6 +55,7 @@
#include "adb_install.h"
#include "common.h"
#include "device.h"
+#include "fsck_unshare_blocks.h"
#include "fuse_sdcard_provider.h"
#include "fuse_sideload.h"
#include "install.h"
@@ -969,6 +970,7 @@
[](const std::string& arg) { return const_cast<char*>(arg.c_str()); });
static constexpr struct option OPTIONS[] = {
+ { "fsck_unshare_blocks", no_argument, nullptr, 0 },
{ "just_exit", no_argument, nullptr, 'x' },
{ "locale", required_argument, nullptr, 0 },
{ "prompt_and_wipe_data", no_argument, nullptr, 0 },
@@ -997,6 +999,7 @@
bool sideload_auto_reboot = false;
bool just_exit = false;
bool shutdown_after = false;
+ bool fsck_unshare_blocks = false;
int retry_count = 0;
bool security_update = false;
std::string locale;
@@ -1014,7 +1017,9 @@
break;
case 0: {
std::string option = OPTIONS[option_index].name;
- if (option == "locale") {
+ if (option == "fsck_unshare_blocks") {
+ fsck_unshare_blocks = true;
+ } else if (option == "locale") {
// Handled in recovery_main.cpp
} else if (option == "prompt_and_wipe_data") {
should_prompt_and_wipe_data = true;
@@ -1181,6 +1186,10 @@
if (sideload_auto_reboot) {
ui->Print("Rebooting automatically.\n");
}
+ } else if (fsck_unshare_blocks) {
+ if (!do_fsck_unshare_blocks()) {
+ status = INSTALL_ERROR;
+ }
} else if (!just_exit) {
// If this is an eng or userdebug build, automatically turn on the text display if no command
// is specified. Note that this should be called before setting the background to avoid
diff --git a/updater_sample/Android.mk b/updater_sample/Android.mk
index 056ad66..7662111 100644
--- a/updater_sample/Android.mk
+++ b/updater_sample/Android.mk
@@ -18,8 +18,8 @@
include $(CLEAR_VARS)
LOCAL_PACKAGE_NAME := SystemUpdaterSample
-LOCAL_SDK_VERSION := system_current
LOCAL_MODULE_TAGS := samples
+LOCAL_SDK_VERSION := system_current
# TODO: enable proguard and use proguard.flags file
LOCAL_PROGUARD_ENABLED := disabled
diff --git a/updater_sample/README.md b/updater_sample/README.md
index 3f211dd..f6c63a7 100644
--- a/updater_sample/README.md
+++ b/updater_sample/README.md
@@ -65,6 +65,32 @@
6. Push OTA packages to the device.
+## Sample App State vs UpdateEngine Status
+
+UpdateEngine provides status for different stages of update application
+process. But it lacks of proper status codes when update fails.
+
+This creates two problems:
+
+1. If sample app is unbound from update_engine (MainActivity is paused, destroyed),
+ app doesn't receive onStatusUpdate and onPayloadApplicationCompleted notifications.
+ If app binds to update_engine after update is completed,
+ only onStatusUpdate is called, but status becomes IDLE in most cases.
+ And there is no way to know if update was successful or not.
+
+2. This sample app demostrates suspend/resume using update_engins's
+ `cancel` and `applyPayload` (which picks up from where it left).
+ When `cancel` is called, status is set to `IDLE`, which doesn't allow
+ tracking suspended state properly.
+
+To solve these problems sample app implements its own separate update
+state - `UpdaterState`. To solve the first problem, sample app persists
+`UpdaterState` on a device. When app is resumed, it checks if `UpdaterState`
+matches the update_engine's status (as onStatusUpdate is guaranteed to be called).
+If they doesn't match, sample app calls `applyPayload` again with the same
+parameters, and handles update completion properly using `onPayloadApplicationCompleted`
+callback. The second problem is solved by adding `PAUSED` updater state.
+
## Sending HTTP headers from UpdateEngine
Sometimes OTA package server might require some HTTP headers to be present,
@@ -76,6 +102,44 @@
which HTTP headers are supported.
+## Used update_engine APIs
+
+### UpdateEngine#bind
+
+Binds given callbacks to update_engine. When update_engine successfully
+initialized, it's guaranteed to invoke callback onStatusUpdate.
+
+### UpdateEngine#applyPayload
+
+Start an update attempt to download an apply the provided `payload_url` if
+no other update is running. The extra `key_value_pair_headers` will be
+included when fetching the payload.
+
+### UpdateEngine#cancel
+
+Cancel the ongoing update. The update could be running or suspended, but it
+can't be canceled after it was done.
+
+### UpdateEngine#resetStatus
+
+Reset the already applied update back to an idle state. This method can
+only be called when no update attempt is going on, and it will reset the
+status back to idle, deleting the currently applied update if any.
+
+### Callback: onStatusUpdate
+
+Called whenever the value of `status` or `progress` changes. For
+`progress` values changes, this method will be called only if it changes significantly.
+At this time of writing this doc, delta for `progress` is `0.005`.
+
+`onStatusUpdate` is always called when app binds to update_engine,
+except when update_engine fails to initialize.
+
+### Callback: onPayloadApplicationComplete
+
+Called whenever an update attempt is completed.
+
+
## Development
- [x] Create a UI with list of configs, current version,
@@ -90,6 +154,10 @@
- [x] Add demo for passing HTTP headers to `UpdateEngine#applyPayload`
- [x] [Package compatibility check](https://source.android.com/devices/architecture/vintf/match-rules)
- [x] Deferred switch slot demo
+- [x] Add UpdateManager; extract update logic from MainActivity
+- [x] Add Sample app update state (separate from update_engine status)
+- [-] Add smart update completion detection using onStatusUpdate
+- [ ] Add pause/resume demo
- [ ] Add demo for passing NETWORK_ID to `UpdateEngine#applyPayload`
- [ ] Verify system partition checksum for package
- [?] Add non-A/B updates demo
diff --git a/updater_sample/src/com/example/android/systemupdatersample/UpdateManager.java b/updater_sample/src/com/example/android/systemupdatersample/UpdateManager.java
index c4c8c9c..145cc83 100644
--- a/updater_sample/src/com/example/android/systemupdatersample/UpdateManager.java
+++ b/updater_sample/src/com/example/android/systemupdatersample/UpdateManager.java
@@ -39,6 +39,8 @@
import java.util.function.DoubleConsumer;
import java.util.function.IntConsumer;
+import javax.annotation.concurrent.GuardedBy;
+
/**
* Manages the update flow. It has its own state (in memory), separate from
* {@link UpdateEngine}'s state. Asynchronously interacts with the {@link UpdateEngine}.
@@ -62,11 +64,16 @@
private AtomicBoolean mManualSwitchSlotRequired = new AtomicBoolean(true);
+ @GuardedBy("mLock")
private UpdateData mLastUpdateData = null;
+ @GuardedBy("mLock")
private IntConsumer mOnStateChangeCallback = null;
+ @GuardedBy("mLock")
private IntConsumer mOnEngineStatusUpdateCallback = null;
+ @GuardedBy("mLock")
private DoubleConsumer mOnProgressUpdateCallback = null;
+ @GuardedBy("mLock")
private IntConsumer mOnEngineCompleteCallback = null;
private final Object mLock = new Object();
@@ -384,11 +391,85 @@
updateEngineApplyPayload(builder.build());
}
+ /**
+ * Verifies if mUpdaterState matches mUpdateEngineStatus.
+ * If they don't match, runs applyPayload to trigger onPayloadApplicationComplete
+ * callback, which updates mUpdaterState.
+ */
+ private void ensureCorrectUpdaterState() {
+ // When mUpdaterState is one of IDLE, PAUSED, ERROR, SLOT_SWITCH_REQUIRED
+ // then mUpdateEngineStatus must be IDLE.
+ // When mUpdaterState is RUNNING,
+ // then mUpdateEngineStatus must not be IDLE or UPDATED_NEED_REBOOT.
+ // When mUpdaterState is REBOOT_REQUIRED,
+ // then mUpdateEngineStatus must be UPDATED_NEED_REBOOT.
+ int state = mUpdaterState.get();
+ int updateEngineStatus = mUpdateEngineStatus.get();
+ if (state == UpdaterState.IDLE
+ || state == UpdaterState.ERROR
+ || state == UpdaterState.PAUSED
+ || state == UpdaterState.SLOT_SWITCH_REQUIRED) {
+ ensureUpdateEngineStatusIdle(state, updateEngineStatus);
+ } else if (state == UpdaterState.RUNNING) {
+ ensureUpdateEngineStatusRunning(state, updateEngineStatus);
+ } else if (state == UpdaterState.REBOOT_REQUIRED) {
+ ensureUpdateEngineStatusReboot(state, updateEngineStatus);
+ }
+ }
+
+ private void ensureUpdateEngineStatusIdle(int state, int updateEngineStatus) {
+ if (updateEngineStatus == UpdateEngine.UpdateStatusConstants.IDLE) {
+ return;
+ }
+ // It might happen when update is started not from the sample app.
+ // To make the sample app simple, we won't handle this case.
+ throw new RuntimeException("When mUpdaterState is " + state
+ + " mUpdateEngineStatus expected to be "
+ + UpdateEngine.UpdateStatusConstants.IDLE
+ + ", but it is " + updateEngineStatus);
+ }
+
+ private void ensureUpdateEngineStatusRunning(int state, int updateEngineStatus) {
+ if (updateEngineStatus != UpdateEngine.UpdateStatusConstants.UPDATED_NEED_REBOOT
+ && updateEngineStatus != UpdateEngine.UpdateStatusConstants.IDLE) {
+ return;
+ }
+ // Re-apply latest update. It makes update_engine to invoke
+ // onPayloadApplicationComplete callback. The callback notifies
+ // if update was successful or not.
+ updateEngineReApplyPayload();
+ }
+
+ private void ensureUpdateEngineStatusReboot(int state, int updateEngineStatus) {
+ if (updateEngineStatus == UpdateEngine.UpdateStatusConstants.UPDATED_NEED_REBOOT) {
+ return;
+ }
+ // This might happen when update is installed by other means,
+ // and sample app is not aware of it. To make the sample app simple,
+ // we won't handle this case.
+ throw new RuntimeException("When mUpdaterState is " + state
+ + " mUpdateEngineStatus expected to be "
+ + UpdateEngine.UpdateStatusConstants.UPDATED_NEED_REBOOT
+ + ", but it is " + updateEngineStatus);
+ }
+
+ /**
+ * Invoked by update_engine whenever update status or progress changes.
+ * It's also guaranteed to be invoked when app binds to the update_engine, except
+ * when update_engine fails to initialize (as defined in
+ * system/update_engine/binder_service_android.cc in
+ * function BinderUpdateEngineAndroidService::bind).
+ *
+ * @param status one of {@link UpdateEngine.UpdateStatusConstants}.
+ * @param progress a number from 0.0 to 1.0.
+ */
private void onStatusUpdate(int status, float progress) {
int previousStatus = mUpdateEngineStatus.get();
mUpdateEngineStatus.set(status);
mProgress.set(progress);
+ ensureCorrectUpdaterState();
+
getOnProgressUpdateCallback().ifPresent(callback -> callback.accept(progress));
if (previousStatus != status) {
@@ -413,7 +494,7 @@
}
/**
- * Helper class to delegate {@code update_engine} callbacks to UpdateManager
+ * Helper class to delegate {@code update_engine} callback invocations to UpdateManager.
*/
class UpdateEngineCallbackImpl extends UpdateEngineCallback {
@Override
diff --git a/updater_sample/src/com/example/android/systemupdatersample/ui/MainActivity.java b/updater_sample/src/com/example/android/systemupdatersample/ui/MainActivity.java
index 0b571cc..1de72c2 100644
--- a/updater_sample/src/com/example/android/systemupdatersample/ui/MainActivity.java
+++ b/updater_sample/src/com/example/android/systemupdatersample/ui/MainActivity.java
@@ -108,12 +108,16 @@
@Override
protected void onResume() {
super.onResume();
+ // TODO(zhomart) load saved states
+ // Binding to UpdateEngine invokes onStatusUpdate callback,
+ // persisted updater state has to be loaded and prepared beforehand.
this.mUpdateManager.bind();
}
@Override
protected void onPause() {
this.mUpdateManager.unbind();
+ // TODO(zhomart) save state
super.onPause();
}