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 390
