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