third_party/leveldatabase/env_chromium.cc

   1 // Copyright (c) 2011 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 #include <stdio.h>
   7
   8 #include <deque>
   9
  10 #include "base/at_exit.h"
  11 #include "base/debug/trace_event.h"
  12 #include "base/file_util.h"
  13 #include "base/files/file_enumerator.h"
  14 #include "base/files/file_path.h"
  15 #include "base/lazy_instance.h"
  16 #include "base/memory/ref_counted.h"
  17 #include "base/message_loop/message_loop.h"
  18 #include "base/metrics/histogram.h"
  19 #include "base/platform_file.h"
  20 #include "base/posix/eintr_wrapper.h"
  21 #include "base/strings/utf_string_conversions.h"
  22 #include "base/synchronization/lock.h"
  23 #include "base/sys_info.h"
  24 #include "base/threading/platform_thread.h"
  25 #include "base/threading/thread.h"
  26 #include "chromium_logger.h"
  27 #include "env_chromium.h"
  28 #include "leveldb/env.h"
  29 #include "leveldb/slice.h"
  30 #include "port/port.h"
  31 #include "third_party/re2/re2/re2.h"
  32 #include "util/logging.h"
  33
  34 #if defined(OS_WIN)
  35 #include <io.h>
  36 #include "base/win/win_util.h"
  37 #endif
  38
  39 #if defined(OS_POSIX)
  40 #include <fcntl.h>
  41 #include <sys/resource.h>
  42 #include <sys/time.h>
  43 #endif
  44
  45 using namespace leveldb;
  46
  47 namespace leveldb_env {
  48
  49 namespace {
  50
  51 #if defined(OS_MACOSX) || defined(OS_WIN) || defined(OS_ANDROID) || \
  52     defined(OS_OPENBSD)
  53 // The following are glibc-specific
  54
  55 size_t fread_wrapper(void *ptr, size_t size, size_t n, FILE *file) {
  56   return fread(ptr, size, n, file);
  57 }
  58
  59 size_t fwrite_wrapper(const void *ptr, size_t size, size_t n, FILE *file) {
  60   return fwrite(ptr, size, n, file);
  61 }
  62
  63 int fflush_wrapper(FILE *file) {
  64   return fflush(file);
  65 }
  66
  67 #if !defined(OS_ANDROID)
  68 int fdatasync(int fildes) {
  69 #if defined(OS_WIN)
  70   return _commit(fildes);
  71 #else
  72   return HANDLE_EINTR(fsync(fildes));
  73 #endif
  74 }
  75 #endif
  76
  77 #else
  78
  79 class TryToLockFILE {
  80   // This class should be deleted if it doesn't turn up anything useful after
  81   // going to stable (chrome 29).
  82  public:
  83   TryToLockFILE(FILE* file) : file_to_unlock_(NULL) {
  84     if (ftrylockfile(file) == 0)
  85       file_to_unlock_ = file;
  86     else
  87       UMA_HISTOGRAM_BOOLEAN("LevelDBEnv.All.SafeThreadAccess", false);
  88   }
  89   ~TryToLockFILE() {
  90     if (file_to_unlock_)
  91       funlockfile(file_to_unlock_);
  92   }
  93
  94  private:
  95   FILE* file_to_unlock_;
  96 };
  97
  98 size_t fread_wrapper(void *ptr, size_t size, size_t n, FILE *file) {
  99   TryToLockFILE lock(file);
 100   return fread_unlocked(ptr, size, n, file);
 101 }
 102
 103 size_t fwrite_wrapper(const void *ptr, size_t size, size_t n, FILE *file) {
 104   TryToLockFILE lock(file);
 105   return fwrite_unlocked(ptr, size, n, file);
 106 }
 107
 108 int fflush_wrapper(FILE *file) {
 109   TryToLockFILE lock(file);
 110   return fflush_unlocked(file);
 111 }
 112
 113 #endif
 114
 115 // Wide-char safe fopen wrapper.
 116 FILE* fopen_internal(const char* fname, const char* mode) {
 117 #if defined(OS_WIN)
 118   return _wfopen(UTF8ToUTF16(fname).c_str(), ASCIIToUTF16(mode).c_str());
 119 #else
 120   return fopen(fname, mode);
 121 #endif
 122 }
 123
 124 base::FilePath CreateFilePath(const std::string& file_path) {
 125 #if defined(OS_WIN)
 126   return base::FilePath(UTF8ToUTF16(file_path));
 127 #else
 128   return base::FilePath(file_path);
 129 #endif
 130 }
 131
 132 static const base::FilePath::CharType kLevelDBTestDirectoryPrefix[]
 133     = FILE_PATH_LITERAL("leveldb-test-");
 134
 135 const char* PlatformFileErrorString(const ::base::PlatformFileError& error) {
 136   switch (error) {
 137     case ::base::PLATFORM_FILE_ERROR_FAILED:
 138       return "No further details.";
 139     case ::base::PLATFORM_FILE_ERROR_IN_USE:
 140       return "File currently in use.";
 141     case ::base::PLATFORM_FILE_ERROR_EXISTS:
 142       return "File already exists.";
 143     case ::base::PLATFORM_FILE_ERROR_NOT_FOUND:
 144       return "File not found.";
 145     case ::base::PLATFORM_FILE_ERROR_ACCESS_DENIED:
 146       return "Access denied.";
 147     case ::base::PLATFORM_FILE_ERROR_TOO_MANY_OPENED:
 148       return "Too many files open.";
 149     case ::base::PLATFORM_FILE_ERROR_NO_MEMORY:
 150       return "Out of memory.";
 151     case ::base::PLATFORM_FILE_ERROR_NO_SPACE:
 152       return "No space left on drive.";
 153     case ::base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY:
 154       return "Not a directory.";
 155     case ::base::PLATFORM_FILE_ERROR_INVALID_OPERATION:
 156       return "Invalid operation.";
 157     case ::base::PLATFORM_FILE_ERROR_SECURITY:
 158       return "Security error.";
 159     case ::base::PLATFORM_FILE_ERROR_ABORT:
 160       return "File operation aborted.";
 161     case ::base::PLATFORM_FILE_ERROR_NOT_A_FILE:
 162       return "The supplied path was not a file.";
 163     case ::base::PLATFORM_FILE_ERROR_NOT_EMPTY:
 164       return "The file was not empty.";
 165     case ::base::PLATFORM_FILE_ERROR_INVALID_URL:
 166       return "Invalid URL.";
 167     case ::base::PLATFORM_FILE_ERROR_IO:
 168       return "OS or hardware error.";
 169     case ::base::PLATFORM_FILE_OK:
 170       return "OK.";
 171     case ::base::PLATFORM_FILE_ERROR_MAX:
 172       NOTREACHED();
 173   }
 174   NOTIMPLEMENTED();
 175   return "Unknown error.";
 176 }
 177
 178 class ChromiumSequentialFile: public SequentialFile {
 179  private:
 180   std::string filename_;
 181   FILE* file_;
 182   const UMALogger* uma_logger_;
 183
 184  public:
 185   ChromiumSequentialFile(const std::string& fname, FILE* f,
 186                          const UMALogger* uma_logger)
 187       : filename_(fname), file_(f), uma_logger_(uma_logger) { }
 188   virtual ~ChromiumSequentialFile() { fclose(file_); }
 189
 190   virtual Status Read(size_t n, Slice* result, char* scratch) {
 191     Status s;
 192     size_t r = fread_wrapper(scratch, 1, n, file_);
 193     *result = Slice(scratch, r);
 194     if (r < n) {
 195       if (feof(file_)) {
 196         // We leave status as ok if we hit the end of the file
 197       } else {
 198         // A partial read with an error: return a non-ok status
 199         s = MakeIOError(filename_, strerror(errno), kSequentialFileRead, errno);
 200         uma_logger_->RecordErrorAt(kSequentialFileRead);
 201       }
 202     }
 203     return s;
 204   }
 205
 206   virtual Status Skip(uint64_t n) {
 207     if (fseek(file_, n, SEEK_CUR)) {
 208       int saved_errno = errno;
 209       uma_logger_->RecordErrorAt(kSequentialFileSkip);
 210       return MakeIOError(
 211           filename_, strerror(saved_errno), kSequentialFileSkip, saved_errno);
 212     }
 213     return Status::OK();
 214   }
 215 };
 216
 217 class ChromiumRandomAccessFile: public RandomAccessFile {
 218  private:
 219   std::string filename_;
 220   ::base::PlatformFile file_;
 221   const UMALogger* uma_logger_;
 222
 223  public:
 224   ChromiumRandomAccessFile(const std::string& fname, ::base::PlatformFile file,
 225                            const UMALogger* uma_logger)
 226       : filename_(fname), file_(file), uma_logger_(uma_logger) { }
 227   virtual ~ChromiumRandomAccessFile() { ::base::ClosePlatformFile(file_); }
 228
 229   virtual Status Read(uint64_t offset, size_t n, Slice* result,
 230                       char* scratch) const {
 231     Status s;
 232     int r = ::base::ReadPlatformFile(file_, offset, scratch, n);
 233     *result = Slice(scratch, (r < 0) ? 0 : r);
 234     if (r < 0) {
 235       // An error: return a non-ok status
 236       s = MakeIOError(
 237           filename_, "Could not perform read", kRandomAccessFileRead);
 238       uma_logger_->RecordErrorAt(kRandomAccessFileRead);
 239     }
 240     return s;
 241   }
 242 };
 243
 244 class ChromiumFileLock : public FileLock {
 245  public:
 246   ::base::PlatformFile file_;
 247 };
 248
 249 class Retrier {
 250  public:
 251   Retrier(MethodID method, RetrierProvider* provider)
 252       : start_(base::TimeTicks::Now()),
 253         limit_(start_ + base::TimeDelta::FromMilliseconds(
 254                             provider->MaxRetryTimeMillis())),
 255         last_(start_),
 256         time_to_sleep_(base::TimeDelta::FromMilliseconds(10)),
 257         success_(true),
 258         method_(method),
 259         last_error_(base::PLATFORM_FILE_OK),
 260         provider_(provider) {}
 261   ~Retrier() {
 262     if (success_) {
 263       provider_->GetRetryTimeHistogram(method_)->AddTime(last_ - start_);
 264       if (last_error_ != base::PLATFORM_FILE_OK) {
 265         DCHECK(last_error_ < 0);
 266         provider_->GetRecoveredFromErrorHistogram(method_)->Add(-last_error_);
 267       }
 268     }
 269   }
 270   bool ShouldKeepTrying(base::PlatformFileError last_error) {
 271     DCHECK_NE(last_error, base::PLATFORM_FILE_OK);
 272     last_error_ = last_error;
 273     if (last_ < limit_) {
 274       base::PlatformThread::Sleep(time_to_sleep_);
 275       last_ = base::TimeTicks::Now();
 276       return true;
 277     }
 278     success_ = false;
 279     return false;
 280   }
 281
 282  private:
 283   base::TimeTicks start_;
 284   base::TimeTicks limit_;
 285   base::TimeTicks last_;
 286   base::TimeDelta time_to_sleep_;
 287   bool success_;
 288   MethodID method_;
 289   base::PlatformFileError last_error_;
 290   RetrierProvider* provider_;
 291 };
 292
 293 class IDBEnv : public ChromiumEnv {
 294  public:
 295   IDBEnv() : ChromiumEnv() { name_ = "LevelDBEnv.IDB"; }
 296 };
 297
 298 ::base::LazyInstance<IDBEnv>::Leaky idb_env = LAZY_INSTANCE_INITIALIZER;
 299
 300 ::base::LazyInstance<ChromiumEnv>::Leaky default_env =
 301     LAZY_INSTANCE_INITIALIZER;
 302
 303 }  // unnamed namespace
 304
 305 const char* MethodIDToString(MethodID method) {
 306   switch (method) {
 307     case kSequentialFileRead:
 308       return "SequentialFileRead";
 309     case kSequentialFileSkip:
 310       return "SequentialFileSkip";
 311     case kRandomAccessFileRead:
 312       return "RandomAccessFileRead";
 313     case kWritableFileAppend:
 314       return "WritableFileAppend";
 315     case kWritableFileClose:
 316       return "WritableFileClose";
 317     case kWritableFileFlush:
 318       return "WritableFileFlush";
 319     case kWritableFileSync:
 320       return "WritableFileSync";
 321     case kNewSequentialFile:
 322       return "NewSequentialFile";
 323     case kNewRandomAccessFile:
 324       return "NewRandomAccessFile";
 325     case kNewWritableFile:
 326       return "NewWritableFile";
 327     case kDeleteFile:
 328       return "DeleteFile";
 329     case kCreateDir:
 330       return "CreateDir";
 331     case kDeleteDir:
 332       return "DeleteDir";
 333     case kGetFileSize:
 334       return "GetFileSize";
 335     case kRenameFile:
 336       return "RenameFile";
 337     case kLockFile:
 338       return "LockFile";
 339     case kUnlockFile:
 340       return "UnlockFile";
 341     case kGetTestDirectory:
 342       return "GetTestDirectory";
 343     case kNewLogger:
 344       return "NewLogger";
 345     case kSyncParent:
 346       return "SyncParent";
 347     case kNumEntries:
 348       NOTREACHED();
 349       return "kNumEntries";
 350   }
 351   NOTREACHED();
 352   return "Unknown";
 353 }
 354
 355 Status MakeIOError(Slice filename,
 356                    const char* message,
 357                    MethodID method,
 358                    int saved_errno) {
 359   char buf[512];
 360   snprintf(buf,
 361            sizeof(buf),
 362            "%s (ChromeMethodErrno: %d::%s::%d)",
 363            message,
 364            method,
 365            MethodIDToString(method),
 366            saved_errno);
 367   return Status::IOError(filename, buf);
 368 }
 369
 370 Status MakeIOError(Slice filename,
 371                    const char* message,
 372                    MethodID method,
 373                    base::PlatformFileError error) {
 374   DCHECK(error < 0);
 375   char buf[512];
 376   snprintf(buf,
 377            sizeof(buf),
 378            "%s (ChromeMethodPFE: %d::%s::%d)",
 379            message,
 380            method,
 381            MethodIDToString(method),
 382            -error);
 383   return Status::IOError(filename, buf);
 384 }
 385
 386 Status MakeIOError(Slice filename, const char* message, MethodID method) {
 387   char buf[512];
 388   snprintf(buf,
 389            sizeof(buf),
 390            "%s (ChromeMethodOnly: %d::%s)",
 391            message,
 392            method,
 393            MethodIDToString(method));
 394   return Status::IOError(filename, buf);
 395 }
 396
 397 ErrorParsingResult ParseMethodAndError(const char* string,
 398                                        MethodID* method_param,
 399                                        int* error) {
 400   int method;
 401   if (RE2::PartialMatch(string, "ChromeMethodOnly: (\\d+)", &method)) {
 402     *method_param = static_cast<MethodID>(method);
 403     return METHOD_ONLY;
 404   }
 405   if (RE2::PartialMatch(
 406           string, "ChromeMethodPFE: (\\d+)::.*::(\\d+)", &method, error)) {
 407     *error = -*error;
 408     *method_param = static_cast<MethodID>(method);
 409     return METHOD_AND_PFE;
 410   }
 411   if (RE2::PartialMatch(
 412           string, "ChromeMethodErrno: (\\d+)::.*::(\\d+)", &method, error)) {
 413     *method_param = static_cast<MethodID>(method);
 414     return METHOD_AND_ERRNO;
 415   }
 416   return NONE;
 417 }
 418
 419 std::string FilePathToString(const base::FilePath& file_path) {
 420 #if defined(OS_WIN)
 421   return UTF16ToUTF8(file_path.value());
 422 #else
 423   return file_path.value();
 424 #endif
 425 }
 426
 427 ChromiumWritableFile::ChromiumWritableFile(const std::string& fname,
 428                                            FILE* f,
 429                                            const UMALogger* uma_logger,
 430                                            WriteTracker* tracker)
 431     : filename_(fname), file_(f), uma_logger_(uma_logger), tracker_(tracker) {
 432   base::FilePath path = base::FilePath::FromUTF8Unsafe(fname);
 433   is_manifest_ =
 434       FilePathToString(path.BaseName()).find("MANIFEST") !=
 435       std::string::npos;
 436   if (!is_manifest_)
 437     tracker_->DidCreateNewFile(filename_);
 438   parent_dir_ = FilePathToString(CreateFilePath(fname).DirName());
 439 }
 440
 441 ChromiumWritableFile::~ChromiumWritableFile() {
 442   if (file_ != NULL) {
 443     // Ignoring any potential errors
 444     fclose(file_);
 445   }
 446 }
 447
 448 Status ChromiumWritableFile::SyncParent() {
 449   Status s;
 450 #if !defined(OS_WIN)
 451   TRACE_EVENT0("leveldb", "SyncParent");
 452
 453   int parent_fd =
 454       HANDLE_EINTR(open(parent_dir_.c_str(), O_RDONLY));
 455   if (parent_fd < 0)
 456     return MakeIOError(parent_dir_, strerror(errno), kSyncParent);
 457   if (HANDLE_EINTR(fsync(parent_fd)) != 0) {
 458     s = MakeIOError(parent_dir_, strerror(errno), kSyncParent);
 459   };
 460   HANDLE_EINTR(close(parent_fd));
 461 #endif
 462   return s;
 463 }
 464
 465 Status ChromiumWritableFile::Append(const Slice& data) {
 466   if (is_manifest_ && tracker_->DoesDirNeedSync(filename_)) {
 467     Status s = SyncParent();
 468     if (!s.ok())
 469       return s;
 470     tracker_->DidSyncDir(filename_);
 471   }
 472
 473   size_t r = fwrite_wrapper(data.data(), 1, data.size(), file_);
 474   if (r != data.size()) {
 475     int saved_errno = errno;
 476     uma_logger_->RecordOSError(kWritableFileAppend, saved_errno);
 477     return MakeIOError(
 478         filename_, strerror(saved_errno), kWritableFileAppend, saved_errno);
 479   }
 480   return Status::OK();
 481 }
 482
 483 Status ChromiumWritableFile::Close() {
 484   Status result;
 485   if (fclose(file_) != 0) {
 486     result = MakeIOError(filename_, strerror(errno), kWritableFileClose, errno);
 487     uma_logger_->RecordErrorAt(kWritableFileClose);
 488   }
 489   file_ = NULL;
 490   return result;
 491 }
 492
 493 Status ChromiumWritableFile::Flush() {
 494   Status result;
 495   if (HANDLE_EINTR(fflush_wrapper(file_))) {
 496     int saved_errno = errno;
 497     result = MakeIOError(
 498         filename_, strerror(saved_errno), kWritableFileFlush, saved_errno);
 499     uma_logger_->RecordOSError(kWritableFileFlush, saved_errno);
 500   }
 501   return result;
 502 }
 503
 504 Status ChromiumWritableFile::Sync() {
 505   TRACE_EVENT0("leveldb", "ChromiumEnv::Sync");
 506   Status result;
 507   int error = 0;
 508
 509   if (HANDLE_EINTR(fflush_wrapper(file_)))
 510     error = errno;
 511   // Sync even if fflush gave an error; perhaps the data actually got out,
 512   // even though something went wrong.
 513   if (fdatasync(fileno(file_)) && !error)
 514     error = errno;
 515   // Report the first error we found.
 516   if (error) {
 517     result = MakeIOError(filename_, strerror(error), kWritableFileSync, error);
 518     uma_logger_->RecordErrorAt(kWritableFileSync);
 519   }
 520   return result;
 521 }
 522
 523 ChromiumEnv::ChromiumEnv()
 524     : name_("LevelDBEnv"),
 525       bgsignal_(&mu_),
 526       started_bgthread_(false),
 527       kMaxRetryTimeMillis(1000) {
 528 }
 529
 530 ChromiumEnv::~ChromiumEnv() {
 531   // In chromium, ChromiumEnv is leaked. It'd be nice to add NOTREACHED here to
 532   // ensure that behavior isn't accidentally changed, but there's an instance in
 533   // a unit test that is deleted.
 534 }
 535
 536 Status ChromiumEnv::NewSequentialFile(const std::string& fname,
 537                                       SequentialFile** result) {
 538   FILE* f = fopen_internal(fname.c_str(), "rb");
 539   if (f == NULL) {
 540     *result = NULL;
 541     int saved_errno = errno;
 542     RecordOSError(kNewSequentialFile, saved_errno);
 543     return MakeIOError(
 544         fname, strerror(saved_errno), kNewSequentialFile, saved_errno);
 545   } else {
 546     *result = new ChromiumSequentialFile(fname, f, this);
 547     return Status::OK();
 548   }
 549 }
 550
 551 void ChromiumEnv::RecordOpenFilesLimit(const std::string& type) {
 552 #if defined(OS_POSIX)
 553   struct rlimit nofile;
 554   if (getrlimit(RLIMIT_NOFILE, &nofile))
 555     return;
 556   GetMaxFDHistogram(type)->Add(nofile.rlim_cur);
 557 #endif
 558 }
 559
 560 Status ChromiumEnv::NewRandomAccessFile(const std::string& fname,
 561                                         RandomAccessFile** result) {
 562   int flags = ::base::PLATFORM_FILE_READ | ::base::PLATFORM_FILE_OPEN;
 563   bool created;
 564   ::base::PlatformFileError error_code;
 565   ::base::PlatformFile file = ::base::CreatePlatformFile(
 566       CreateFilePath(fname), flags, &created, &error_code);
 567   if (error_code == ::base::PLATFORM_FILE_OK) {
 568     *result = new ChromiumRandomAccessFile(fname, file, this);
 569     RecordOpenFilesLimit("Success");
 570     return Status::OK();
 571   }
 572   if (error_code == ::base::PLATFORM_FILE_ERROR_TOO_MANY_OPENED)
 573     RecordOpenFilesLimit("TooManyOpened");
 574   else
 575     RecordOpenFilesLimit("OtherError");
 576   *result = NULL;
 577   RecordOSError(kNewRandomAccessFile, error_code);
 578   return MakeIOError(fname,
 579                      PlatformFileErrorString(error_code),
 580                      kNewRandomAccessFile,
 581                      error_code);
 582 }
 583
 584 Status ChromiumEnv::NewWritableFile(const std::string& fname,
 585                                     WritableFile** result) {
 586   *result = NULL;
 587   FILE* f = fopen_internal(fname.c_str(), "wb");
 588   if (f == NULL) {
 589     int saved_errno = errno;
 590     RecordErrorAt(kNewWritableFile);
 591     return MakeIOError(
 592         fname, strerror(saved_errno), kNewWritableFile, saved_errno);
 593   } else {
 594     *result = new ChromiumWritableFile(fname, f, this, this);
 595     return Status::OK();
 596   }
 597 }
 598
 599 bool ChromiumEnv::FileExists(const std::string& fname) {
 600   return ::base::PathExists(CreateFilePath(fname));
 601 }
 602
 603 Status ChromiumEnv::GetChildren(const std::string& dir,
 604                                 std::vector<std::string>* result) {
 605   result->clear();
 606   base::FileEnumerator iter(
 607       CreateFilePath(dir), false, base::FileEnumerator::FILES);
 608   base::FilePath current = iter.Next();
 609   while (!current.empty()) {
 610     result->push_back(FilePathToString(current.BaseName()));
 611     current = iter.Next();
 612   }
 613   // TODO(jorlow): Unfortunately, the FileEnumerator swallows errors, so
 614   //               we'll always return OK. Maybe manually check for error
 615   //               conditions like the file not existing?
 616   return Status::OK();
 617 }
 618
 619 Status ChromiumEnv::DeleteFile(const std::string& fname) {
 620   Status result;
 621   // TODO(jorlow): Should we assert this is a file?
 622   if (!::base::DeleteFile(CreateFilePath(fname), false)) {
 623     result = MakeIOError(fname, "Could not delete file.", kDeleteFile);
 624     RecordErrorAt(kDeleteFile);
 625   }
 626   return result;
 627 }
 628
 629 Status ChromiumEnv::CreateDir(const std::string& name) {
 630   Status result;
 631   base::PlatformFileError error = base::PLATFORM_FILE_OK;
 632   Retrier retrier(kCreateDir, this);
 633   do {
 634     if (::file_util::CreateDirectoryAndGetError(CreateFilePath(name), &error))
 635       return result;
 636   } while (retrier.ShouldKeepTrying(error));
 637   result = MakeIOError(name, "Could not create directory.", kCreateDir, error);
 638   RecordOSError(kCreateDir, error);
 639   return result;
 640 }
 641
 642 Status ChromiumEnv::DeleteDir(const std::string& name) {
 643   Status result;
 644   // TODO(jorlow): Should we assert this is a directory?
 645   if (!::base::DeleteFile(CreateFilePath(name), false)) {
 646     result = MakeIOError(name, "Could not delete directory.", kDeleteDir);
 647     RecordErrorAt(kDeleteDir);
 648   }
 649   return result;
 650 }
 651
 652 Status ChromiumEnv::GetFileSize(const std::string& fname, uint64_t* size) {
 653   Status s;
 654   int64_t signed_size;
 655   if (!::file_util::GetFileSize(CreateFilePath(fname), &signed_size)) {
 656     *size = 0;
 657     s = MakeIOError(fname, "Could not determine file size.", kGetFileSize);
 658     RecordErrorAt(kGetFileSize);
 659   } else {
 660     *size = static_cast<uint64_t>(signed_size);
 661   }
 662   return s;
 663 }
 664
 665 Status ChromiumEnv::RenameFile(const std::string& src, const std::string& dst) {
 666   Status result;
 667   base::FilePath src_file_path = CreateFilePath(src);
 668   if (!::base::PathExists(src_file_path))
 669     return result;
 670   base::FilePath destination = CreateFilePath(dst);
 671
 672   Retrier retrier(kRenameFile, this);
 673   base::PlatformFileError error = base::PLATFORM_FILE_OK;
 674   do {
 675     if (base::ReplaceFile(src_file_path, destination, &error))
 676       return result;
 677   } while (retrier.ShouldKeepTrying(error));
 678
 679   DCHECK(error != base::PLATFORM_FILE_OK);
 680   RecordOSError(kRenameFile, error);
 681   char buf[100];
 682   snprintf(buf,
 683            sizeof(buf),
 684            "Could not rename file: %s",
 685            PlatformFileErrorString(error));
 686   return MakeIOError(src, buf, kRenameFile, error);
 687 }
 688
 689 Status ChromiumEnv::LockFile(const std::string& fname, FileLock** lock) {
 690   *lock = NULL;
 691   Status result;
 692   int flags = ::base::PLATFORM_FILE_OPEN_ALWAYS |
 693               ::base::PLATFORM_FILE_READ |
 694               ::base::PLATFORM_FILE_WRITE |
 695               ::base::PLATFORM_FILE_EXCLUSIVE_READ |
 696               ::base::PLATFORM_FILE_EXCLUSIVE_WRITE;
 697   bool created;
 698   ::base::PlatformFileError error_code;
 699   ::base::PlatformFile file;
 700   Retrier retrier(kLockFile, this);
 701   do {
 702     file = ::base::CreatePlatformFile(
 703         CreateFilePath(fname), flags, &created, &error_code);
 704   } while (error_code != ::base::PLATFORM_FILE_OK &&
 705            retrier.ShouldKeepTrying(error_code));
 706
 707   if (error_code == ::base::PLATFORM_FILE_ERROR_NOT_FOUND) {
 708     ::base::FilePath parent = CreateFilePath(fname).DirName();
 709     ::base::FilePath last_parent;
 710     int num_missing_ancestors = 0;
 711     do {
 712       if (base::DirectoryExists(parent))
 713         break;
 714       ++num_missing_ancestors;
 715       last_parent = parent;
 716       parent = parent.DirName();
 717     } while (parent != last_parent);
 718     RecordLockFileAncestors(num_missing_ancestors);
 719   }
 720
 721   if (error_code != ::base::PLATFORM_FILE_OK) {
 722     result = MakeIOError(
 723         fname, PlatformFileErrorString(error_code), kLockFile, error_code);
 724     RecordOSError(kLockFile, error_code);
 725   } else {
 726     ChromiumFileLock* my_lock = new ChromiumFileLock;
 727     my_lock->file_ = file;
 728     *lock = my_lock;
 729   }
 730   return result;
 731 }
 732
 733 Status ChromiumEnv::UnlockFile(FileLock* lock) {
 734   ChromiumFileLock* my_lock = reinterpret_cast<ChromiumFileLock*>(lock);
 735   Status result;
 736   if (!::base::ClosePlatformFile(my_lock->file_)) {
 737     result = MakeIOError("Could not close lock file.", "", kUnlockFile);
 738     RecordErrorAt(kUnlockFile);
 739   }
 740   delete my_lock;
 741   return result;
 742 }
 743
 744 Status ChromiumEnv::GetTestDirectory(std::string* path) {
 745   mu_.Acquire();
 746   if (test_directory_.empty()) {
 747     if (!::file_util::CreateNewTempDirectory(kLevelDBTestDirectoryPrefix,
 748                                              &test_directory_)) {
 749       mu_.Release();
 750       RecordErrorAt(kGetTestDirectory);
 751       return MakeIOError(
 752           "Could not create temp directory.", "", kGetTestDirectory);
 753     }
 754   }
 755   *path = FilePathToString(test_directory_);
 756   mu_.Release();
 757   return Status::OK();
 758 }
 759
 760 Status ChromiumEnv::NewLogger(const std::string& fname, Logger** result) {
 761   FILE* f = fopen_internal(fname.c_str(), "w");
 762   if (f == NULL) {
 763     *result = NULL;
 764     int saved_errno = errno;
 765     RecordOSError(kNewLogger, saved_errno);
 766     return MakeIOError(fname, strerror(saved_errno), kNewLogger, saved_errno);
 767   } else {
 768     *result = new ChromiumLogger(f);
 769     return Status::OK();
 770   }
 771 }
 772
 773 uint64_t ChromiumEnv::NowMicros() {
 774   return ::base::TimeTicks::Now().ToInternalValue();
 775 }
 776
 777 void ChromiumEnv::SleepForMicroseconds(int micros) {
 778   // Round up to the next millisecond.
 779   ::base::PlatformThread::Sleep(::base::TimeDelta::FromMicroseconds(micros));
 780 }
 781
 782 void ChromiumEnv::RecordErrorAt(MethodID method) const {
 783   GetMethodIOErrorHistogram()->Add(method);
 784 }
 785
 786 void ChromiumEnv::RecordLockFileAncestors(int num_missing_ancestors) const {
 787   GetLockFileAncestorHistogram()->Add(num_missing_ancestors);
 788 }
 789
 790 void ChromiumEnv::RecordOSError(MethodID method,
 791                                 base::PlatformFileError error) const {
 792   DCHECK(error < 0);
 793   RecordErrorAt(method);
 794   GetOSErrorHistogram(method, -base::PLATFORM_FILE_ERROR_MAX)->Add(-error);
 795 }
 796
 797 void ChromiumEnv::RecordOSError(MethodID method, int error) const {
 798   DCHECK(error > 0);
 799   RecordErrorAt(method);
 800   GetOSErrorHistogram(method, ERANGE + 1)->Add(error);
 801 }
 802
 803 base::HistogramBase* ChromiumEnv::GetOSErrorHistogram(MethodID method,
 804                                                       int limit) const {
 805   std::string uma_name(name_);
 806   // TODO(dgrogan): This is probably not the best way to concatenate strings.
 807   uma_name.append(".IOError.").append(MethodIDToString(method));
 808   return base::LinearHistogram::FactoryGet(uma_name, 1, limit, limit + 1,
 809       base::Histogram::kUmaTargetedHistogramFlag);
 810 }
 811
 812 base::HistogramBase* ChromiumEnv::GetMethodIOErrorHistogram() const {
 813   std::string uma_name(name_);
 814   uma_name.append(".IOError");
 815   return base::LinearHistogram::FactoryGet(uma_name, 1, kNumEntries,
 816       kNumEntries + 1, base::Histogram::kUmaTargetedHistogramFlag);
 817 }
 818
 819 base::HistogramBase* ChromiumEnv::GetMaxFDHistogram(
 820     const std::string& type) const {
 821   std::string uma_name(name_);
 822   uma_name.append(".MaxFDs.").append(type);
 823   // These numbers make each bucket twice as large as the previous bucket.
 824   const int kFirstEntry = 1;
 825   const int kLastEntry = 65536;
 826   const int kNumBuckets = 18;
 827   return base::Histogram::FactoryGet(
 828       uma_name, kFirstEntry, kLastEntry, kNumBuckets,
 829       base::Histogram::kUmaTargetedHistogramFlag);
 830 }
 831
 832 base::HistogramBase* ChromiumEnv::GetLockFileAncestorHistogram() const {
 833   std::string uma_name(name_);
 834   uma_name.append(".LockFileAncestorsNotFound");
 835   const int kMin = 1;
 836   const int kMax = 10;
 837   const int kNumBuckets = 11;
 838   return base::LinearHistogram::FactoryGet(
 839       uma_name, kMin, kMax, kNumBuckets,
 840       base::Histogram::kUmaTargetedHistogramFlag);
 841 }
 842
 843 base::HistogramBase* ChromiumEnv::GetRetryTimeHistogram(MethodID method) const {
 844   std::string uma_name(name_);
 845   // TODO(dgrogan): This is probably not the best way to concatenate strings.
 846   uma_name.append(".TimeUntilSuccessFor").append(MethodIDToString(method));
 847
 848   const int kBucketSizeMillis = 25;
 849   // Add 2, 1 for each of the buckets <1 and >max.
 850   const int kNumBuckets = kMaxRetryTimeMillis / kBucketSizeMillis + 2;
 851   return base::Histogram::FactoryTimeGet(
 852       uma_name, base::TimeDelta::FromMilliseconds(1),
 853       base::TimeDelta::FromMilliseconds(kMaxRetryTimeMillis + 1),
 854       kNumBuckets,
 855       base::Histogram::kUmaTargetedHistogramFlag);
 856 }
 857
 858 base::HistogramBase* ChromiumEnv::GetRecoveredFromErrorHistogram(
 859     MethodID method) const {
 860   std::string uma_name(name_);
 861   uma_name.append(".RetryRecoveredFromErrorIn")
 862       .append(MethodIDToString(method));
 863   return base::LinearHistogram::FactoryGet(uma_name, 1, kNumEntries,
 864       kNumEntries + 1, base::Histogram::kUmaTargetedHistogramFlag);
 865 }
 866
 867 class Thread : public ::base::PlatformThread::Delegate {
 868  public:
 869   Thread(void (*function)(void* arg), void* arg)
 870       : function_(function), arg_(arg) {
 871     ::base::PlatformThreadHandle handle;
 872     bool success = ::base::PlatformThread::Create(0, this, &handle);
 873     DCHECK(success);
 874   }
 875   virtual ~Thread() {}
 876   virtual void ThreadMain() {
 877     (*function_)(arg_);
 878     delete this;
 879   }
 880
 881  private:
 882   void (*function_)(void* arg);
 883   void* arg_;
 884 };
 885
 886 void ChromiumEnv::Schedule(void (*function)(void*), void* arg) {
 887   mu_.Acquire();
 888
 889   // Start background thread if necessary
 890   if (!started_bgthread_) {
 891     started_bgthread_ = true;
 892     StartThread(&ChromiumEnv::BGThreadWrapper, this);
 893   }
 894
 895   // If the queue is currently empty, the background thread may currently be
 896   // waiting.
 897   if (queue_.empty()) {
 898     bgsignal_.Signal();
 899   }
 900
 901   // Add to priority queue
 902   queue_.push_back(BGItem());
 903   queue_.back().function = function;
 904   queue_.back().arg = arg;
 905
 906   mu_.Release();
 907 }
 908
 909 void ChromiumEnv::BGThread() {
 910   base::PlatformThread::SetName(name_.c_str());
 911
 912   while (true) {
 913     // Wait until there is an item that is ready to run
 914     mu_.Acquire();
 915     while (queue_.empty()) {
 916       bgsignal_.Wait();
 917     }
 918
 919     void (*function)(void*) = queue_.front().function;
 920     void* arg = queue_.front().arg;
 921     queue_.pop_front();
 922
 923     mu_.Release();
 924     TRACE_EVENT0("leveldb", "ChromiumEnv::BGThread-Task");
 925     (*function)(arg);
 926   }
 927 }
 928
 929 void ChromiumEnv::StartThread(void (*function)(void* arg), void* arg) {
 930   new Thread(function, arg); // Will self-delete.
 931 }
 932
 933 static std::string GetDirName(const std::string& filename) {
 934   base::FilePath file = base::FilePath::FromUTF8Unsafe(filename);
 935   return FilePathToString(file.DirName());
 936 }
 937
 938 void ChromiumEnv::DidCreateNewFile(const std::string& filename) {
 939   base::AutoLock auto_lock(map_lock_);
 940   needs_sync_map_[GetDirName(filename)] = true;
 941 }
 942
 943 bool ChromiumEnv::DoesDirNeedSync(const std::string& filename) {
 944   base::AutoLock auto_lock(map_lock_);
 945   return needs_sync_map_.find(GetDirName(filename)) != needs_sync_map_.end();
 946 }
 947
 948 void ChromiumEnv::DidSyncDir(const std::string& filename) {
 949   base::AutoLock auto_lock(map_lock_);
 950   needs_sync_map_.erase(GetDirName(filename));
 951 }
 952
 953 }  // namespace leveldb_env
 954
 955 namespace leveldb {
 956
 957 Env* IDBEnv() {
 958   return leveldb_env::idb_env.Pointer();
 959 }
 960
 961 Env* Env::Default() {
 962   return leveldb_env::default_env.Pointer();
 963 }
 964
 965 }  // namespace leveldb
 966