AU: block exit / reset update progress for non-idempotent ops as late as possible.

delta_performer.cc

 // Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "update_engine/delta_performer.h"
 
 #include <endian.h>
 #include <errno.h>
 
 #include <algorithm>
@@ skipping 204 matching lines @@
   ssize_t total_operations = manifest_.install_operations_size() +
       manifest_.kernel_install_operations_size();
   while (next_operation_num_ < total_operations) {
     const DeltaArchiveManifest_InstallOperation &op =
         next_operation_num_ < manifest_.install_operations_size() ?
         manifest_.install_operations(next_operation_num_) :
         manifest_.kernel_install_operations(
             next_operation_num_ - manifest_.install_operations_size());
     if (!CanPerformInstallOperation(op))
       break;
+    // Makes sure we unblock exit when this operation completes.
     ScopedTerminatorExitUnblocker exit_unblocker =
         ScopedTerminatorExitUnblocker();  // Avoids a compiler unused var bug.
     // Log every thousandth operation, and also the first and last ones
     if ((next_operation_num_ % 1000 == 0) ||
         (next_operation_num_ + 1 == total_operations)) {
       LOG(INFO) << "Performing operation " << (next_operation_num_ + 1) << "/"
                 << total_operations;
     }
     bool is_kernel_partition =
         (next_operation_num_ >= manifest_.install_operations_size());
-    // If about to start a non-idempotent operation, clear the update state so
-    // that if the operation gets interrupted, we don't try to resume the
-    // update.
-    if (!IsIdempotentOperation(op)) {
-      Terminator::set_exit_blocked(true);
-      ResetUpdateProgress(prefs_, true);
-    }
     if (op.type() == DeltaArchiveManifest_InstallOperation_Type_REPLACE ||
         op.type() == DeltaArchiveManifest_InstallOperation_Type_REPLACE_BZ) {
       if (!PerformReplaceOperation(op, is_kernel_partition)) {
         LOG(ERROR) << "Failed to perform replace operation "
                    << next_operation_num_;
         return -EINVAL;
       }
     } else if (op.type() == DeltaArchiveManifest_InstallOperation_Type_MOVE) {
       if (!PerformMoveOperation(op, is_kernel_partition)) {
         LOG(ERROR) << "Failed to perform move operation "
@@ skipping 112 matching lines @@
                                           &buf[bytes_read],
                                           extent.num_blocks() * block_size_,
                                           extent.start_block() * block_size_,
                                           &bytes_read_this_iteration));
     TEST_AND_RETURN_FALSE(
         bytes_read_this_iteration ==
         static_cast<ssize_t>(extent.num_blocks() * block_size_));
     bytes_read += bytes_read_this_iteration;
   }
 
+  // If this is a non-idempotent operation, request a delayed exit and clear the
+  // update state in case the operation gets interrupted. Do this as late as
+  // possible.
+  if (!IsIdempotentOperation(operation)) {
+    Terminator::set_exit_blocked(true);
+    ResetUpdateProgress(prefs_, true);
+  }
+
   // Write bytes out.
   ssize_t bytes_written = 0;
   for (int i = 0; i < operation.dst_extents_size(); i++) {
     const Extent& extent = operation.dst_extents(i);
     TEST_AND_RETURN_FALSE(utils::PWriteAll(fd,
                                            &buf[bytes_written],
                                            extent.num_blocks() * block_size_,
                                            extent.start_block() * block_size_));
     bytes_written += extent.num_blocks() * block_size_;
   }
@@ skipping 55 matching lines @@
   {
     int fd = open(temp_filename.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0644);
     ScopedFdCloser fd_closer(&fd);
     TEST_AND_RETURN_FALSE(
         utils::WriteAll(fd, &buffer_[0], operation.data_length()));
   }
 
   int fd = is_kernel_partition ? kernel_fd_ : fd_;
   const string& path = is_kernel_partition ? kernel_path_ : path_;
 
+  // If this is a non-idempotent operation, request a delayed exit and clear the
+  // update state in case the operation gets interrupted. Do this as late as
+  // possible.
+  if (!IsIdempotentOperation(operation)) {
+    Terminator::set_exit_blocked(true);
+    ResetUpdateProgress(prefs_, true);
+  }
+
   vector<string> cmd;
   cmd.push_back(kBspatchPath);
   cmd.push_back(path);
   cmd.push_back(path);
   cmd.push_back(temp_filename);
   cmd.push_back(input_positions);
   cmd.push_back(output_positions);
   int return_code = 0;
   TEST_AND_RETURN_FALSE(Subprocess::SynchronousExec(cmd, &return_code));
   TEST_AND_RETURN_FALSE(return_code == 0);
@@ skipping 201 matching lines @@
   if (prefs_->GetInt64(kPrefsResumedUpdateFailures, &resumed_update_failures)) {
     resumed_update_failures++;
   } else {
     resumed_update_failures = 1;
   }
   prefs_->SetInt64(kPrefsResumedUpdateFailures, resumed_update_failures);
   return true;
 }
 
 }  // namespace chromeos_update_engine