Inside Bitcoin

1// Copyright (c) 2018 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// Prevent Windows headers from defining min/max macros and instead
6// use STL.
7#ifndef NOMINMAX
8#define NOMINMAX
9#endif  // ifndef NOMINMAX
10#include <windows.h>
11
12#include <algorithm>
13#include <atomic>
14#include <chrono>
15#include <condition_variable>
16#include <cstddef>
17#include <cstdint>
18#include <cstdlib>
19#include <cstring>
20#include <memory>
21#include <mutex>
22#include <queue>
23#include <sstream>
24#include <string>
25#include <vector>
26
27#include "leveldb/env.h"
28#include "leveldb/slice.h"
29#include "port/port.h"
30#include "port/thread_annotations.h"
31#include "util/env_windows_test_helper.h"
32#include "util/logging.h"
33#include "util/mutexlock.h"
34#include "util/windows_logger.h"
35
36#if defined(DeleteFile)
37#undef DeleteFile
38#endif  // defined(DeleteFile)
39
40namespace leveldb {
41
42namespace {
43
44constexpr const size_t kWritableFileBufferSize = 65536;
45
46// Up to 1000 mmaps for 64-bit binaries; none for 32-bit.
47constexpr int kDefaultMmapLimit = (sizeof(void*) >= 8) ? 1000 : 0;
48
49// Can be set by by EnvWindowsTestHelper::SetReadOnlyMMapLimit().
50int g_mmap_limit = kDefaultMmapLimit;
51
52std::string GetWindowsErrorMessage(DWORD error_code) {
53  std::string message;
54  char* error_text = nullptr;
55  // Use MBCS version of FormatMessage to match return value.
56  size_t error_text_size = ::FormatMessageA(
57      FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER |
58          FORMAT_MESSAGE_IGNORE_INSERTS,
59      nullptr, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
60      reinterpret_cast<char*>(&error_text), 0, nullptr);
61  if (!error_text) {
62    return message;
63  }
64  message.assign(error_text, error_text_size);
65  ::LocalFree(error_text);
66  return message;
67}
68
69Status WindowsError(const std::string& context, DWORD error_code) {
70  if (error_code == ERROR_FILE_NOT_FOUND || error_code == ERROR_PATH_NOT_FOUND)
71    return Status::NotFound(context, GetWindowsErrorMessage(error_code));
72  return Status::IOError(context, GetWindowsErrorMessage(error_code));
73}
74
75class ScopedHandle {
76 public:
77  ScopedHandle(HANDLE handle) : handle_(handle) {}
78  ScopedHandle(const ScopedHandle&) = delete;
79  ScopedHandle(ScopedHandle&& other) noexcept : handle_(other.Release()) {}
80  ~ScopedHandle() { Close(); }
81
82  ScopedHandle& operator=(const ScopedHandle&) = delete;
83
84  ScopedHandle& operator=(ScopedHandle&& rhs) = delete;
85
86  bool Close() {
87    if (!is_valid()) {
88      return true;
89    }
90    HANDLE h = handle_;
91    handle_ = INVALID_HANDLE_VALUE;
92    return ::CloseHandle(h);
93  }
94
95  bool is_valid() const {
96    return handle_ != INVALID_HANDLE_VALUE && handle_ != nullptr;
97  }
98
99  HANDLE get() const { return handle_; }
100
101  HANDLE Release() {
102    HANDLE h = handle_;
103    handle_ = INVALID_HANDLE_VALUE;
104    return h;
105  }
106
107 private:
108  HANDLE handle_;
109};
110
111// Helper class to limit resource usage to avoid exhaustion.
112// Currently used to limit read-only file descriptors and mmap file usage
113// so that we do not run out of file descriptors or virtual memory, or run into
114// kernel performance problems for very large databases.
115class Limiter {
116 public:
117  // Limit maximum number of resources to |max_acquires|.
118  Limiter(int max_acquires) : acquires_allowed_(max_acquires) {}
119
120  Limiter(const Limiter&) = delete;
121  Limiter operator=(const Limiter&) = delete;
122
123  // If another resource is available, acquire it and return true.
124  // Else return false.
125  bool Acquire() {
126    int old_acquires_allowed =
127        acquires_allowed_.fetch_sub(1, std::memory_order_relaxed);
128
129    if (old_acquires_allowed > 0) return true;
130
131    acquires_allowed_.fetch_add(1, std::memory_order_relaxed);
132    return false;
133  }
134
135  // Release a resource acquired by a previous call to Acquire() that returned
136  // true.
137  void Release() { acquires_allowed_.fetch_add(1, std::memory_order_relaxed); }
138
139 private:
140  // The number of available resources.
141  //
142  // This is a counter and is not tied to the invariants of any other class, so
143  // it can be operated on safely using std::memory_order_relaxed.
144  std::atomic<int> acquires_allowed_;
145};
146
147class WindowsSequentialFile : public SequentialFile {
148 public:
149  WindowsSequentialFile(std::string filename, ScopedHandle handle)
150      : handle_(std::move(handle)), filename_(std::move(filename)) {}
151  ~WindowsSequentialFile() override {}
152
153  Status Read(size_t n, Slice* result, char* scratch) override {
154    DWORD bytes_read;
155    // DWORD is 32-bit, but size_t could technically be larger. However leveldb
156    // files are limited to leveldb::Options::max_file_size which is clamped to
157    // 1<<30 or 1 GiB.
158    assert(n <= std::numeric_limits<DWORD>::max());
159    if (!::ReadFile(handle_.get(), scratch, static_cast<DWORD>(n), &bytes_read,
160                    nullptr)) {
161      return WindowsError(filename_, ::GetLastError());
162    }
163
164    *result = Slice(scratch, bytes_read);
165    return Status::OK();
166  }
167
168  Status Skip(uint64_t n) override {
169    LARGE_INTEGER distance;
170    distance.QuadPart = n;
171    if (!::SetFilePointerEx(handle_.get(), distance, nullptr, FILE_CURRENT)) {
172      return WindowsError(filename_, ::GetLastError());
173    }
174    return Status::OK();
175  }
176
177  std::string GetName() const override { return filename_; }
178
179 private:
180  const ScopedHandle handle_;
181  const std::string filename_;
182};
183
184class WindowsRandomAccessFile : public RandomAccessFile {
185 public:
186  WindowsRandomAccessFile(std::string filename, ScopedHandle handle)
187      : handle_(std::move(handle)), filename_(std::move(filename)) {}
188
189  ~WindowsRandomAccessFile() override = default;
190
191  Status Read(uint64_t offset, size_t n, Slice* result,
192              char* scratch) const override {
193    DWORD bytes_read = 0;
194    OVERLAPPED overlapped = {};
195
196    overlapped.OffsetHigh = static_cast<DWORD>(offset >> 32);
197    overlapped.Offset = static_cast<DWORD>(offset);
198    if (!::ReadFile(handle_.get(), scratch, static_cast<DWORD>(n), &bytes_read,
199                    &overlapped)) {
200      DWORD error_code = ::GetLastError();
201      if (error_code != ERROR_HANDLE_EOF) {
202        *result = Slice(scratch, 0);
203        return Status::IOError(filename_, GetWindowsErrorMessage(error_code));
204      }
205    }
206
207    *result = Slice(scratch, bytes_read);
208    return Status::OK();
209  }
210
211  std::string GetName() const override { return filename_; }
212
213 private:
214  const ScopedHandle handle_;
215  const std::string filename_;
216};
217
218class WindowsMmapReadableFile : public RandomAccessFile {
219 public:
220  // base[0,length-1] contains the mmapped contents of the file.
221  WindowsMmapReadableFile(std::string filename, char* mmap_base, size_t length,
222                          Limiter* mmap_limiter)
223      : mmap_base_(mmap_base),
224        length_(length),
225        mmap_limiter_(mmap_limiter),
226        filename_(std::move(filename)) {}
227
228  ~WindowsMmapReadableFile() override {
229    ::UnmapViewOfFile(mmap_base_);
230    mmap_limiter_->Release();
231  }
232
233  Status Read(uint64_t offset, size_t n, Slice* result,
234              char* scratch) const override {
235    if (offset + n > length_) {
236      *result = Slice();
237      return WindowsError(filename_, ERROR_INVALID_PARAMETER);
238    }
239
240    *result = Slice(mmap_base_ + offset, n);
241    return Status::OK();
242  }
243
244  std::string GetName() const override { return filename_; }
245
246 private:
247  char* const mmap_base_;
248  const size_t length_;
249  Limiter* const mmap_limiter_;
250  const std::string filename_;