diff --git a/filesystem_copier_action.cc b/filesystem_copier_action.cc
index 1f0fbc7..c9be962 100644
--- a/filesystem_copier_action.cc
+++ b/filesystem_copier_action.cc
@@ -15,8 +15,6 @@
 #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>
@@ -38,8 +36,8 @@
 }  // namespace {}
 
 FilesystemCopierAction::FilesystemCopierAction(
-    bool copying_kernel_install_path, bool verify_hash,
-    unsigned max_rewrite_attempts)
+    bool copying_kernel_install_path,
+    bool verify_hash)
     : copying_kernel_install_path_(copying_kernel_install_path),
       verify_hash_(verify_hash),
       src_stream_(NULL),
@@ -47,12 +45,7 @@
       read_done_(false),
       failed_(false),
       cancelled_(false),
-      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) {
+      filesystem_size_(kint64max) {
   // A lot of code works on the implicit assumption that processing is done on
   // exactly 2 ping-pong buffers.
   COMPILE_ASSERT(arraysize(buffer_) == 2 &&
@@ -163,18 +156,6 @@
   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;
@@ -215,6 +196,7 @@
                                                      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]);
@@ -229,46 +211,11 @@
       LOG(ERROR) << "Write error: " << utils::GetAndFreeGError(&error);
     } else {
       LOG(ERROR) << "Wrote too few bytes: " << bytes_written
-                 << " instead of " << buffer_valid_size_[index];
+                 << " < " << buffer_valid_size_[index];
     }
-
-    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;
+    failed_ = true;
   }
 
-  if (buffer_state_[index] == kBufferStateWriting)
-    buffer_state_[index] = kBufferStateEmpty;
-
   SpawnAsyncActions();
 }
 
@@ -313,12 +260,6 @@
       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(),
@@ -334,15 +275,6 @@
   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 d2f33cf..9bd9b20 100644
--- a/filesystem_copier_action.h
+++ b/filesystem_copier_action.h
@@ -37,8 +37,7 @@
 
 class FilesystemCopierAction : public Action<FilesystemCopierAction> {
  public:
-  FilesystemCopierAction(bool copying_kernel_install_path, bool verify_hash,
-                         unsigned max_rewrite_attempts);
+  FilesystemCopierAction(bool copying_kernel_install_path, bool verify_hash);
 
   typedef ActionTraits<FilesystemCopierAction>::InputObjectType
   InputObjectType;
@@ -139,19 +138,6 @@
   // 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 7c6c727..cb9c817 100644
--- a/filesystem_copier_action_unittest.cc
+++ b/filesystem_copier_action_unittest.cc
@@ -93,10 +93,18 @@
   return FALSE;
 }
 
-TEST_F(FilesystemCopierActionTest, RunAsRootSimpleTest) {
+// TODO(garnold) Temporarily disabling this test, see chromium-os:31082 for
+// details; still trying to track down the root cause for these rare write
+// failures and whether or not they are due to the test setup or an inherent
+// issue with the chroot environiment, library versions we use, etc.
+TEST_F(FilesystemCopierActionTest, DISABLED_RunAsRootSimpleTest) {
   ASSERT_EQ(0, getuid());
-  EXPECT_TRUE(DoTest(false, false, false, 0));
-  EXPECT_TRUE(DoTest(false, false, true, 0));
+  bool test = DoTest(false, false, false, 0);
+  EXPECT_TRUE(test);
+  if (!test)
+    return;
+  test = DoTest(false, false, true, 0);
+  EXPECT_TRUE(test);
 }
 
 bool FilesystemCopierActionTest::DoTest(bool run_out_of_space,
@@ -139,6 +147,8 @@
   ScopedLoopbackDeviceBinder a_dev_releaser(a_loop_file, &a_dev);
   ScopedLoopbackDeviceBinder b_dev_releaser(b_loop_file, &b_dev);
 
+  LOG(INFO) << "copying: " << a_loop_file << " -> " << b_loop_file
+            << ", " << kLoopFileSize << " bytes";
   bool success = true;
 
   // Set up the action objects
@@ -178,7 +188,7 @@
 
   ObjectFeederAction<InstallPlan> feeder_action;
   FilesystemCopierAction copier_action(use_kernel_partition,
-                                       verify_hash != 0, 3);
+                                       verify_hash != 0);
   ObjectCollectorAction<InstallPlan> collector_action;
 
   BondActions(&feeder_action, &copier_action);
@@ -269,7 +279,7 @@
 
   processor.set_delegate(&delegate);
 
-  FilesystemCopierAction copier_action(false, false, 0);
+  FilesystemCopierAction copier_action(false, false);
   ObjectCollectorAction<InstallPlan> collector_action;
 
   BondActions(&copier_action, &collector_action);
@@ -292,7 +302,7 @@
   const char* kUrl = "http://some/url";
   InstallPlan install_plan(true, kUrl, 0, "", "", "");
   feeder_action.set_obj(install_plan);
-  FilesystemCopierAction copier_action(false, false, 0);
+  FilesystemCopierAction copier_action(false, false);
   ObjectCollectorAction<InstallPlan> collector_action;
 
   BondActions(&feeder_action, &copier_action);
@@ -322,7 +332,7 @@
                            "/no/such/file",
                            "/no/such/file");
   feeder_action.set_obj(install_plan);
-  FilesystemCopierAction copier_action(false, false, 0);
+  FilesystemCopierAction copier_action(false, false);
   ObjectCollectorAction<InstallPlan> collector_action;
 
   BondActions(&copier_action, &collector_action);
@@ -371,7 +381,7 @@
 
   for (int i = 0; i < 2; ++i) {
     bool is_kernel = i == 1;
-    FilesystemCopierAction action(is_kernel, false, 0);
+    FilesystemCopierAction action(is_kernel, false);
     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 93c3c1f..8dd4622 100644
--- a/update_attempter.cc
+++ b/update_attempter.cc
@@ -377,9 +377,9 @@
   shared_ptr<OmahaResponseHandlerAction> response_handler_action(
       new OmahaResponseHandlerAction(prefs_));
   shared_ptr<FilesystemCopierAction> filesystem_copier_action(
-      new FilesystemCopierAction(false, false, 0));
+      new FilesystemCopierAction(false, false));
   shared_ptr<FilesystemCopierAction> kernel_filesystem_copier_action(
-      new FilesystemCopierAction(true, false, 0));
+      new FilesystemCopierAction(true, false));
   shared_ptr<OmahaRequestAction> download_started_action(
       new OmahaRequestAction(prefs_,
                              &omaha_request_params_,
@@ -406,9 +406,9 @@
                                                     is_test_mode_),
                              false));
   shared_ptr<FilesystemCopierAction> filesystem_verifier_action(
-      new FilesystemCopierAction(false, true, 0));
+      new FilesystemCopierAction(false, true));
   shared_ptr<FilesystemCopierAction> kernel_filesystem_verifier_action(
-      new FilesystemCopierAction(true, true, 0));
+      new FilesystemCopierAction(true, true));
   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 ae7298d..0173dea 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, 0);
+  FilesystemCopierAction filesystem_copier_action(false, false);
   EXPECT_EQ(kActionCodeFilesystemCopierError,
             GetErrorCodeForAction(&filesystem_copier_action, kActionCodeError));
   PostinstallRunnerAction postinstall_runner_action;