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