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