1 // Copyright (c) 2011-2013 The LevelDB 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. See the AUTHORS file for names of contributors.
4
5 #include <errno.h>
6
7 #include "base/debug/trace_event.h"
8 #include "base/metrics/histogram.h"
9 #include "base/posix/eintr_wrapper.h"
10 #include "base/strings/utf_string_conversions.h"
11 #include "chromium_logger.h"
12 #include "env_chromium_stdio.h"
13
14 #if defined(OS_WIN)
15 #include <io.h>
16 #include "base/win/win_util.h"
17 #endif
18
19 #if defined(OS_POSIX)
20 #include <dirent.h>
21 #include <fcntl.h>
22 #include <sys/resource.h>
23 #endif
24
25 using namespace leveldb;
26
27 namespace leveldb_env {
28
29 namespace {
30
31 #if (defined(OS_POSIX) && !defined(OS_LINUX)) || defined(OS_WIN)
32 // The following are glibc-specific
33
fread_unlocked(void * ptr,size_t size,size_t n,FILE * file)34 size_t fread_unlocked(void* ptr, size_t size, size_t n, FILE* file) {
35 return fread(ptr, size, n, file);
36 }
37
fwrite_unlocked(const void * ptr,size_t size,size_t n,FILE * file)38 size_t fwrite_unlocked(const void* ptr, size_t size, size_t n, FILE* file) {
39 return fwrite(ptr, size, n, file);
40 }
41
fflush_unlocked(FILE * file)42 int fflush_unlocked(FILE* file) { return fflush(file); }
43
44 #if !defined(OS_ANDROID)
fdatasync(int fildes)45 int fdatasync(int fildes) {
46 #if defined(OS_WIN)
47 return _commit(fildes);
48 #else
49 return HANDLE_EINTR(fsync(fildes));
50 #endif
51 }
52 #endif
53
54 #endif
55
56 // Wide-char safe fopen wrapper.
fopen_internal(const char * fname,const char * mode)57 FILE* fopen_internal(const char* fname, const char* mode) {
58 #if defined(OS_WIN)
59 return _wfopen(base::UTF8ToUTF16(fname).c_str(),
60 base::ASCIIToUTF16(mode).c_str());
61 #else
62 return fopen(fname, mode);
63 #endif
64 }
65
66 class ChromiumSequentialFile : public SequentialFile {
67 private:
68 std::string filename_;
69 FILE* file_;
70 const UMALogger* uma_logger_;
71
72 public:
ChromiumSequentialFile(const std::string & fname,FILE * f,const UMALogger * uma_logger)73 ChromiumSequentialFile(const std::string& fname,
74 FILE* f,
75 const UMALogger* uma_logger)
76 : filename_(fname), file_(f), uma_logger_(uma_logger) {}
~ChromiumSequentialFile()77 virtual ~ChromiumSequentialFile() { fclose(file_); }
78
Read(size_t n,Slice * result,char * scratch)79 virtual Status Read(size_t n, Slice* result, char* scratch) {
80 Status s;
81 size_t r = fread_unlocked(scratch, 1, n, file_);
82 *result = Slice(scratch, r);
83 if (r < n) {
84 if (feof(file_)) {
85 // We leave status as ok if we hit the end of the file
86 } else {
87 // A partial read with an error: return a non-ok status
88 s = MakeIOError(filename_, strerror(errno), kSequentialFileRead, errno);
89 uma_logger_->RecordErrorAt(kSequentialFileRead);
90 }
91 }
92 return s;
93 }
94
Skip(uint64_t n)95 virtual Status Skip(uint64_t n) {
96 if (fseek(file_, n, SEEK_CUR)) {
97 int saved_errno = errno;
98 uma_logger_->RecordErrorAt(kSequentialFileSkip);
99 return MakeIOError(
100 filename_, strerror(saved_errno), kSequentialFileSkip, saved_errno);
101 }
102 return Status::OK();
103 }
104 };
105
106 class ChromiumRandomAccessFile : public RandomAccessFile {
107 private:
108 std::string filename_;
109 mutable ::base::File file_;
110 const UMALogger* uma_logger_;
111
112 public:
ChromiumRandomAccessFile(const std::string & fname,::base::File file,const UMALogger * uma_logger)113 ChromiumRandomAccessFile(const std::string& fname,
114 ::base::File file,
115 const UMALogger* uma_logger)
116 : filename_(fname), file_(file.Pass()), uma_logger_(uma_logger) {}
~ChromiumRandomAccessFile()117 virtual ~ChromiumRandomAccessFile() {}
118
Read(uint64_t offset,size_t n,Slice * result,char * scratch) const119 virtual Status Read(uint64_t offset, size_t n, Slice* result, char* scratch)
120 const {
121 Status s;
122 int r = file_.Read(offset, scratch, n);
123 *result = Slice(scratch, (r < 0) ? 0 : r);
124 if (r < 0) {
125 // An error: return a non-ok status
126 s = MakeIOError(
127 filename_, "Could not perform read", kRandomAccessFileRead);
128 uma_logger_->RecordErrorAt(kRandomAccessFileRead);
129 }
130 return s;
131 }
132 };
133
134 } // unnamed namespace
135
ChromiumWritableFile(const std::string & fname,FILE * f,const UMALogger * uma_logger,WriteTracker * tracker,bool make_backup)136 ChromiumWritableFile::ChromiumWritableFile(const std::string& fname,
137 FILE* f,
138 const UMALogger* uma_logger,
139 WriteTracker* tracker,
140 bool make_backup)
141 : filename_(fname),
142 file_(f),
143 uma_logger_(uma_logger),
144 tracker_(tracker),
145 file_type_(kOther),
146 make_backup_(make_backup) {
147 base::FilePath path = base::FilePath::FromUTF8Unsafe(fname);
148 if (FilePathToString(path.BaseName()).find("MANIFEST") == 0)
149 file_type_ = kManifest;
150 else if (ChromiumEnv::HasTableExtension(path))
151 file_type_ = kTable;
152 if (file_type_ != kManifest)
153 tracker_->DidCreateNewFile(filename_);
154 parent_dir_ = FilePathToString(ChromiumEnv::CreateFilePath(fname).DirName());
155 }
156
~ChromiumWritableFile()157 ChromiumWritableFile::~ChromiumWritableFile() {
158 if (file_ != NULL) {
159 // Ignoring any potential errors
160 fclose(file_);
161 }
162 }
163
SyncParent()164 Status ChromiumWritableFile::SyncParent() {
165 Status s;
166 #if !defined(OS_WIN)
167 TRACE_EVENT0("leveldb", "SyncParent");
168
169 int parent_fd = HANDLE_EINTR(open(parent_dir_.c_str(), O_RDONLY));
170 if (parent_fd < 0) {
171 int saved_errno = errno;
172 return MakeIOError(
173 parent_dir_, strerror(saved_errno), kSyncParent, saved_errno);
174 }
175 if (HANDLE_EINTR(fsync(parent_fd)) != 0) {
176 int saved_errno = errno;
177 s = MakeIOError(
178 parent_dir_, strerror(saved_errno), kSyncParent, saved_errno);
179 };
180 close(parent_fd);
181 #endif
182 return s;
183 }
184
Append(const Slice & data)185 Status ChromiumWritableFile::Append(const Slice& data) {
186 if (file_type_ == kManifest && tracker_->DoesDirNeedSync(filename_)) {
187 Status s = SyncParent();
188 if (!s.ok())
189 return s;
190 tracker_->DidSyncDir(filename_);
191 }
192
193 size_t r = fwrite_unlocked(data.data(), 1, data.size(), file_);
194 if (r != data.size()) {
195 int saved_errno = errno;
196 uma_logger_->RecordOSError(kWritableFileAppend, saved_errno);
197 return MakeIOError(
198 filename_, strerror(saved_errno), kWritableFileAppend, saved_errno);
199 }
200 return Status::OK();
201 }
202
Close()203 Status ChromiumWritableFile::Close() {
204 Status result;
205 if (fclose(file_) != 0) {
206 result = MakeIOError(filename_, strerror(errno), kWritableFileClose, errno);
207 uma_logger_->RecordErrorAt(kWritableFileClose);
208 }
209 file_ = NULL;
210 return result;
211 }
212
Flush()213 Status ChromiumWritableFile::Flush() {
214 Status result;
215 if (HANDLE_EINTR(fflush_unlocked(file_))) {
216 int saved_errno = errno;
217 result = MakeIOError(
218 filename_, strerror(saved_errno), kWritableFileFlush, saved_errno);
219 uma_logger_->RecordOSError(kWritableFileFlush, saved_errno);
220 }
221 return result;
222 }
223
Sync()224 Status ChromiumWritableFile::Sync() {
225 TRACE_EVENT0("leveldb", "ChromiumEnvStdio::Sync");
226 Status result;
227 int error = 0;
228
229 if (HANDLE_EINTR(fflush_unlocked(file_)))
230 error = errno;
231 // Sync even if fflush gave an error; perhaps the data actually got out,
232 // even though something went wrong.
233 if (fdatasync(fileno(file_)) && !error)
234 error = errno;
235 // Report the first error we found.
236 if (error) {
237 result = MakeIOError(filename_, strerror(error), kWritableFileSync, error);
238 uma_logger_->RecordErrorAt(kWritableFileSync);
239 } else if (make_backup_ && file_type_ == kTable) {
240 bool success = ChromiumEnv::MakeBackup(filename_);
241 uma_logger_->RecordBackupResult(success);
242 }
243 return result;
244 }
245
ChromiumEnvStdio()246 ChromiumEnvStdio::ChromiumEnvStdio() {}
247
~ChromiumEnvStdio()248 ChromiumEnvStdio::~ChromiumEnvStdio() {}
249
NewSequentialFile(const std::string & fname,SequentialFile ** result)250 Status ChromiumEnvStdio::NewSequentialFile(const std::string& fname,
251 SequentialFile** result) {
252 FILE* f = fopen_internal(fname.c_str(), "rb");
253 if (f == NULL) {
254 *result = NULL;
255 int saved_errno = errno;
256 RecordOSError(kNewSequentialFile, saved_errno);
257 return MakeIOError(
258 fname, strerror(saved_errno), kNewSequentialFile, saved_errno);
259 } else {
260 *result = new ChromiumSequentialFile(fname, f, this);
261 return Status::OK();
262 }
263 }
264
RecordOpenFilesLimit(const std::string & type)265 void ChromiumEnvStdio::RecordOpenFilesLimit(const std::string& type) {
266 #if defined(OS_POSIX)
267 struct rlimit nofile;
268 if (getrlimit(RLIMIT_NOFILE, &nofile))
269 return;
270 GetMaxFDHistogram(type)->Add(nofile.rlim_cur);
271 #endif
272 }
273
NewRandomAccessFile(const std::string & fname,RandomAccessFile ** result)274 Status ChromiumEnvStdio::NewRandomAccessFile(const std::string& fname,
275 RandomAccessFile** result) {
276 int flags = ::base::File::FLAG_READ | ::base::File::FLAG_OPEN;
277 ::base::File file(ChromiumEnv::CreateFilePath(fname), flags);
278 if (file.IsValid()) {
279 *result = new ChromiumRandomAccessFile(fname, file.Pass(), this);
280 RecordOpenFilesLimit("Success");
281 return Status::OK();
282 }
283 ::base::File::Error error_code = file.error_details();
284 if (error_code == ::base::File::FILE_ERROR_TOO_MANY_OPENED)
285 RecordOpenFilesLimit("TooManyOpened");
286 else
287 RecordOpenFilesLimit("OtherError");
288 *result = NULL;
289 RecordOSError(kNewRandomAccessFile, error_code);
290 return MakeIOError(fname,
291 FileErrorString(error_code),
292 kNewRandomAccessFile,
293 error_code);
294 }
295
NewWritableFile(const std::string & fname,WritableFile ** result)296 Status ChromiumEnvStdio::NewWritableFile(const std::string& fname,
297 WritableFile** result) {
298 *result = NULL;
299 FILE* f = fopen_internal(fname.c_str(), "wb");
300 if (f == NULL) {
301 int saved_errno = errno;
302 RecordErrorAt(kNewWritableFile);
303 return MakeIOError(
304 fname, strerror(saved_errno), kNewWritableFile, saved_errno);
305 } else {
306 *result = new ChromiumWritableFile(fname, f, this, this, make_backup_);
307 return Status::OK();
308 }
309 }
310
311 #if defined(OS_WIN)
GetDirectoryEntries(const base::FilePath & dir_param,std::vector<base::FilePath> * result) const312 base::File::Error ChromiumEnvStdio::GetDirectoryEntries(
313 const base::FilePath& dir_param,
314 std::vector<base::FilePath>* result) const {
315 result->clear();
316 base::FilePath dir_filepath = dir_param.Append(FILE_PATH_LITERAL("*"));
317 WIN32_FIND_DATA find_data;
318 HANDLE find_handle = FindFirstFile(dir_filepath.value().c_str(), &find_data);
319 if (find_handle == INVALID_HANDLE_VALUE) {
320 DWORD last_error = GetLastError();
321 if (last_error == ERROR_FILE_NOT_FOUND)
322 return base::File::FILE_OK;
323 return base::File::OSErrorToFileError(last_error);
324 }
325 do {
326 base::FilePath filepath(find_data.cFileName);
327 base::FilePath::StringType basename = filepath.BaseName().value();
328 if (basename == FILE_PATH_LITERAL(".") ||
329 basename == FILE_PATH_LITERAL(".."))
330 continue;
331 result->push_back(filepath.BaseName());
332 } while (FindNextFile(find_handle, &find_data));
333 DWORD last_error = GetLastError();
334 base::File::Error return_value = base::File::FILE_OK;
335 if (last_error != ERROR_NO_MORE_FILES)
336 return_value = base::File::OSErrorToFileError(last_error);
337 FindClose(find_handle);
338 return return_value;
339 }
340 #else
GetDirectoryEntries(const base::FilePath & dir_filepath,std::vector<base::FilePath> * result) const341 base::File::Error ChromiumEnvStdio::GetDirectoryEntries(
342 const base::FilePath& dir_filepath,
343 std::vector<base::FilePath>* result) const {
344 const std::string dir_string = FilePathToString(dir_filepath);
345 result->clear();
346 DIR* dir = opendir(dir_string.c_str());
347 if (!dir)
348 return base::File::OSErrorToFileError(errno);
349 struct dirent dent_buf;
350 struct dirent* dent;
351 int readdir_result;
352 while ((readdir_result = readdir_r(dir, &dent_buf, &dent)) == 0 && dent) {
353 if (strcmp(dent->d_name, ".") == 0 || strcmp(dent->d_name, "..") == 0)
354 continue;
355 result->push_back(ChromiumEnv::CreateFilePath(dent->d_name));
356 }
357 int saved_errno = errno;
358 closedir(dir);
359 if (readdir_result != 0)
360 return base::File::OSErrorToFileError(saved_errno);
361 return base::File::FILE_OK;
362 }
363 #endif
364
NewLogger(const std::string & fname,Logger ** result)365 Status ChromiumEnvStdio::NewLogger(const std::string& fname, Logger** result) {
366 FILE* f = fopen_internal(fname.c_str(), "w");
367 if (f == NULL) {
368 *result = NULL;
369 int saved_errno = errno;
370 RecordOSError(kNewLogger, saved_errno);
371 return MakeIOError(fname, strerror(saved_errno), kNewLogger, saved_errno);
372 } else {
373 *result = new ChromiumLogger(f);
374 return Status::OK();
375 }
376 }
377
378 } // namespace leveldb_env
379