| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 45 size_t fread_unlocked(void* ptr, size_t size, size_t n, FILE* file) { | |
| 46 return fread(ptr, size, n, file); | |
| 47 } | |
| 48 | |
| 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 | |
| 53 int fflush_unlocked(FILE* file) { return fflush(file); } | |
| 54 | |
| 55 #if !defined(OS_ANDROID) | |
| 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. | |
| 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: | |
| 84 ChromiumSequentialFile(const std::string& fname, | |
| 85 FILE* f, | |
| 86 const UMALogger* uma_logger) | |
| 87 : filename_(fname), file_(f), uma_logger_(uma_logger) {} | |
| 88 virtual ~ChromiumSequentialFile() { fclose(file_); } | |
| 89 | |
| 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 | |
| 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: | |
| 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) {} | |
| 128 virtual ~ChromiumRandomAccessFile() {} | |
| 129 | |
| 130 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 | |
| 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 | |
| 168 ChromiumWritableFile::~ChromiumWritableFile() { | |
| 169 if (file_ != NULL) { | |
| 170 // Ignoring any potential errors | |
| 171 fclose(file_); | |
| 172 } | |
| 173 } | |
| 174 | |
| 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 | |
| 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 | |
| 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 | |
| 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 | |
| 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 | |
| 257 ChromiumEnvStdio::ChromiumEnvStdio() {} | |
| 258 | |
| 259 ChromiumEnvStdio::~ChromiumEnvStdio() {} | |
| 260 | |
| 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 | |
| 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 | |
| 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 | |
| 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) | |
| 323 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 | |
| 352 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 | |
| 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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 710373002:
LevelDB: Using base::File for all file I/O (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master