diff --git a/filesystem_copier_action.cc b/filesystem_copier_action.cc
index 340dd1d..1f0fbc7 100644
--- a/filesystem_copier_action.cc
+++ b/filesystem_copier_action.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
@@ -15,6 +15,8 @@
 #include <string>
 #include <vector>
 
+#include <base/string_util.h>
+#include <base/stringprintf.h>
 #include <gio/gio.h>
 #include <gio/gunixinputstream.h>
 #include <gio/gunixoutputstream.h>
@@ -36,8 +38,8 @@
 }  // namespace {}
 
 FilesystemCopierAction::FilesystemCopierAction(
-    bool copying_kernel_install_path,
-    bool verify_hash)
+    bool copying_kernel_install_path, bool verify_hash,
+    unsigned max_rewrite_attempts)
     : copying_kernel_install_path_(copying_kernel_install_path),
       verify_hash_(verify_hash),
       src_stream_(NULL),
@@ -45,7 +47,12 @@
       read_done_(false),
       failed_(false),
       cancelled_(false),
-      filesystem_size_(kint64max) {
+      filesystem_size_(kint64max),
+      total_bytes_written_(0),
+      num_curr_rewrite_attempts_(0),
+      num_total_rewrite_attempts_(0),
+      max_rewrite_attempts_(max_rewrite_attempts),
+      is_debug_last_read_(false) {
   // A lot of code works on the implicit assumption that processing is done on
   // exactly 2 ping-pong buffers.
   COMPILE_ASSERT(arraysize(buffer_) == 2 &&
@@ -156,6 +163,18 @@
   cancelled_ = g_cancellable_is_cancelled(canceller_[index]) == TRUE;
 
   ssize_t bytes_read = g_input_stream_read_finish(src_stream_, res, &error);
+
+  // TODO(garnold) this is debugging code which needs to be removed once we
+  // figure out the reasons for write I/O error.
+  ssize_t bytes_expected = std::min(static_cast<int64_t>(buffer_[0].size()),
+                                    filesystem_size_);
+  if (!is_debug_last_read_ && bytes_read > 0 && bytes_read < bytes_expected) {
+    LOG(INFO) << "[debug] read fewer bytes than expected ("
+              << bytes_read << " < " << bytes_expected
+              << "), this is likely the final read";
+    is_debug_last_read_ = true;
+  }
+
   if (bytes_read < 0) {
     LOG(ERROR) << "Read failed: " << utils::GetAndFreeGError(&error);
     failed_ = true;
@@ -196,7 +215,6 @@
                                                      GAsyncResult *res) {
   int index = buffer_state_[0] == kBufferStateWriting ? 0 : 1;
   CHECK(buffer_state_[index] == kBufferStateWriting);
-  buffer_state_[index] = kBufferStateEmpty;
 
   GError* error = NULL;
   CHECK(canceller_[index]);
@@ -205,16 +223,52 @@
   ssize_t bytes_written = g_output_stream_write_finish(dst_stream_,
                                                        res,
                                                        &error);
+
   if (bytes_written < static_cast<ssize_t>(buffer_valid_size_[index])) {
     if (bytes_written < 0) {
-      LOG(ERROR) << "Write failed: " << utils::GetAndFreeGError(&error);
+      LOG(ERROR) << "Write error: " << utils::GetAndFreeGError(&error);
     } else {
-      LOG(ERROR) << "Write was short: wrote " << bytes_written
-                 << " but expected to write " << buffer_valid_size_[index];
+      LOG(ERROR) << "Wrote too few bytes: " << bytes_written
+                 << " instead of " << buffer_valid_size_[index];
     }
-    failed_ = true;
+
+    bool do_fail = true;  // fail, unless we can retry
+
+    if (cancelled_) {
+      LOG(ERROR) << "write operation cancelled, copying failed";
+    } else if (num_curr_rewrite_attempts_ < max_rewrite_attempts_) {
+      // Try again: mark buffer as full, reposition the output stream.
+      num_curr_rewrite_attempts_++;
+      num_total_rewrite_attempts_++;
+      off_t ret =
+          lseek(g_unix_output_stream_get_fd(G_UNIX_OUTPUT_STREAM(dst_stream_)),
+                static_cast<off_t>(total_bytes_written_),
+                SEEK_SET);
+      if (ret == static_cast<off_t>(total_bytes_written_)) {
+        buffer_state_[index] = kBufferStateFull;
+        do_fail = false;
+        LOG(INFO) << "attempting to rewrite current buffer at offset "
+                  << total_bytes_written_ << " (" << num_curr_rewrite_attempts_
+                  << " of " << max_rewrite_attempts_ << " attempts)";
+      } else {
+        PLOG(ERROR)
+            << "can't reposition output stream for rewrite, copying failed";
+      }
+    } else {
+      LOG(ERROR) << "rewrite attempts exhausted (" << max_rewrite_attempts_
+                 << "), copying failed";
+    }
+
+    if (do_fail)
+      failed_ = true;
+  } else {
+    total_bytes_written_ += static_cast<size_t>(bytes_written);
+    num_curr_rewrite_attempts_ = 0;
   }
 
+  if (buffer_state_[index] == kBufferStateWriting)
+    buffer_state_[index] = kBufferStateEmpty;
+
   SpawnAsyncActions();
 }
 
@@ -259,6 +313,12 @@
       buffer_state_[i] = kBufferStateReading;
     } else if (!writing && !verify_hash_ &&
                buffer_state_[i] == kBufferStateFull) {
+      // TODO(garnold) debugging code, to be removed.
+      if (is_debug_last_read_) {
+        LOG(INFO) << "[debug] spawning async write of "
+                  << buffer_valid_size_[i] << " bytes";
+      }
+
       g_output_stream_write_async(
           dst_stream_,
           buffer_[i].data(),
@@ -274,6 +334,15 @@
   if (!reading && !writing) {
     // We're done!
     ActionExitCode code = kActionCodeSuccess;
+    // TODO(garnold) we're signaling a failure if buffer rewriting was attempted
+    // during the copy action; this is necessary for keeping our unit tests
+    // failing, allowing us to diagnose the root cause for write I/O errors.
+    // When diagnosis is complete, this error return code needs to be reversed.
+    if (num_total_rewrite_attempts_) {
+      code = kActionCodeError;
+      LOG(ERROR) << "[debug] rewrite was attempted "
+                 << num_total_rewrite_attempts_ << " time(s), copying failed";
+    }
     if (hasher_.Finalize()) {
       LOG(INFO) << "Hash: " << hasher_.hash();
       if (verify_hash_) {
diff --git a/filesystem_copier_action.h b/filesystem_copier_action.h
index 0658597..d2f33cf 100644
--- a/filesystem_copier_action.h
+++ b/filesystem_copier_action.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
@@ -37,8 +37,8 @@
 
 class FilesystemCopierAction : public Action<FilesystemCopierAction> {
  public:
-  FilesystemCopierAction(bool copying_kernel_install_path,
-                         bool verify_hash);
+  FilesystemCopierAction(bool copying_kernel_install_path, bool verify_hash,
+                         unsigned max_rewrite_attempts);
 
   typedef ActionTraits<FilesystemCopierAction>::InputObjectType
   InputObjectType;
@@ -139,6 +139,19 @@
   // bytes get copied.
   int64_t filesystem_size_;
 
+  // The total number of bytes successfully written to the destination stream.
+  // This is used for repositioning the stream on rewrite attempts.
+  size_t total_bytes_written_;
+
+  // Number of successive rewrite attempts for a buffer, total rewrite attempts
+  // during a copy, and the maximum number of allowed attempts.
+  unsigned num_curr_rewrite_attempts_;
+  unsigned num_total_rewrite_attempts_;
+  unsigned max_rewrite_attempts_;
+
+  // TODO(garnold) used for debugging, to be removed.
+  bool is_debug_last_read_;
+
   DISALLOW_COPY_AND_ASSIGN(FilesystemCopierAction);
 };
 
diff --git a/filesystem_copier_action_unittest.cc b/filesystem_copier_action_unittest.cc
index a626363..7c6c727 100644
--- a/filesystem_copier_action_unittest.cc
+++ b/filesystem_copier_action_unittest.cc
@@ -9,8 +9,6 @@
 #include <vector>
 
 #include <base/eintr_wrapper.h>
-// TODO(garnold) remove this include, here for debugging purposes
-#include <base/rand_util.h>
 #include <base/string_util.h>
 #include <base/stringprintf.h>
 #include <glib.h>
@@ -33,22 +31,10 @@
   // |verify_hash|: 0 - no hash verification, 1 -- successful hash verification,
   // 2 -- hash verification failure.
   // Returns true iff test has completed successfully.
-  // TODO(garnold) we temporarily add an |is_debug_random_loop_file_size| to try
-  // copying with different file sizes, in attempt to expose circumstances that
-  // lead to a certain unit test failure. The second variant preserves the
-  // original behavior. This code needs to be reverted.
   bool DoTest(bool run_out_of_space,
               bool terminate_early,
               bool use_kernel_partition,
-              int verify_hash,
-              bool is_debug_random_loop_file_size);
-  inline bool DoTest(bool run_out_of_space,
-                     bool terminate_early,
-                     bool use_kernel_partition,
-                     int verify_hash) {
-    return DoTest(run_out_of_space, terminate_early, use_kernel_partition,
-                  verify_hash, false);
-  }
+              int verify_hash);
   void SetUp() {
   }
   void TearDown() {
@@ -109,15 +95,14 @@
 
 TEST_F(FilesystemCopierActionTest, RunAsRootSimpleTest) {
   ASSERT_EQ(0, getuid());
-  EXPECT_TRUE(DoTest(false, false, false, 0, true));
-  EXPECT_TRUE(DoTest(false, false, true, 0, true));
+  EXPECT_TRUE(DoTest(false, false, false, 0));
+  EXPECT_TRUE(DoTest(false, false, true, 0));
 }
 
 bool FilesystemCopierActionTest::DoTest(bool run_out_of_space,
                                         bool terminate_early,
                                         bool use_kernel_partition,
-                                        int verify_hash,
-                                        bool is_debug_random_loop_file_size) {
+                                        int verify_hash) {
   GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
 
   string a_loop_file;
@@ -132,35 +117,7 @@
   ScopedPathUnlinker b_loop_file_unlinker(b_loop_file);
 
   // Make random data for a, zero filled data for b.
-  // TODO(garnold) eliminate the random choice, here for debugging purposes of
-  // unittest failures. We're testing the hypothesis that the particular file
-  // size causes this nondeterministic problem.
-  size_t randomLoopFileSize = 10 * 1024 * 1024 + 512;  // original value
-  if (is_debug_random_loop_file_size) {
-    int debugRandomChoice = base::RandInt(0, 4);
-    switch (debugRandomChoice) {
-      case 0:
-        break;  // keep default value
-      case 1:
-        randomLoopFileSize = 10 * 1024 * 1024;  // exactly 10 MB
-        break;
-      case 2:
-        randomLoopFileSize = (10 * 1024 + 128) * 1024;  // 10 MB + 128 KB
-        break;
-      case 3:
-        randomLoopFileSize = 30 * 1024 * 1024;  // exactly 30 MB
-        break;
-      case 4:
-        randomLoopFileSize = 30 * 1024 * 1024 + 512;  // 10 MB + 512 bytes
-        break;
-      default:
-        ADD_FAILURE();
-        return false;
-    }
-    LOG(INFO) << "(debug) randomLoopFileSize=" << randomLoopFileSize
-              << " (option " << debugRandomChoice << ")";
-  }
-  const size_t kLoopFileSize = randomLoopFileSize;
+  const size_t kLoopFileSize = 10 * 1024 * 1024 + 512;
   vector<char> a_loop_data(kLoopFileSize);
   FillWithData(&a_loop_data);
   vector<char> b_loop_data(run_out_of_space ?
@@ -221,7 +178,7 @@
 
   ObjectFeederAction<InstallPlan> feeder_action;
   FilesystemCopierAction copier_action(use_kernel_partition,
-                                       verify_hash != 0);
+                                       verify_hash != 0, 3);
   ObjectCollectorAction<InstallPlan> collector_action;
 
   BondActions(&feeder_action, &copier_action);
@@ -312,7 +269,7 @@
 
   processor.set_delegate(&delegate);
 
-  FilesystemCopierAction copier_action(false, false);
+  FilesystemCopierAction copier_action(false, false, 0);
   ObjectCollectorAction<InstallPlan> collector_action;
 
   BondActions(&copier_action, &collector_action);
@@ -335,7 +292,7 @@
   const char* kUrl = "http://some/url";
   InstallPlan install_plan(true, kUrl, 0, "", "", "");
   feeder_action.set_obj(install_plan);
-  FilesystemCopierAction copier_action(false, false);
+  FilesystemCopierAction copier_action(false, false, 0);
   ObjectCollectorAction<InstallPlan> collector_action;
 
   BondActions(&feeder_action, &copier_action);
@@ -365,7 +322,7 @@
                            "/no/such/file",
                            "/no/such/file");
   feeder_action.set_obj(install_plan);
-  FilesystemCopierAction copier_action(false, false);
+  FilesystemCopierAction copier_action(false, false, 0);
   ObjectCollectorAction<InstallPlan> collector_action;
 
   BondActions(&copier_action, &collector_action);
@@ -414,7 +371,7 @@
 
   for (int i = 0; i < 2; ++i) {
     bool is_kernel = i == 1;
-    FilesystemCopierAction action(is_kernel, false);
+    FilesystemCopierAction action(is_kernel, false, 0);
     EXPECT_EQ(kint64max, action.filesystem_size_);
     {
       int fd = HANDLE_EINTR(open(img.c_str(), O_RDONLY));
diff --git a/update_attempter.cc b/update_attempter.cc
index 8b77a95..7e3f362 100644
--- a/update_attempter.cc
+++ b/update_attempter.cc
@@ -373,9 +373,9 @@
   shared_ptr<OmahaResponseHandlerAction> response_handler_action(
       new OmahaResponseHandlerAction(prefs_));
   shared_ptr<FilesystemCopierAction> filesystem_copier_action(
-      new FilesystemCopierAction(false, false));
+      new FilesystemCopierAction(false, false, 0));
   shared_ptr<FilesystemCopierAction> kernel_filesystem_copier_action(
-      new FilesystemCopierAction(true, false));
+      new FilesystemCopierAction(true, false, 0));
   shared_ptr<OmahaRequestAction> download_started_action(
       new OmahaRequestAction(prefs_,
                              &omaha_request_params_,
@@ -400,9 +400,9 @@
                                                     system_state_),
                              false));
   shared_ptr<FilesystemCopierAction> filesystem_verifier_action(
-      new FilesystemCopierAction(false, true));
+      new FilesystemCopierAction(false, true, 0));
   shared_ptr<FilesystemCopierAction> kernel_filesystem_verifier_action(
-      new FilesystemCopierAction(true, true));
+      new FilesystemCopierAction(true, true, 0));
   shared_ptr<PostinstallRunnerAction> postinstall_runner_action(
       new PostinstallRunnerAction);
   shared_ptr<OmahaRequestAction> update_complete_action(
diff --git a/update_attempter_unittest.cc b/update_attempter_unittest.cc
index 0173dea..ae7298d 100644
--- a/update_attempter_unittest.cc
+++ b/update_attempter_unittest.cc
@@ -177,7 +177,7 @@
   EXPECT_EQ(kActionCodeOmahaResponseHandlerError,
             GetErrorCodeForAction(&omaha_response_handler_action,
                                   kActionCodeError));
-  FilesystemCopierAction filesystem_copier_action(false, false);
+  FilesystemCopierAction filesystem_copier_action(false, false, 0);
   EXPECT_EQ(kActionCodeFilesystemCopierError,
             GetErrorCodeForAction(&filesystem_copier_action, kActionCodeError));
   PostinstallRunnerAction postinstall_runner_action;