third_party/leveldatabase/env_chromium_win.cc

   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