base/files/important_file_writer.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/files/important_file_writer.h"
   6
   7 #include <stdio.h>
   8
   9 #include <string>
  10
  11 #include "base/bind.h"
  12 #include "base/critical_closure.h"
  13 #include "base/file_util.h"
  14 #include "base/files/file_path.h"
  15 #include "base/logging.h"
  16 #include "base/metrics/histogram.h"
  17 #include "base/strings/string_number_conversions.h"
  18 #include "base/task_runner.h"
  19 #include "base/threading/thread.h"
  20 #include "base/time/time.h"
  21
  22 namespace base {
  23
  24 namespace {
  25
  26 const int kDefaultCommitIntervalMs = 10000;
  27
  28 enum TempFileFailure {
  29   FAILED_CREATING,
  30   FAILED_OPENING,
  31   FAILED_CLOSING,
  32   FAILED_WRITING,
  33   FAILED_RENAMING,
  34   TEMP_FILE_FAILURE_MAX
  35 };
  36
  37 void LogFailure(const FilePath& path, TempFileFailure failure_code,
  38                 const std::string& message) {
  39   UMA_HISTOGRAM_ENUMERATION("ImportantFile.TempFileFailures", failure_code,
  40                             TEMP_FILE_FAILURE_MAX);
  41   DPLOG(WARNING) << "temp file failure: " << path.value().c_str()
  42                  << " : " << message;
  43 }
  44
  45 }  // namespace
  46
  47 // static
  48 bool ImportantFileWriter::WriteFileAtomically(const FilePath& path,
  49                                               const std::string& data) {
  50   // Write the data to a temp file then rename to avoid data loss if we crash
  51   // while writing the file. Ensure that the temp file is on the same volume
  52   // as target file, so it can be moved in one step, and that the temp file
  53   // is securely created.
  54   FilePath tmp_file_path;
  55   if (!file_util::CreateTemporaryFileInDir(path.DirName(), &tmp_file_path)) {
  56     LogFailure(path, FAILED_CREATING, "could not create temporary file");
  57     return false;
  58   }
  59
  60   int flags = PLATFORM_FILE_OPEN | PLATFORM_FILE_WRITE;
  61   PlatformFile tmp_file =
  62       CreatePlatformFile(tmp_file_path, flags, NULL, NULL);
  63   if (tmp_file == kInvalidPlatformFileValue) {
  64     LogFailure(path, FAILED_OPENING, "could not open temporary file");
  65     return false;
  66   }
  67
  68   // If this happens in the wild something really bad is going on.
  69   CHECK_LE(data.length(), static_cast<size_t>(kint32max));
  70   int bytes_written = WritePlatformFile(
  71       tmp_file, 0, data.data(), static_cast<int>(data.length()));
  72   FlushPlatformFile(tmp_file);  // Ignore return value.
  73
  74   if (!ClosePlatformFile(tmp_file)) {
  75     LogFailure(path, FAILED_CLOSING, "failed to close temporary file");
  76     base::DeleteFile(tmp_file_path, false);
  77     return false;
  78   }
  79
  80   if (bytes_written < static_cast<int>(data.length())) {
  81     LogFailure(path, FAILED_WRITING, "error writing, bytes_written=" +
  82                IntToString(bytes_written));
  83     base::DeleteFile(tmp_file_path, false);
  84     return false;
  85   }
  86
  87   if (!base::ReplaceFile(tmp_file_path, path, NULL)) {
  88     LogFailure(path, FAILED_RENAMING, "could not rename temporary file");
  89     base::DeleteFile(tmp_file_path, false);
  90     return false;
  91   }
  92
  93   return true;
  94 }
  95
  96 ImportantFileWriter::ImportantFileWriter(
  97     const FilePath& path, base::SequencedTaskRunner* task_runner)
  98         : path_(path),
  99           task_runner_(task_runner),
 100           serializer_(NULL),
 101           commit_interval_(TimeDelta::FromMilliseconds(
 102               kDefaultCommitIntervalMs)) {
 103   DCHECK(CalledOnValidThread());
 104   DCHECK(task_runner_.get());
 105 }
 106
 107 ImportantFileWriter::~ImportantFileWriter() {
 108   // We're usually a member variable of some other object, which also tends
 109   // to be our serializer. It may not be safe to call back to the parent object
 110   // being destructed.
 111   DCHECK(!HasPendingWrite());
 112 }
 113
 114 bool ImportantFileWriter::HasPendingWrite() const {
 115   DCHECK(CalledOnValidThread());
 116   return timer_.IsRunning();
 117 }
 118
 119 void ImportantFileWriter::WriteNow(const std::string& data) {
 120   DCHECK(CalledOnValidThread());
 121   if (data.length() > static_cast<size_t>(kint32max)) {
 122     NOTREACHED();
 123     return;
 124   }
 125
 126   if (HasPendingWrite())
 127     timer_.Stop();
 128
 129   if (!task_runner_->PostTask(
 130           FROM_HERE,
 131           MakeCriticalClosure(
 132               Bind(IgnoreResult(&ImportantFileWriter::WriteFileAtomically),
 133                    path_, data)))) {
 134     // Posting the task to background message loop is not expected
 135     // to fail, but if it does, avoid losing data and just hit the disk
 136     // on the current thread.
 137     NOTREACHED();
 138
 139     WriteFileAtomically(path_, data);
 140   }
 141 }
 142
 143 void ImportantFileWriter::ScheduleWrite(DataSerializer* serializer) {
 144   DCHECK(CalledOnValidThread());
 145
 146   DCHECK(serializer);
 147   serializer_ = serializer;
 148
 149   if (!timer_.IsRunning()) {
 150     timer_.Start(FROM_HERE, commit_interval_, this,
 151                  &ImportantFileWriter::DoScheduledWrite);
 152   }
 153 }
 154
 155 void ImportantFileWriter::DoScheduledWrite() {
 156   DCHECK(serializer_);
 157   std::string data;
 158   if (serializer_->SerializeData(&data)) {
 159     WriteNow(data);
 160   } else {
 161     DLOG(WARNING) << "failed to serialize data to be saved in "
 162                   << path_.value().c_str();
 163   }
 164   serializer_ = NULL;
 165 }
 166
 167 }  // namespace base