Home | History | Annotate | Download | only in leveldatabase 
      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 "third_party/leveldatabase/env_chromium.h"
      6 
      7 #if defined(OS_WIN)
      8 #include <io.h>
      9 #endif
     10 
     11 #include "base/debug/trace_event.h"
     12 #include "base/files/file_util.h"
     13 #include "base/lazy_instance.h"
     14 #include "base/metrics/histogram.h"
     15 #include "base/strings/utf_string_conversions.h"
     16 #include "third_party/leveldatabase/env_chromium_stdio.h"
     17 #include "third_party/re2/re2/re2.h"
     18 
     19 #if defined(OS_WIN)
     20 #include "base/command_line.h"
     21 #include "base/win/win_util.h"
     22 #include "third_party/leveldatabase/env_chromium_win.h"
     23 #endif
     24 
     25 using leveldb::FileLock;
     26 using leveldb::Slice;
     27 using leveldb::Status;
     28 
     29 namespace leveldb_env {
     30 
     31 namespace {
     32 
     33 const base::FilePath::CharType backup_table_extension[] =
     34     FILE_PATH_LITERAL(".bak");
     35 const base::FilePath::CharType table_extension[] = FILE_PATH_LITERAL(".ldb");
     36 
     37 static const base::FilePath::CharType kLevelDBTestDirectoryPrefix[]
     38     = FILE_PATH_LITERAL("leveldb-test-");
     39 
     40 class ChromiumFileLock : public FileLock {
     41  public:
     42   ::base::File file_;
     43   std::string name_;
     44 };
     45 
     46 class Retrier {
     47  public:
     48   Retrier(MethodID method, RetrierProvider* provider)
     49       : start_(base::TimeTicks::Now()),
     50         limit_(start_ + base::TimeDelta::FromMilliseconds(
     51                             provider->MaxRetryTimeMillis())),
     52         last_(start_),
     53         time_to_sleep_(base::TimeDelta::FromMilliseconds(10)),
     54         success_(true),
     55         method_(method),
     56         last_error_(base::File::FILE_OK),
     57         provider_(provider) {}
     58   ~Retrier() {
     59     if (success_) {
     60       provider_->GetRetryTimeHistogram(method_)->AddTime(last_ - start_);
     61       if (last_error_ != base::File::FILE_OK) {
     62         DCHECK_LT(last_error_, 0);
     63         provider_->GetRecoveredFromErrorHistogram(method_)->Add(-last_error_);
     64       }
     65     }
     66   }
     67   bool ShouldKeepTrying(base::File::Error last_error) {
     68     DCHECK_NE(last_error, base::File::FILE_OK);
     69     last_error_ = last_error;
     70     if (last_ < limit_) {
     71       base::PlatformThread::Sleep(time_to_sleep_);
     72       last_ = base::TimeTicks::Now();
     73       return true;
     74     }
     75     success_ = false;
     76     return false;
     77   }
     78 
     79  private:
     80   base::TimeTicks start_;
     81   base::TimeTicks limit_;
     82   base::TimeTicks last_;
     83   base::TimeDelta time_to_sleep_;
     84   bool success_;
     85   MethodID method_;
     86   base::File::Error last_error_;
     87   RetrierProvider* provider_;
     88 };
     89 
     90 class IDBEnvStdio : public ChromiumEnvStdio {
     91  public:
     92   IDBEnvStdio() : ChromiumEnvStdio() {
     93     name_ = "LevelDBEnv.IDB";
     94     make_backup_ = true;
     95   }
     96 };
     97 
     98 #if defined(OS_WIN)
     99 class IDBEnvWin : public ChromiumEnvWin {
    100  public:
    101   IDBEnvWin() : ChromiumEnvWin() {
    102     name_ = "LevelDBEnv.IDB";
    103     make_backup_ = true;
    104   }
    105 };
    106 #endif
    107 
    108 #if defined(OS_WIN)
    109 ::base::LazyInstance<IDBEnvWin>::Leaky idb_env =
    110     LAZY_INSTANCE_INITIALIZER;
    111 #else
    112 ::base::LazyInstance<IDBEnvStdio>::Leaky idb_env =
    113     LAZY_INSTANCE_INITIALIZER;
    114 #endif
    115 
    116 ::base::LazyInstance<ChromiumEnvStdio>::Leaky default_env =
    117     LAZY_INSTANCE_INITIALIZER;
    118 
    119 }  // unnamed namespace
    120 
    121 const char* MethodIDToString(MethodID method) {
    122   switch (method) {
    123     case kSequentialFileRead:
    124       return "SequentialFileRead";
    125     case kSequentialFileSkip:
    126       return "SequentialFileSkip";
    127     case kRandomAccessFileRead:
    128       return "RandomAccessFileRead";
    129     case kWritableFileAppend:
    130       return "WritableFileAppend";
    131     case kWritableFileClose:
    132       return "WritableFileClose";
    133     case kWritableFileFlush:
    134       return "WritableFileFlush";
    135     case kWritableFileSync:
    136       return "WritableFileSync";
    137     case kNewSequentialFile:
    138       return "NewSequentialFile";
    139     case kNewRandomAccessFile:
    140       return "NewRandomAccessFile";
    141     case kNewWritableFile:
    142       return "NewWritableFile";
    143     case kDeleteFile:
    144       return "DeleteFile";
    145     case kCreateDir:
    146       return "CreateDir";
    147     case kDeleteDir:
    148       return "DeleteDir";
    149     case kGetFileSize:
    150       return "GetFileSize";
    151     case kRenameFile:
    152       return "RenameFile";
    153     case kLockFile:
    154       return "LockFile";
    155     case kUnlockFile:
    156       return "UnlockFile";
    157     case kGetTestDirectory:
    158       return "GetTestDirectory";
    159     case kNewLogger:
    160       return "NewLogger";
    161     case kSyncParent:
    162       return "SyncParent";
    163     case kGetChildren:
    164       return "GetChildren";
    165     case kNumEntries:
    166       NOTREACHED();
    167       return "kNumEntries";
    168   }
    169   NOTREACHED();
    170   return "Unknown";
    171 }
    172 
    173 Status MakeIOError(Slice filename,
    174                    const char* message,
    175                    MethodID method,
    176                    int saved_errno) {
    177   char buf[512];
    178   snprintf(buf,
    179            sizeof(buf),
    180            "%s (ChromeMethodErrno: %d::%s::%d)",
    181            message,
    182            method,
    183            MethodIDToString(method),
    184            saved_errno);
    185   return Status::IOError(filename, buf);
    186 }
    187 
    188 Status MakeIOError(Slice filename,
    189                    const char* message,
    190                    MethodID method,
    191                    base::File::Error error) {
    192   DCHECK_LT(error, 0);
    193   char buf[512];
    194   snprintf(buf,
    195            sizeof(buf),
    196            "%s (ChromeMethodPFE: %d::%s::%d)",
    197            message,
    198            method,
    199            MethodIDToString(method),
    200            -error);
    201   return Status::IOError(filename, buf);
    202 }
    203 
    204 Status MakeIOError(Slice filename, const char* message, MethodID method) {
    205   char buf[512];
    206   snprintf(buf,
    207            sizeof(buf),
    208            "%s (ChromeMethodOnly: %d::%s)",
    209            message,
    210            method,
    211            MethodIDToString(method));
    212   return Status::IOError(filename, buf);
    213 }
    214 
    215 ErrorParsingResult ParseMethodAndError(const char* string,
    216                                        MethodID* method_param,
    217                                        int* error) {
    218   int method;
    219   if (RE2::PartialMatch(string, "ChromeMethodOnly: (\\d+)", &method)) {
    220     *method_param = static_cast<MethodID>(method);
    221     return METHOD_ONLY;
    222   }
    223   if (RE2::PartialMatch(
    224           string, "ChromeMethodPFE: (\\d+)::.*::(\\d+)", &method, error)) {
    225     *error = -*error;
    226     *method_param = static_cast<MethodID>(method);
    227     return METHOD_AND_PFE;
    228   }
    229   if (RE2::PartialMatch(
    230           string, "ChromeMethodErrno: (\\d+)::.*::(\\d+)", &method, error)) {
    231     *method_param = static_cast<MethodID>(method);
    232     return METHOD_AND_ERRNO;
    233   }
    234   return NONE;
    235 }
    236 
    237 // Keep in sync with LevelDBCorruptionTypes in histograms.xml. Also, don't
    238 // change the order because indices into this array have been recorded in uma
    239 // histograms.
    240 const char* patterns[] = {
    241   "missing files",
    242   "log record too small",
    243   "corrupted internal key",
    244   "partial record",
    245   "missing start of fragmented record",
    246   "error in middle of record",
    247   "unknown record type",
    248   "truncated record at end",
    249   "bad record length",
    250   "VersionEdit",
    251   "FileReader invoked with unexpected value",
    252   "corrupted key",
    253   "CURRENT file does not end with newline",
    254   "no meta-nextfile entry",
    255   "no meta-lognumber entry",
    256   "no last-sequence-number entry",
    257   "malformed WriteBatch",
    258   "bad WriteBatch Put",
    259   "bad WriteBatch Delete",
    260   "unknown WriteBatch tag",
    261   "WriteBatch has wrong count",
    262   "bad entry in block",
    263   "bad block contents",
    264   "bad block handle",
    265   "truncated block read",
    266   "block checksum mismatch",
    267   "checksum mismatch",
    268   "corrupted compressed block contents",
    269   "bad block type",
    270   "bad magic number",
    271   "file is too short",
    272 };
    273 
    274 // Returns 1-based index into the above array or 0 if nothing matches.
    275 int GetCorruptionCode(const leveldb::Status& status) {
    276   DCHECK(!status.IsIOError());
    277   DCHECK(!status.ok());
    278   const int kOtherError = 0;
    279   int error = kOtherError;
    280   const std::string& str_error = status.ToString();
    281   const size_t kNumPatterns = arraysize(patterns);
    282   for (size_t i = 0; i < kNumPatterns; ++i) {
    283     if (str_error.find(patterns[i]) != std::string::npos) {
    284       error = i + 1;
    285       break;
    286     }
    287   }
    288   return error;
    289 }
    290 
    291 int GetNumCorruptionCodes() {
    292   // + 1 for the "other" error that is returned when a corruption message
    293   // doesn't match any of the patterns.
    294   return arraysize(patterns) + 1;
    295 }
    296 
    297 std::string GetCorruptionMessage(const leveldb::Status& status) {
    298   int code = GetCorruptionCode(status);
    299   if (code == 0)
    300     return "Unknown corruption";
    301   return patterns[code - 1];
    302 }
    303 
    304 bool IndicatesDiskFull(const leveldb::Status& status) {
    305   if (status.ok())
    306     return false;
    307   leveldb_env::MethodID method;
    308   int error = -1;
    309   leveldb_env::ErrorParsingResult result = leveldb_env::ParseMethodAndError(
    310       status.ToString().c_str(), &method, &error);
    311   return (result == leveldb_env::METHOD_AND_PFE &&
    312           static_cast<base::File::Error>(error) ==
    313               base::File::FILE_ERROR_NO_SPACE) ||
    314          (result == leveldb_env::METHOD_AND_ERRNO && error == ENOSPC);
    315 }
    316 
    317 bool IsIOError(const leveldb::Status& status) {
    318   leveldb_env::MethodID method;
    319   int error = -1;
    320   leveldb_env::ErrorParsingResult result = leveldb_env::ParseMethodAndError(
    321       status.ToString().c_str(), &method, &error);
    322   return result != leveldb_env::NONE;
    323 }
    324 
    325 bool IsCorruption(const leveldb::Status& status) {
    326   // LevelDB returns InvalidArgument when an sst file is truncated but there is
    327   // no IsInvalidArgument() accessor defined.
    328   return status.IsCorruption() || (!status.ok() && !IsIOError(status));
    329 }
    330 
    331 std::string FilePathToString(const base::FilePath& file_path) {
    332 #if defined(OS_WIN)
    333   return base::UTF16ToUTF8(file_path.value());
    334 #else
    335   return file_path.value();
    336 #endif
    337 }
    338 
    339 base::FilePath ChromiumEnv::CreateFilePath(const std::string& file_path) {
    340 #if defined(OS_WIN)
    341   return base::FilePath(base::UTF8ToUTF16(file_path));
    342 #else
    343   return base::FilePath(file_path);
    344 #endif
    345 }
    346 
    347 bool ChromiumEnv::MakeBackup(const std::string& fname) {
    348   base::FilePath original_table_name = CreateFilePath(fname);
    349   base::FilePath backup_table_name =
    350       original_table_name.ReplaceExtension(backup_table_extension);
    351   return base::CopyFile(original_table_name, backup_table_name);
    352 }
    353 
    354 bool ChromiumEnv::HasTableExtension(const base::FilePath& path) {
    355   return path.MatchesExtension(table_extension);
    356 }
    357 
    358 ChromiumEnv::ChromiumEnv()
    359     : name_("LevelDBEnv"),
    360       make_backup_(false),
    361       bgsignal_(&mu_),
    362       started_bgthread_(false),
    363       kMaxRetryTimeMillis(1000) {
    364 }
    365 
    366 ChromiumEnv::~ChromiumEnv() {
    367   // In chromium, ChromiumEnv is leaked. It'd be nice to add NOTREACHED here to
    368   // ensure that behavior isn't accidentally changed, but there's an instance in
    369   // a unit test that is deleted.
    370 }
    371 
    372 bool ChromiumEnv::FileExists(const std::string& fname) {
    373   return ::base::PathExists(CreateFilePath(fname));
    374 }
    375 
    376 const char* ChromiumEnv::FileErrorString(::base::File::Error error) {
    377   switch (error) {
    378     case ::base::File::FILE_ERROR_FAILED:
    379       return "No further details.";
    380     case ::base::File::FILE_ERROR_IN_USE:
    381       return "File currently in use.";
    382     case ::base::File::FILE_ERROR_EXISTS:
    383       return "File already exists.";
    384     case ::base::File::FILE_ERROR_NOT_FOUND:
    385       return "File not found.";
    386     case ::base::File::FILE_ERROR_ACCESS_DENIED:
    387       return "Access denied.";
    388     case ::base::File::FILE_ERROR_TOO_MANY_OPENED:
    389       return "Too many files open.";
    390     case ::base::File::FILE_ERROR_NO_MEMORY:
    391       return "Out of memory.";
    392     case ::base::File::FILE_ERROR_NO_SPACE:
    393       return "No space left on drive.";
    394     case ::base::File::FILE_ERROR_NOT_A_DIRECTORY:
    395       return "Not a directory.";
    396     case ::base::File::FILE_ERROR_INVALID_OPERATION:
    397       return "Invalid operation.";
    398     case ::base::File::FILE_ERROR_SECURITY:
    399       return "Security error.";
    400     case ::base::File::FILE_ERROR_ABORT:
    401       return "File operation aborted.";
    402     case ::base::File::FILE_ERROR_NOT_A_FILE:
    403       return "The supplied path was not a file.";
    404     case ::base::File::FILE_ERROR_NOT_EMPTY:
    405       return "The file was not empty.";
    406     case ::base::File::FILE_ERROR_INVALID_URL:
    407       return "Invalid URL.";
    408     case ::base::File::FILE_ERROR_IO:
    409       return "OS or hardware error.";
    410     case ::base::File::FILE_OK:
    411       return "OK.";
    412     case ::base::File::FILE_ERROR_MAX:
    413       NOTREACHED();
    414   }
    415   NOTIMPLEMENTED();
    416   return "Unknown error.";
    417 }
    418 
    419 base::FilePath ChromiumEnv::RestoreFromBackup(const base::FilePath& base_name) {
    420   base::FilePath table_name =
    421       base_name.AddExtension(table_extension);
    422   bool result = base::CopyFile(base_name.AddExtension(backup_table_extension),
    423                                table_name);
    424   std::string uma_name(name_);
    425   uma_name.append(".TableRestore");
    426   base::BooleanHistogram::FactoryGet(
    427       uma_name, base::Histogram::kUmaTargetedHistogramFlag)->AddBoolean(result);
    428   return table_name;
    429 }
    430 
    431 void ChromiumEnv::RestoreIfNecessary(const std::string& dir,
    432                                      std::vector<std::string>* result) {
    433   std::set<base::FilePath> tables_found;
    434   std::set<base::FilePath> backups_found;
    435   for (std::vector<std::string>::iterator it = result->begin();
    436        it != result->end();
    437        ++it) {
    438     base::FilePath current = CreateFilePath(*it);
    439     if (current.MatchesExtension(table_extension))
    440       tables_found.insert(current.RemoveExtension());
    441     if (current.MatchesExtension(backup_table_extension))
    442       backups_found.insert(current.RemoveExtension());
    443   }
    444   std::set<base::FilePath> backups_only =
    445       base::STLSetDifference<std::set<base::FilePath> >(backups_found,
    446                                                         tables_found);
    447 
    448   if (backups_only.size()) {
    449     std::string uma_name(name_);
    450     uma_name.append(".MissingFiles");
    451     int num_missing_files =
    452         backups_only.size() > INT_MAX ? INT_MAX : backups_only.size();
    453     base::Histogram::FactoryGet(uma_name,
    454                                 1 /*min*/,
    455                                 100 /*max*/,
    456                                 8 /*num_buckets*/,
    457                                 base::Histogram::kUmaTargetedHistogramFlag)
    458         ->Add(num_missing_files);
    459   }
    460   base::FilePath dir_filepath = base::FilePath::FromUTF8Unsafe(dir);
    461   for (std::set<base::FilePath>::iterator it = backups_only.begin();
    462        it != backups_only.end();
    463        ++it) {
    464     base::FilePath restored_table_name =
    465         RestoreFromBackup(dir_filepath.Append(*it));
    466     result->push_back(FilePathToString(restored_table_name.BaseName()));
    467   }
    468 }
    469 
    470 Status ChromiumEnv::GetChildren(const std::string& dir_string,
    471                                 std::vector<std::string>* result) {
    472   std::vector<base::FilePath> entries;
    473   base::File::Error error =
    474       GetDirectoryEntries(CreateFilePath(dir_string), &entries);
    475   if (error != base::File::FILE_OK) {
    476     RecordOSError(kGetChildren, error);
    477     return MakeIOError(
    478         dir_string, "Could not open/read directory", kGetChildren, error);
    479   }
    480   result->clear();
    481   for (std::vector<base::FilePath>::iterator it = entries.begin();
    482        it != entries.end();
    483        ++it) {
    484     result->push_back(FilePathToString(*it));
    485   }
    486 
    487   if (make_backup_)
    488     RestoreIfNecessary(dir_string, result);
    489   return Status::OK();
    490 }
    491 
    492 Status ChromiumEnv::DeleteFile(const std::string& fname) {
    493   Status result;
    494   base::FilePath fname_filepath = CreateFilePath(fname);
    495   // TODO(jorlow): Should we assert this is a file?
    496   if (!::base::DeleteFile(fname_filepath, false)) {
    497     result = MakeIOError(fname, "Could not delete file.", kDeleteFile);
    498     RecordErrorAt(kDeleteFile);
    499   }
    500   if (make_backup_ && fname_filepath.MatchesExtension(table_extension)) {
    501     base::DeleteFile(fname_filepath.ReplaceExtension(backup_table_extension),
    502                      false);
    503   }
    504   return result;
    505 }
    506 
    507 Status ChromiumEnv::CreateDir(const std::string& name) {
    508   Status result;
    509   base::File::Error error = base::File::FILE_OK;
    510   Retrier retrier(kCreateDir, this);
    511   do {
    512     if (base::CreateDirectoryAndGetError(CreateFilePath(name), &error))
    513       return result;
    514   } while (retrier.ShouldKeepTrying(error));
    515   result = MakeIOError(name, "Could not create directory.", kCreateDir, error);
    516   RecordOSError(kCreateDir, error);
    517   return result;
    518 }
    519 
    520 Status ChromiumEnv::DeleteDir(const std::string& name) {
    521   Status result;
    522   // TODO(jorlow): Should we assert this is a directory?
    523   if (!::base::DeleteFile(CreateFilePath(name), false)) {
    524     result = MakeIOError(name, "Could not delete directory.", kDeleteDir);
    525     RecordErrorAt(kDeleteDir);
    526   }
    527   return result;
    528 }
    529 
    530 Status ChromiumEnv::GetFileSize(const std::string& fname, uint64_t* size) {
    531   Status s;
    532   int64_t signed_size;
    533   if (!::base::GetFileSize(CreateFilePath(fname), &signed_size)) {
    534     *size = 0;
    535     s = MakeIOError(fname, "Could not determine file size.", kGetFileSize);
    536     RecordErrorAt(kGetFileSize);
    537   } else {
    538     *size = static_cast<uint64_t>(signed_size);
    539   }
    540   return s;
    541 }
    542 
    543 Status ChromiumEnv::RenameFile(const std::string& src, const std::string& dst) {
    544   Status result;
    545   base::FilePath src_file_path = CreateFilePath(src);
    546   if (!::base::PathExists(src_file_path))
    547     return result;
    548   base::FilePath destination = CreateFilePath(dst);
    549 
    550   Retrier retrier(kRenameFile, this);
    551   base::File::Error error = base::File::FILE_OK;
    552   do {
    553     if (base::ReplaceFile(src_file_path, destination, &error))
    554       return result;
    555   } while (retrier.ShouldKeepTrying(error));
    556 
    557   DCHECK(error != base::File::FILE_OK);
    558   RecordOSError(kRenameFile, error);
    559   char buf[100];
    560   snprintf(buf,
    561            sizeof(buf),
    562            "Could not rename file: %s",
    563            FileErrorString(error));
    564   return MakeIOError(src, buf, kRenameFile, error);
    565 }
    566 
    567 Status ChromiumEnv::LockFile(const std::string& fname, FileLock** lock) {
    568   *lock = NULL;
    569   Status result;
    570   int flags = ::base::File::FLAG_OPEN_ALWAYS |
    571               ::base::File::FLAG_READ |
    572               ::base::File::FLAG_WRITE;
    573   ::base::File::Error error_code;
    574   ::base::File file;
    575   Retrier retrier(kLockFile, this);
    576   do {
    577     file.Initialize(CreateFilePath(fname), flags);
    578     if (!file.IsValid())
    579       error_code = file.error_details();
    580   } while (!file.IsValid() && retrier.ShouldKeepTrying(error_code));
    581 
    582   if (!file.IsValid()) {
    583     if (error_code == ::base::File::FILE_ERROR_NOT_FOUND) {
    584       ::base::FilePath parent = CreateFilePath(fname).DirName();
    585       ::base::FilePath last_parent;
    586       int num_missing_ancestors = 0;
    587       do {
    588         if (base::DirectoryExists(parent))
    589           break;
    590         ++num_missing_ancestors;
    591         last_parent = parent;
    592         parent = parent.DirName();
    593       } while (parent != last_parent);
    594       RecordLockFileAncestors(num_missing_ancestors);
    595     }
    596 
    597     result = MakeIOError(fname, FileErrorString(error_code), kLockFile,
    598                          error_code);
    599     RecordOSError(kLockFile, error_code);
    600     return result;
    601   }
    602 
    603   if (!locks_.Insert(fname)) {
    604     result = MakeIOError(fname, "Lock file already locked.", kLockFile);
    605     return result;
    606   }
    607 
    608   Retrier lock_retrier = Retrier(kLockFile, this);
    609   do {
    610     error_code = file.Lock();
    611   } while (error_code != ::base::File::FILE_OK &&
    612            retrier.ShouldKeepTrying(error_code));
    613 
    614   if (error_code != ::base::File::FILE_OK) {
    615     locks_.Remove(fname);
    616     result = MakeIOError(fname, FileErrorString(error_code), kLockFile,
    617                          error_code);
    618     RecordOSError(kLockFile, error_code);
    619     return result;
    620   }
    621 
    622   ChromiumFileLock* my_lock = new ChromiumFileLock;
    623   my_lock->file_ = file.Pass();
    624   my_lock->name_ = fname;
    625   *lock = my_lock;
    626   return result;
    627 }
    628 
    629 Status ChromiumEnv::UnlockFile(FileLock* lock) {
    630   ChromiumFileLock* my_lock = reinterpret_cast<ChromiumFileLock*>(lock);
    631   Status result;
    632 
    633   ::base::File::Error error_code = my_lock->file_.Unlock();
    634   if (error_code != ::base::File::FILE_OK) {
    635     result =
    636         MakeIOError(my_lock->name_, "Could not unlock lock file.", kUnlockFile);
    637     RecordOSError(kUnlockFile, error_code);
    638   }
    639   bool removed = locks_.Remove(my_lock->name_);
    640   DCHECK(removed);
    641   delete my_lock;
    642   return result;
    643 }
    644 
    645 Status ChromiumEnv::GetTestDirectory(std::string* path) {
    646   mu_.Acquire();
    647   if (test_directory_.empty()) {
    648     if (!base::CreateNewTempDirectory(kLevelDBTestDirectoryPrefix,
    649                                       &test_directory_)) {
    650       mu_.Release();
    651       RecordErrorAt(kGetTestDirectory);
    652       return MakeIOError(
    653           "Could not create temp directory.", "", kGetTestDirectory);
    654     }
    655   }
    656   *path = FilePathToString(test_directory_);
    657   mu_.Release();
    658   return Status::OK();
    659 }
    660 
    661 uint64_t ChromiumEnv::NowMicros() {
    662   return ::base::TimeTicks::Now().ToInternalValue();
    663 }
    664 
    665 void ChromiumEnv::SleepForMicroseconds(int micros) {
    666   // Round up to the next millisecond.
    667   ::base::PlatformThread::Sleep(::base::TimeDelta::FromMicroseconds(micros));
    668 }
    669 
    670 void ChromiumEnv::RecordErrorAt(MethodID method) const {
    671   GetMethodIOErrorHistogram()->Add(method);
    672 }
    673 
    674 void ChromiumEnv::RecordLockFileAncestors(int num_missing_ancestors) const {
    675   GetLockFileAncestorHistogram()->Add(num_missing_ancestors);
    676 }
    677 
    678 void ChromiumEnv::RecordOSError(MethodID method,
    679                                 base::File::Error error) const {
    680   DCHECK_LT(error, 0);
    681   RecordErrorAt(method);
    682   GetOSErrorHistogram(method, -base::File::FILE_ERROR_MAX)->Add(-error);
    683 }
    684 
    685 void ChromiumEnv::RecordOSError(MethodID method, int error) const {
    686   DCHECK_GT(error, 0);
    687   RecordErrorAt(method);
    688   GetOSErrorHistogram(method, ERANGE + 1)->Add(error);
    689 }
    690 
    691 void ChromiumEnv::RecordBackupResult(bool result) const {
    692   std::string uma_name(name_);
    693   uma_name.append(".TableBackup");
    694   base::BooleanHistogram::FactoryGet(
    695       uma_name, base::Histogram::kUmaTargetedHistogramFlag)->AddBoolean(result);
    696 }
    697 
    698 base::HistogramBase* ChromiumEnv::GetOSErrorHistogram(MethodID method,
    699                                                       int limit) const {
    700   std::string uma_name(name_);
    701   // TODO(dgrogan): This is probably not the best way to concatenate strings.
    702   uma_name.append(".IOError.").append(MethodIDToString(method));
    703   return base::LinearHistogram::FactoryGet(uma_name, 1, limit, limit + 1,
    704       base::Histogram::kUmaTargetedHistogramFlag);
    705 }
    706 
    707 base::HistogramBase* ChromiumEnv::GetMethodIOErrorHistogram() const {
    708   std::string uma_name(name_);
    709   uma_name.append(".IOError");
    710   return base::LinearHistogram::FactoryGet(uma_name, 1, kNumEntries,
    711       kNumEntries + 1, base::Histogram::kUmaTargetedHistogramFlag);
    712 }
    713 
    714 base::HistogramBase* ChromiumEnv::GetMaxFDHistogram(
    715     const std::string& type) const {
    716   std::string uma_name(name_);
    717   uma_name.append(".MaxFDs.").append(type);
    718   // These numbers make each bucket twice as large as the previous bucket.
    719   const int kFirstEntry = 1;
    720   const int kLastEntry = 65536;
    721   const int kNumBuckets = 18;
    722   return base::Histogram::FactoryGet(
    723       uma_name, kFirstEntry, kLastEntry, kNumBuckets,
    724       base::Histogram::kUmaTargetedHistogramFlag);
    725 }
    726 
    727 base::HistogramBase* ChromiumEnv::GetLockFileAncestorHistogram() const {
    728   std::string uma_name(name_);
    729   uma_name.append(".LockFileAncestorsNotFound");
    730   const int kMin = 1;
    731   const int kMax = 10;
    732   const int kNumBuckets = 11;
    733   return base::LinearHistogram::FactoryGet(
    734       uma_name, kMin, kMax, kNumBuckets,
    735       base::Histogram::kUmaTargetedHistogramFlag);
    736 }
    737 
    738 base::HistogramBase* ChromiumEnv::GetRetryTimeHistogram(MethodID method) const {
    739   std::string uma_name(name_);
    740   // TODO(dgrogan): This is probably not the best way to concatenate strings.
    741   uma_name.append(".TimeUntilSuccessFor").append(MethodIDToString(method));
    742 
    743   const int kBucketSizeMillis = 25;
    744   // Add 2, 1 for each of the buckets <1 and >max.
    745   const int kNumBuckets = kMaxRetryTimeMillis / kBucketSizeMillis + 2;
    746   return base::Histogram::FactoryTimeGet(
    747       uma_name, base::TimeDelta::FromMilliseconds(1),
    748       base::TimeDelta::FromMilliseconds(kMaxRetryTimeMillis + 1),
    749       kNumBuckets,
    750       base::Histogram::kUmaTargetedHistogramFlag);
    751 }
    752 
    753 base::HistogramBase* ChromiumEnv::GetRecoveredFromErrorHistogram(
    754     MethodID method) const {
    755   std::string uma_name(name_);
    756   uma_name.append(".RetryRecoveredFromErrorIn")
    757       .append(MethodIDToString(method));
    758   return base::LinearHistogram::FactoryGet(uma_name, 1, kNumEntries,
    759       kNumEntries + 1, base::Histogram::kUmaTargetedHistogramFlag);
    760 }
    761 
    762 class Thread : public ::base::PlatformThread::Delegate {
    763  public:
    764   Thread(void (*function)(void* arg), void* arg)
    765       : function_(function), arg_(arg) {
    766     ::base::PlatformThreadHandle handle;
    767     bool success = ::base::PlatformThread::Create(0, this, &handle);
    768     DCHECK(success);
    769   }
    770   virtual ~Thread() {}
    771   virtual void ThreadMain() {
    772     (*function_)(arg_);
    773     delete this;
    774   }
    775 
    776  private:
    777   void (*function_)(void* arg);
    778   void* arg_;
    779 };
    780 
    781 void ChromiumEnv::Schedule(ScheduleFunc* function, void* arg) {
    782   mu_.Acquire();
    783 
    784   // Start background thread if necessary
    785   if (!started_bgthread_) {
    786     started_bgthread_ = true;
    787     StartThread(&ChromiumEnv::BGThreadWrapper, this);
    788   }
    789 
    790   // If the queue is currently empty, the background thread may currently be
    791   // waiting.
    792   if (queue_.empty()) {
    793     bgsignal_.Signal();
    794   }
    795 
    796   // Add to priority queue
    797   queue_.push_back(BGItem());
    798   queue_.back().function = function;
    799   queue_.back().arg = arg;
    800 
    801   mu_.Release();
    802 }
    803 
    804 void ChromiumEnv::BGThread() {
    805   base::PlatformThread::SetName(name_.c_str());
    806 
    807   while (true) {
    808     // Wait until there is an item that is ready to run
    809     mu_.Acquire();
    810     while (queue_.empty()) {
    811       bgsignal_.Wait();
    812     }
    813 
    814     void (*function)(void*) = queue_.front().function;
    815     void* arg = queue_.front().arg;
    816     queue_.pop_front();
    817 
    818     mu_.Release();
    819     TRACE_EVENT0("leveldb", "ChromiumEnv::BGThread-Task");
    820     (*function)(arg);
    821   }
    822 }
    823 
    824 void ChromiumEnv::StartThread(void (*function)(void* arg), void* arg) {
    825   new Thread(function, arg);  // Will self-delete.
    826 }
    827 
    828 static std::string GetDirName(const std::string& filename) {
    829   base::FilePath file = base::FilePath::FromUTF8Unsafe(filename);
    830   return FilePathToString(file.DirName());
    831 }
    832 
    833 void ChromiumEnv::DidCreateNewFile(const std::string& filename) {
    834   base::AutoLock auto_lock(map_lock_);
    835   needs_sync_map_[GetDirName(filename)] = true;
    836 }
    837 
    838 bool ChromiumEnv::DoesDirNeedSync(const std::string& filename) {
    839   base::AutoLock auto_lock(map_lock_);
    840   return needs_sync_map_.find(GetDirName(filename)) != needs_sync_map_.end();
    841 }
    842 
    843 void ChromiumEnv::DidSyncDir(const std::string& filename) {
    844   base::AutoLock auto_lock(map_lock_);
    845   needs_sync_map_.erase(GetDirName(filename));
    846 }
    847 
    848 }  // namespace leveldb_env
    849 
    850 namespace leveldb {
    851 
    852 Env* IDBEnv() {
    853   return leveldb_env::idb_env.Pointer();
    854 }
    855 
    856 Env* Env::Default() {
    857   return leveldb_env::default_env.Pointer();
    858 }
    859 
    860 }  // namespace leveldb
    861