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