Inside Bitcoin

251  Limiter* const mmap_limiter_;
252  const std::string filename_;
253};
254
255class PosixWritableFile final : public WritableFile {
256 public:
257  PosixWritableFile(std::string filename, int fd)
258      : pos_(0),
259        fd_(fd),
260        is_manifest_(IsManifest(filename)),
261        filename_(std::move(filename)),
262        dirname_(Dirname(filename_)) {}
263
264  ~PosixWritableFile() override {
265    if (fd_ >= 0) {
266      // Ignoring any potential errors
267      Close();
268    }
269  }
270
271  Status Append(const Slice& data) override {
272    size_t write_size = data.size();
273    const char* write_data = data.data();
274
275    // Fit as much as possible into buffer.
276    size_t copy_size = std::min(write_size, kWritableFileBufferSize - pos_);
277    std::memcpy(buf_ + pos_, write_data, copy_size);
278    write_data += copy_size;
279    write_size -= copy_size;
280    pos_ += copy_size;
281    if (write_size == 0) {
282      return Status::OK();
283    }
284
285    // Can't fit in buffer, so need to do at least one write.
286    Status status = FlushBuffer();
287    if (!status.ok()) {
288      return status;
289    }
290
291    // Small writes go to buffer, large writes are written directly.
292    if (write_size < kWritableFileBufferSize) {
293      std::memcpy(buf_, write_data, write_size);
294      pos_ = write_size;
295      return Status::OK();
296    }
297    return WriteUnbuffered(write_data, write_size);
298  }
299
300  Status Close() override {
301    Status status = FlushBuffer();
302    const int close_result = ::close(fd_);
303    if (close_result < 0 && status.ok()) {
304      status = PosixError(filename_, errno);
305    }
306    fd_ = -1;
307    return status;
308  }
309
310  Status Flush() override { return FlushBuffer(); }
311
312  Status Sync() override {
313    // Ensure new files referred to by the manifest are in the filesystem.
314    //
315    // This needs to happen before the manifest file is flushed to disk, to
316    // avoid crashing in a state where the manifest refers to files that are not
317    // yet on disk.
318    Status status = SyncDirIfManifest();
319    if (!status.ok()) {
320      return status;
321    }
322
323    status = FlushBuffer();
324    if (!status.ok()) {
325      return status;
326    }
327
328    return SyncFd(fd_, filename_, false);
329  }
330
331 private:
332  Status FlushBuffer() {
333    Status status = WriteUnbuffered(buf_, pos_);
334    pos_ = 0;
335    return status;
336  }
337
338  Status WriteUnbuffered(const char* data, size_t size) {
339    while (size > 0) {
340      ssize_t write_result = ::write(fd_, data, size);
341      if (write_result < 0) {
342        if (errno == EINTR) {
343          continue;  // Retry
344        }
345        return PosixError(filename_, errno);
346      }
347      data += write_result;
348      size -= write_result;
349    }
350    return Status::OK();
351  }
352
353  Status SyncDirIfManifest() {
354    Status status;
355    if (!is_manifest_) {
356      return status;
357    }
358
359    int fd = ::open(dirname_.c_str(), O_RDONLY | kOpenBaseFlags);
360    if (fd < 0) {
361      status = PosixError(dirname_, errno);
362    } else {
363      status = SyncFd(fd, dirname_, true);
364      ::close(fd);
365    }
366    return status;
367  }
368
369  // Ensures that all the caches associated with the given file descriptor's
370  // data are flushed all the way to durable media, and can withstand power
371  // failures.
372  //
373  // The path argument is only used to populate the description string in the
374  // returned Status if an error occurs.
375  static Status SyncFd(int fd, const std::string& fd_path, bool syncing_dir) {
376#if HAVE_FULLFSYNC
377    // On macOS and iOS, fsync() doesn't guarantee durability past power
378    // failures. fcntl(F_FULLFSYNC) is required for that purpose. Some
379    // filesystems don't support fcntl(F_FULLFSYNC), and require a fallback to
380    // fsync().
381    if (::fcntl(fd, F_FULLFSYNC) == 0) {
382      return Status::OK();
383    }
384#endif  // HAVE_FULLFSYNC
385
386#if HAVE_FDATASYNC
387    bool sync_success = ::fdatasync(fd) == 0;
388#else
389    bool sync_success = ::fsync(fd) == 0;
390#endif  // HAVE_FDATASYNC
391
392    if (sync_success) {
393      return Status::OK();
394    }
395    // Do not crash if filesystem can't fsync directories
396    // (see https://github.com/bitcoin/bitcoin/pull/10000)
397    if (syncing_dir && errno == EINVAL) {
398      return Status::OK();
399    }
400    return PosixError(fd_path, errno);
401  }
402
403  // Returns the directory name in a path pointing to a file.
404  //
405  // Returns "." if the path does not contain any directory separator.
406  static std::string Dirname(const std::string& filename) {
407    std::string::size_type separator_pos = filename.rfind('/');
408    if (separator_pos == std::string::npos) {
409      return std::string(".");
410    }
411    // The filename component should not contain a path separator. If it does,
412    // the splitting was done incorrectly.
413    assert(filename.find('/', separator_pos + 1) == std::string::npos);
414
415    return filename.substr(0, separator_pos);
416  }
417
418  // Extracts the file name from a path pointing to a file.
419  //
420  // The returned Slice points to |filename|'s data buffer, so it is only valid
421  // while |filename| is alive and unchanged.
422  static Slice Basename(const std::string& filename) {
423    std::string::size_type separator_pos = filename.rfind('/');
424    if (separator_pos == std::string::npos) {
425      return Slice(filename);
426    }
427    // The filename component should not contain a path separator. If it does,
428    // the splitting was done incorrectly.
429    assert(filename.find('/', separator_pos + 1) == std::string::npos);
430
431    return Slice(filename.data() + separator_pos + 1,
432                 filename.length() - separator_pos - 1);
433  }
434
435  // True if the given file is a manifest file.
436  static bool IsManifest(const std::string& filename) {
437    return Basename(filename).starts_with("MANIFEST");
438  }
439
440  virtual std::string GetName() const override { return filename_; }
441
442  // buf_[0, pos_ - 1] contains data to be written to fd_.
443  char buf_[kWritableFileBufferSize];
444  size_t pos_;
445  int fd_;
446
447  const bool is_manifest_;  // True if the file's name starts with MANIFEST.
448  const std::string filename_;
449  const std::string dirname_;  // The directory of filename_.
450};
451
452int LockOrUnlock(int fd, bool lock) {
453  errno = 0;
454  struct ::flock file_lock_info;
455  std::memset(&file_lock_info, 0, sizeof(file_lock_info));
456  file_lock_info.l_type = (lock ? F_WRLCK : F_UNLCK);
457  file_lock_info.l_whence = SEEK_SET;
458  file_lock_info.l_start = 0;
459  file_lock_info.l_len = 0;  // Lock/unlock entire file.
460  return ::fcntl(fd, F_SETLK, &file_lock_info);
461}
462
463// Instances are thread-safe because they are immutable.
464class PosixFileLock : public FileLock {
465 public:
466  PosixFileLock(int fd, std::string filename)
467      : fd_(fd), filename_(std::move(filename)) {}
468
469  int fd() const { return fd_; }
470  const std::string& filename() const { return filename_; }
471
472 private:
473  const int fd_;
474  const std::string filename_;
475};
476
477// Tracks the files locked by PosixEnv::LockFile().
478//
479// We maintain a separate set instead of relying on fcntl(F_SETLK) because
480// fcntl(F_SETLK) does not provide any protection against multiple uses from the
481// same process.
482//
483// Instances are thread-safe because all member data is guarded by a mutex.
484class PosixLockTable {
485 public:
486  bool Insert(const std::string& fname) LOCKS_EXCLUDED(mu_) {
487    mu_.Lock();
488    bool succeeded = locked_files_.insert(fname).second;
489    mu_.Unlock();
490    return succeeded;
491  }
492  void Remove(const std::string& fname) LOCKS_EXCLUDED(mu_) {
493    mu_.Lock();
494    locked_files_.erase(fname);
495    mu_.Unlock();
496  }
497
498 private:
499  port::Mutex mu_;
500  std::set<std::string> locked_files_ GUARDED_BY(mu_);