Home | History | Annotate | Download | only in leveldatabase 
      1 // Copyright (c) 2013 The LevelDB Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file. See the AUTHORS file for names of contributors.
      4 
      5 #include "base/debug/trace_event.h"
      6 #include "base/files/file.h"
      7 #include "base/files/file_path.h"
      8 #include "base/strings/utf_string_conversions.h"
      9 #include "base/win/win_util.h"
     10 #include "chromium_logger.h"
     11 #include "env_chromium_stdio.h"
     12 #include "env_chromium_win.h"
     13 
     14 using namespace leveldb;
     15 
     16 namespace leveldb_env {
     17 
     18 namespace {
     19 
     20 static std::string GetWindowsErrorMessage(DWORD err) {
     21   LPTSTR errorText(NULL);
     22   FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER |
     23                     FORMAT_MESSAGE_IGNORE_INSERTS,
     24                 NULL,
     25                 err,
     26                 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
     27                 (LPTSTR) & errorText,
     28                 0,
     29                 NULL);
     30   if (errorText != NULL) {
     31     std::string message(base::UTF16ToUTF8(errorText));
     32     // FormatMessage adds CR/LF to messages so we remove it.
     33     base::TrimWhitespace(message, base::TRIM_TRAILING, &message);
     34     LocalFree(errorText);
     35     return message;
     36   } else {
     37     return std::string();
     38   }
     39 }
     40 
     41 class ChromiumSequentialFileWin : public SequentialFile {
     42  private:
     43   std::string filename_;
     44   HANDLE file_;
     45   const UMALogger* uma_logger_;
     46 
     47  public:
     48   ChromiumSequentialFileWin(const std::string& fname,
     49                          HANDLE f,
     50                          const UMALogger* uma_logger)
     51       : filename_(fname), file_(f), uma_logger_(uma_logger) {
     52     DCHECK(file_ != INVALID_HANDLE_VALUE);
     53   }
     54   virtual ~ChromiumSequentialFileWin() {
     55     DCHECK(file_ != INVALID_HANDLE_VALUE);
     56     CloseHandle(file_);
     57     file_ = INVALID_HANDLE_VALUE;
     58   }
     59 
     60   virtual Status Read(size_t n, Slice* result, char* scratch) {
     61     Status s;
     62     DWORD bytes_read(0);
     63     DCHECK(file_ != INVALID_HANDLE_VALUE);
     64     if (ReadFile(file_, scratch, n, &bytes_read, NULL)) {
     65       *result = Slice(scratch, bytes_read);
     66     } else {
     67       DWORD err = GetLastError();
     68       s = MakeIOErrorWin(
     69           filename_, GetWindowsErrorMessage(err), kSequentialFileRead, err);
     70       uma_logger_->RecordErrorAt(kSequentialFileRead);
     71       if (bytes_read > 0)
     72         *result = Slice(scratch, bytes_read);
     73     }
     74     return s;
     75   }
     76 
     77   virtual Status Skip(uint64_t n) {
     78     LARGE_INTEGER li;
     79     li.QuadPart = n;
     80     if (SetFilePointer(file_, li.LowPart, &li.HighPart, FILE_CURRENT) ==
     81         INVALID_SET_FILE_POINTER) {
     82       DWORD err = GetLastError();
     83       uma_logger_->RecordErrorAt(kSequentialFileSkip);
     84       return MakeIOErrorWin(
     85           filename_, GetWindowsErrorMessage(err), kSequentialFileSkip, err);
     86     }
     87     return Status::OK();
     88   }
     89 };
     90 
     91 class ChromiumRandomAccessFileWin : public RandomAccessFile {
     92  private:
     93   std::string filename_;
     94   mutable ::base::File file_;
     95   const UMALogger* uma_logger_;
     96 
     97  public:
     98   ChromiumRandomAccessFileWin(const std::string& fname,
     99                               ::base::File file,
    100                               const UMALogger* uma_logger)
    101       : filename_(fname), file_(file.Pass()), uma_logger_(uma_logger) {}
    102   virtual ~ChromiumRandomAccessFileWin() {}
    103 
    104   virtual Status Read(uint64_t offset, size_t n, Slice* result, char* scratch)
    105       const {
    106     Status s;
    107     int r = file_.Read(offset, scratch, n);
    108     *result = Slice(scratch, (r < 0) ? 0 : r);
    109     if (r < 0) {
    110       // An error: return a non-ok status
    111       s = MakeIOError(
    112           filename_, "Could not perform read", kRandomAccessFileRead);
    113       uma_logger_->RecordErrorAt(kRandomAccessFileRead);
    114     }
    115     return s;
    116   }
    117 };
    118 
    119 }  // unnamed namespace
    120 
    121 Status MakeIOErrorWin(Slice filename,
    122                         const std::string& message,
    123                         MethodID method,
    124                         DWORD error) {
    125   char buf[512];
    126   if (snprintf(buf,
    127                sizeof(buf),
    128                "%s (ChromeMethodErrno: %d::%s::%u)",
    129                message.c_str(),
    130                method,
    131                MethodIDToString(method),
    132                error) >= 0) {
    133     return Status::IOError(filename, buf);
    134   } else {
    135     return Status::IOError(filename, "<unknown>");
    136   }
    137 }
    138 
    139 ChromiumWritableFileWin::ChromiumWritableFileWin(
    140     const std::string& fname,
    141     HANDLE f,
    142     const UMALogger* uma_logger,
    143     WriteTracker* tracker,
    144     bool make_backup)
    145     : filename_(fname),
    146       file_(f),
    147       uma_logger_(uma_logger),
    148       tracker_(tracker),
    149       file_type_(kOther),
    150       make_backup_(make_backup) {
    151   DCHECK(f != INVALID_HANDLE_VALUE);
    152   base::FilePath path = base::FilePath::FromUTF8Unsafe(fname);
    153   if (FilePathToString(path.BaseName()).find("MANIFEST") == 0)
    154     file_type_ = kManifest;
    155   else if (ChromiumEnv::HasTableExtension(path))
    156     file_type_ = kTable;
    157   if (file_type_ != kManifest)
    158     tracker_->DidCreateNewFile(filename_);
    159   parent_dir_ = FilePathToString(ChromiumEnv::CreateFilePath(fname).DirName());
    160 }
    161 
    162 ChromiumWritableFileWin::~ChromiumWritableFileWin() {
    163   if (file_ != INVALID_HANDLE_VALUE) {
    164     // Ignoring any potential errors
    165 
    166     CloseHandle(file_);
    167     file_ = INVALID_HANDLE_VALUE;
    168   }
    169 }
    170 
    171 Status ChromiumWritableFileWin::SyncParent() {
    172   // On Windows no need to sync parent directory. It's metadata will be
    173   // updated via the creation of the new file, without an explicit sync.
    174   return Status();
    175 }
    176 
    177 Status ChromiumWritableFileWin::Append(const Slice& data) {
    178   if (file_type_ == kManifest && tracker_->DoesDirNeedSync(filename_)) {
    179     Status s = SyncParent();
    180     if (!s.ok())
    181       return s;
    182     tracker_->DidSyncDir(filename_);
    183   }
    184 
    185   DWORD written(0);
    186   if (!WriteFile(file_, data.data(), data.size(), &written, NULL)) {
    187     DWORD err = GetLastError();
    188     uma_logger_->RecordOSError(kWritableFileAppend,
    189                                base::File::OSErrorToFileError(err));
    190     return MakeIOErrorWin(
    191         filename_, GetWindowsErrorMessage(err), kWritableFileAppend, err);
    192   }
    193   return Status::OK();
    194 }
    195 
    196 Status ChromiumWritableFileWin::Close() {
    197   Status result;
    198   DCHECK(file_ != INVALID_HANDLE_VALUE);
    199   if (!CloseHandle(file_)) {
    200     DWORD err = GetLastError();
    201     result = MakeIOErrorWin(
    202         filename_, GetWindowsErrorMessage(err), kWritableFileClose, err);
    203     uma_logger_->RecordErrorAt(kWritableFileClose);
    204   }
    205   file_ = INVALID_HANDLE_VALUE;
    206   return result;
    207 }
    208 
    209 Status ChromiumWritableFileWin::Flush() {
    210   // Windows doesn't use POSIX file streams, so there are no file stream buffers
    211   // to flush - this is a no-op.
    212   return Status();
    213 }
    214 
    215 Status ChromiumWritableFileWin::Sync() {
    216   TRACE_EVENT0("leveldb", "ChromiumEnvWin::Sync");
    217   Status result;
    218   DWORD error = ERROR_SUCCESS;
    219 
    220   DCHECK(file_ != INVALID_HANDLE_VALUE);
    221   if (!FlushFileBuffers(file_))
    222     error = GetLastError();
    223   if (error != ERROR_SUCCESS) {
    224     result = MakeIOErrorWin(
    225         filename_, GetWindowsErrorMessage(error), kWritableFileSync, error);
    226     uma_logger_->RecordErrorAt(kWritableFileSync);
    227   } else if (make_backup_ && file_type_ == kTable) {
    228     bool success = ChromiumEnv::MakeBackup(filename_);
    229     uma_logger_->RecordBackupResult(success);
    230   }
    231   return result;
    232 }
    233 
    234 ChromiumEnvWin::ChromiumEnvWin() {}
    235 
    236 ChromiumEnvWin::~ChromiumEnvWin() {}
    237 
    238 Status ChromiumEnvWin::NewSequentialFile(const std::string& fname,
    239                                            SequentialFile** result) {
    240   HANDLE f = CreateFile(base::UTF8ToUTF16(fname).c_str(),
    241                         GENERIC_READ,
    242                         FILE_SHARE_READ,
    243                         NULL,
    244                         OPEN_EXISTING,
    245                         FILE_ATTRIBUTE_NORMAL,
    246                         NULL);
    247   if (f == INVALID_HANDLE_VALUE) {
    248     *result = NULL;
    249     DWORD err = GetLastError();
    250     RecordOSError(kNewSequentialFile, err);
    251     return MakeIOErrorWin(
    252         fname, GetWindowsErrorMessage(err), kNewSequentialFile, err);
    253   } else {
    254     *result = new ChromiumSequentialFileWin(fname, f, this);
    255     return Status::OK();
    256   }
    257 }
    258 
    259 void ChromiumEnvWin::RecordOpenFilesLimit(const std::string& type) {
    260   // The Windows POSIX implementation (which this class doesn't use)
    261   // has an open file limit, but when using the Win32 API this is limited by
    262   // available memory, so no value to report.
    263 }
    264 
    265 Status ChromiumEnvWin::NewRandomAccessFile(const std::string& fname,
    266                                            RandomAccessFile** result) {
    267   int flags = ::base::File::FLAG_READ | ::base::File::FLAG_OPEN;
    268   ::base::File file(ChromiumEnv::CreateFilePath(fname), flags);
    269   if (file.IsValid()) {
    270     *result = new ChromiumRandomAccessFileWin(fname, file.Pass(), this);
    271     RecordOpenFilesLimit("Success");
    272     return Status::OK();
    273   }
    274   ::base::File::Error error_code = file.error_details();
    275   if (error_code == ::base::File::FILE_ERROR_TOO_MANY_OPENED)
    276     RecordOpenFilesLimit("TooManyOpened");
    277   else
    278     RecordOpenFilesLimit("OtherError");
    279   *result = NULL;
    280   RecordOSError(kNewRandomAccessFile, error_code);
    281   return MakeIOErrorWin(fname,
    282                         FileErrorString(error_code),
    283                         kNewRandomAccessFile,
    284                         error_code);
    285 }
    286 
    287 Status ChromiumEnvWin::NewWritableFile(const std::string& fname,
    288                                          WritableFile** result) {
    289   *result = NULL;
    290   HANDLE f = CreateFile(base::UTF8ToUTF16(fname).c_str(),
    291                         GENERIC_WRITE,
    292                         FILE_SHARE_READ,
    293                         NULL,
    294                         CREATE_ALWAYS,
    295                         FILE_ATTRIBUTE_NORMAL,
    296                         NULL);
    297   if (f == INVALID_HANDLE_VALUE) {
    298     DWORD err = GetLastError();
    299     RecordErrorAt(kNewWritableFile);
    300     return MakeIOErrorWin(
    301         fname, GetWindowsErrorMessage(err), kNewWritableFile, err);
    302   } else {
    303     *result = new ChromiumWritableFileWin(fname, f, this, this, make_backup_);
    304     return Status::OK();
    305   }
    306 }
    307 
    308 base::File::Error ChromiumEnvWin::GetDirectoryEntries(
    309     const base::FilePath& dir_param,
    310     std::vector<base::FilePath>* result) const {
    311   result->clear();
    312   base::FilePath dir_filepath = dir_param.Append(FILE_PATH_LITERAL("*"));
    313   WIN32_FIND_DATA find_data;
    314   HANDLE find_handle = FindFirstFile(dir_filepath.value().c_str(), &find_data);
    315   if (find_handle == INVALID_HANDLE_VALUE) {
    316     DWORD last_error = GetLastError();
    317     if (last_error == ERROR_FILE_NOT_FOUND)
    318       return base::File::FILE_OK;
    319     return base::File::OSErrorToFileError(last_error);
    320   }
    321   do {
    322     base::FilePath filepath(find_data.cFileName);
    323     base::FilePath::StringType basename = filepath.BaseName().value();
    324     if (basename == FILE_PATH_LITERAL(".") ||
    325         basename == FILE_PATH_LITERAL(".."))
    326       continue;
    327     result->push_back(filepath.BaseName());
    328   } while (FindNextFile(find_handle, &find_data));
    329   DWORD last_error = GetLastError();
    330   base::File::Error return_value = base::File::FILE_OK;
    331   if (last_error != ERROR_NO_MORE_FILES)
    332     return_value = base::File::OSErrorToFileError(last_error);
    333   FindClose(find_handle);
    334   return return_value;
    335 }
    336 
    337 Status ChromiumEnvWin::NewLogger(const std::string& fname, Logger** result) {
    338   FILE* f = _wfopen(base::UTF8ToUTF16(fname).c_str(), L"w");
    339   if (f == NULL) {
    340     *result = NULL;
    341     int saved_errno = errno;
    342     RecordOSError(kNewLogger, saved_errno);
    343     return MakeIOError(fname, strerror(saved_errno), kNewLogger, saved_errno);
    344   } else {
    345     *result = new ChromiumLogger(f);
    346     return Status::OK();
    347   }
    348 }
    349 
    350 void ChromiumEnvWin::RecordOSError(MethodID method, DWORD error) const {
    351   RecordErrorAt(method);
    352   GetOSErrorHistogram(method, ERANGE + 1)->Add(error);
    353 }
    354 
    355 }  // namespace leveldb_env
    356