@nxtedition/rocksdb 10.0.13 → 10.0.15

package/deps/rocksdb/rocksdb/env/fs_on_demand.cc

@@ -0,0 +1,331 @@
+// Copyright (c) 2024-present, Facebook, Inc.  All rights reserved.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+
+#include "env/fs_on_demand.h"
+
+#include <algorithm>
+#include <set>
+
+#include "file/filename.h"
+#include "port/port.h"
+#include "rocksdb/types.h"
+
+namespace ROCKSDB_NAMESPACE {
+// Check if the input path is under orig (typically the local directory), and if
+// so, change it to the equivalent path under replace (typically the remote
+// directory). For example, if orig is "/data/follower", replace is
+// "/data/leader", and the given path is "/data/follower/000010.sst", on return
+// the path would be changed to
+// "/data/leader/000010.sst".
+// Return value is true if the path was modified, false otherwise
+bool OnDemandFileSystem::CheckPathAndAdjust(const std::string& orig,
+                                            const std::string& replace,
+                                            std::string& path) {
+  size_t pos = path.find(orig);
+  if (pos > 0) {
+    return false;
+  }
+  path.replace(pos, orig.length(), replace);
+  return true;
+}
+
+bool OnDemandFileSystem::LookupFileType(const std::string& name,
+                                        FileType* type) {
+  std::size_t found = name.find_last_of('/');
+  std::string file_name = name.substr(found);
+  uint64_t number = 0;
+  return ParseFileName(file_name, &number, type);
+}
+
+// RocksDB opens non-SST files for reading in sequential file mode. This
+// includes CURRENT, OPTIONS, MANIFEST etc. For these files, we open them
+// in place in the source directory. For files that are appendable or
+// can be renamed, which is MANIFEST and CURRENT files, we wrap the
+// underlying FSSequentialFile with another class that checks when EOF
+// has been reached and re-opens the file to see the latest data. On some
+// distributed file systems, this is necessary.
+IOStatus OnDemandFileSystem::NewSequentialFile(
+    const std::string& fname, const FileOptions& file_opts,
+    std::unique_ptr<FSSequentialFile>* result, IODebugContext* dbg) {
+  FileType type;
+  static std::unordered_set<FileType> valid_types(
+      {kWalFile, kDescriptorFile, kCurrentFile, kIdentityFile, kOptionsFile});
+  if (!LookupFileType(fname, &type) ||
+      (valid_types.find(type) == valid_types.end())) {
+    return IOStatus::NotSupported();
+  }
+
+  IOStatus s;
+  std::string rname = fname;
+  if (CheckPathAndAdjust(local_path_, remote_path_, rname)) {
+    // First clear any local directory cache as it may be out of date
+    target()->DiscardCacheForDirectory(rname);
+
+    std::unique_ptr<FSSequentialFile> inner_file;
+    s = target()->NewSequentialFile(rname, file_opts, &inner_file, dbg);
+    if (s.ok() && type == kDescriptorFile) {
+      result->reset(new OnDemandSequentialFile(std::move(inner_file), this,
+                                               file_opts, rname));
+    } else {
+      *result = std::move(inner_file);
+    }
+  } else {
+    s = target()->NewSequentialFile(fname, file_opts, result, dbg);
+  }
+  return s;
+}
+
+// This is only supported for SST files. If the file is present locally,
+// i.e in the destination dir, we just open it and return. If its in the
+// remote, i.e source dir, we link it locally and open the link.
+// TODO: Add support for blob files belonging to the new BlobDB
+IOStatus OnDemandFileSystem::NewRandomAccessFile(
+    const std::string& fname, const FileOptions& file_opts,
+    std::unique_ptr<FSRandomAccessFile>* result, IODebugContext* dbg) {
+  FileType type;
+  if (!LookupFileType(fname, &type) || type != kTableFile) {
+    return IOStatus::NotSupported();
+  }
+
+  IOStatus s = target()->FileExists(fname, file_opts.io_options, nullptr);
+  if (s.IsNotFound() || s.IsPathNotFound()) {
+    std::string rname = fname;
+    if (CheckPathAndAdjust(local_path_, remote_path_, rname)) {
+      // First clear any local directory cache as it may be out of date
+      target()->DiscardCacheForDirectory(rname);
+
+      s = target()->LinkFile(rname, fname, IOOptions(), nullptr);
+      if (!s.ok()) {
+        return s;
+      }
+    }
+  }
+
+  return s.ok() ? target()->NewRandomAccessFile(fname, file_opts, result, dbg)
+                : s;
+}
+
+// We don't expect to create any writable file other than info LOG files.
+IOStatus OnDemandFileSystem::NewWritableFile(
+    const std::string& fname, const FileOptions& file_opts,
+    std::unique_ptr<FSWritableFile>* result, IODebugContext* dbg) {
+  FileType type;
+  if (!LookupFileType(fname, &type) || type != kInfoLogFile) {
+    return IOStatus::NotSupported();
+  }
+
+  std::string rname = fname;
+  if (CheckPathAndAdjust(local_path_, remote_path_, rname)) {
+    // First clear any local directory cache as it may be out of date
+    target()->DiscardCacheForDirectory(rname);
+
+    IOStatus s = target()->FileExists(rname, file_opts.io_options, dbg);
+    if (s.ok()) {
+      return IOStatus::InvalidArgument(
+          "Writing to a file present in the remote directory not supoprted");
+    }
+  }
+
+  return target()->NewWritableFile(fname, file_opts, result, dbg);
+}
+
+// Currently not supported, as there's no need for RocksDB to create a
+// directory object for a DB in read-only mode.
+IOStatus OnDemandFileSystem::NewDirectory(
+    const std::string& /*name*/, const IOOptions& /*io_opts*/,
+    std::unique_ptr<FSDirectory>* /*result*/, IODebugContext* /*dbg*/) {
+  return IOStatus::NotSupported();
+}
+
+// Check if the given file exists, either locally or remote. If the file is an
+// SST file, then link it locally. We assume if the file existence is being
+// checked, its for verification purposes, for example while replaying the
+// MANIFEST. The file will be opened for reading  some time in the future.
+IOStatus OnDemandFileSystem::FileExists(const std::string& fname,
+                                        const IOOptions& options,
+                                        IODebugContext* dbg) {
+  IOStatus s = target()->FileExists(fname, options, dbg);
+  if (!s.IsNotFound() && !s.IsPathNotFound()) {
+    return s;
+  }
+
+  std::string rname = fname;
+  if (CheckPathAndAdjust(local_path_, remote_path_, rname)) {
+    // First clear any local directory cache as it may be out of date
+    target()->DiscardCacheForDirectory(rname);
+
+    FileType type;
+    if (LookupFileType(fname, &type) && type == kTableFile) {
+      s = target()->LinkFile(rname, fname, options, dbg);
+    } else {
+      s = target()->FileExists(rname, options, dbg);
+    }
+  }
+  return s;
+}
+
+// Doa listing of both the local and remote directories and merge the two.
+IOStatus OnDemandFileSystem::GetChildren(const std::string& dir,
+                                         const IOOptions& options,
+                                         std::vector<std::string>* result,
+                                         IODebugContext* dbg) {
+  std::string rdir = dir;
+  IOStatus s = target()->GetChildren(dir, options, result, dbg);
+  if (!s.ok() || !CheckPathAndAdjust(local_path_, remote_path_, rdir)) {
+    return s;
+  }
+
+  std::vector<std::string> rchildren;
+  // First clear any local directory cache as it may be out of date
+  target()->DiscardCacheForDirectory(rdir);
+  s = target()->GetChildren(rdir, options, &rchildren, dbg);
+  if (s.ok()) {
+    std::for_each(rchildren.begin(), rchildren.end(), [&](std::string& name) {
+      // Adjust name
+      (void)CheckPathAndAdjust(remote_path_, local_path_, name);
+    });
+    std::sort(result->begin(), result->end());
+    std::sort(rchildren.begin(), rchildren.end());
+
+    std::vector<std::string> output;
+    output.reserve(result->size() + rchildren.size());
+    std::set_union(result->begin(), result->end(), rchildren.begin(),
+                   rchildren.end(), std::back_inserter(output));
+    *result = std::move(output);
+  }
+  return s;
+}
+
+// Doa listing of both the local and remote directories and merge the two.
+IOStatus OnDemandFileSystem::GetChildrenFileAttributes(
+    const std::string& dir, const IOOptions& options,
+    std::vector<FileAttributes>* result, IODebugContext* dbg) {
+  std::string rdir = dir;
+  IOStatus s = target()->GetChildrenFileAttributes(dir, options, result, dbg);
+  if (!s.ok() || !CheckPathAndAdjust(local_path_, remote_path_, rdir)) {
+    return s;
+  }
+
+  std::vector<FileAttributes> rchildren;
+  // First clear any local directory cache as it may be out of date
+  target()->DiscardCacheForDirectory(rdir);
+  s = target()->GetChildrenFileAttributes(rdir, options, &rchildren, dbg);
+  if (s.ok()) {
+    struct FileAttributeSorter {
+      bool operator()(const FileAttributes& lhs, const FileAttributes& rhs) {
+        return lhs.name < rhs.name;
+      }
+    } file_attr_sorter;
+
+    std::for_each(
+        rchildren.begin(), rchildren.end(), [&](FileAttributes& file) {
+          // Adjust name
+          (void)CheckPathAndAdjust(remote_path_, local_path_, file.name);
+        });
+    std::sort(result->begin(), result->end(), file_attr_sorter);
+    std::sort(rchildren.begin(), rchildren.end(), file_attr_sorter);
+
+    std::vector<FileAttributes> output;
+    output.reserve(result->size() + rchildren.size());
+    std::set_union(rchildren.begin(), rchildren.end(), result->begin(),
+                   result->end(), std::back_inserter(output), file_attr_sorter);
+    *result = std::move(output);
+  }
+  return s;
+}
+
+IOStatus OnDemandFileSystem::GetFileSize(const std::string& fname,
+                                         const IOOptions& options,
+                                         uint64_t* file_size,
+                                         IODebugContext* dbg) {
+  uint64_t local_size = 0;
+  IOStatus s = target()->GetFileSize(fname, options, &local_size, dbg);
+  if (!s.ok() && !s.IsNotFound() && !s.IsPathNotFound()) {
+    return s;
+  }
+
+  if (s.IsNotFound() || s.IsPathNotFound()) {
+    std::string rname = fname;
+    if (CheckPathAndAdjust(local_path_, remote_path_, rname)) {
+      // First clear any local directory cache as it may be out of date
+      target()->DiscardCacheForDirectory(rname);
+
+      FileType type;
+      if (LookupFileType(fname, &type) && type == kTableFile) {
+        s = target()->LinkFile(rname, fname, options, dbg);
+        if (s.ok()) {
+          s = target()->GetFileSize(fname, options, &local_size, dbg);
+        }
+      } else {
+        s = target()->GetFileSize(rname, options, &local_size, dbg);
+      }
+    }
+  }
+  *file_size = local_size;
+  return s;
+}
+
+// An implementation of Read that tracks whether we've reached EOF. If so,
+// re-open the file to try to read past the previous EOF offset. After
+// re-opening, positing it back to the last read offset.
+IOStatus OnDemandSequentialFile::Read(size_t n, const IOOptions& options,
+                                      Slice* result, char* scratch,
+                                      IODebugContext* dbg) {
+  IOStatus s;
+  if (eof_) {
+    // Reopen the file. With some distributed file systems, this is required
+    // in order to get the new size
+    file_.reset();
+    s = fs_->NewSequentialFile(path_, file_opts_, &file_, dbg);
+    if (!s.ok()) {
+      return IOStatus::IOError("While opening file after relinking, got error ",
+                               s.ToString());
+    }
+    s = file_->Skip(offset_);
+    if (!s.ok()) {
+      return IOStatus::IOError(
+          "While seeking to offset" + std::to_string(offset_) + "got error",
+          s.ToString());
+    }
+    eof_ = false;
+  }
+
+  s = file_->Read(n, options, result, scratch, dbg);
+  if (s.ok()) {
+    offset_ += result->size();
+    if (result->size() < n) {
+      // We reached EOF. Mark it so we know to relink next time
+      eof_ = true;
+    }
+  }
+  return s;
+}
+
+IOStatus OnDemandSequentialFile::Skip(uint64_t n) {
+  IOStatus s = file_->Skip(n);
+  if (s.ok()) {
+    offset_ += n;
+  }
+  return s;
+}
+
+bool OnDemandSequentialFile::use_direct_io() const {
+  return file_->use_direct_io();
+}
+
+size_t OnDemandSequentialFile::GetRequiredBufferAlignment() const {
+  return file_->GetRequiredBufferAlignment();
+}
+
+Temperature OnDemandSequentialFile::GetTemperature() const {
+  return file_->GetTemperature();
+}
+
+std::shared_ptr<FileSystem> NewOnDemandFileSystem(
+    const std::shared_ptr<FileSystem>& fs, std::string src_path,
+    std::string dest_path) {
+  return std::make_shared<OnDemandFileSystem>(fs, src_path, dest_path);
+}
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/env/fs_on_demand.h

@@ -0,0 +1,139 @@
+// Copyright (c) 2024-present, Facebook, Inc.  All rights reserved.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+
+#pragma once
+#include <string>
+
+#include "rocksdb/file_system.h"
+
+namespace ROCKSDB_NAMESPACE {
+// A FileSystem that links files to a local (destination) directory from a
+// corresponding remote (source) directory on demand. The decision to link
+// depends on the file type, with appendable or rename-able files, such as,
+// descriptors, logs, CURRENT, being read in place in the remote directory,
+// and SST files being linked. In the future, files read in place may be
+// mirrored to the local directory, so the local dir has a complete database
+// for troubleshooting purposes.
+
+class OnDemandFileSystem : public FileSystemWrapper {
+ public:
+  OnDemandFileSystem(const std::shared_ptr<FileSystem>& target,
+                     const std::string& remote_path,
+                     const std::string& local_path)
+      : FileSystemWrapper(target),
+        remote_path_(remote_path),
+        local_path_(local_path) {}
+
+  const char* Name() const override { return "OnDemandFileSystem"; }
+
+  IOStatus NewSequentialFile(const std::string& fname,
+                             const FileOptions& file_opts,
+                             std::unique_ptr<FSSequentialFile>* result,
+                             IODebugContext* dbg) override;
+
+  IOStatus NewRandomAccessFile(const std::string& fname,
+                               const FileOptions& file_opts,
+                               std::unique_ptr<FSRandomAccessFile>* result,
+                               IODebugContext* dbg) override;
+
+  IOStatus NewWritableFile(const std::string& fname,
+                           const FileOptions& file_opts,
+                           std::unique_ptr<FSWritableFile>* result,
+                           IODebugContext* dbg) override;
+
+  IOStatus ReuseWritableFile(const std::string& /*fname*/,
+                             const std::string& /*old_fname*/,
+                             const FileOptions& /*fopts*/,
+                             std::unique_ptr<FSWritableFile>* /*result*/,
+                             IODebugContext* /*dbg*/) override {
+    return IOStatus::NotSupported("ReuseWritableFile");
+  }
+
+  IOStatus NewDirectory(const std::string& name, const IOOptions& io_opts,
+                        std::unique_ptr<FSDirectory>* result,
+                        IODebugContext* dbg) override;
+
+  IOStatus FileExists(const std::string& fname, const IOOptions& options,
+                      IODebugContext* dbg) override;
+
+  IOStatus GetChildren(const std::string& dir, const IOOptions& options,
+                       std::vector<std::string>* result,
+                       IODebugContext* dbg) override;
+
+  IOStatus GetChildrenFileAttributes(const std::string& dir,
+                                     const IOOptions& options,
+                                     std::vector<FileAttributes>* result,
+                                     IODebugContext* dbg) override;
+
+  IOStatus GetFileSize(const std::string& fname, const IOOptions& options,
+                       uint64_t* file_size, IODebugContext* dbg) override;
+
+ private:
+  bool CheckPathAndAdjust(const std::string& orig, const std::string& replace,
+                          std::string& path);
+  bool LookupFileType(const std::string& name, FileType* type);
+
+  const std::string remote_path_;
+  const std::string local_path_;
+};
+
+// A wrapper class around an FSSequentialFile object. Its mainly
+// intended to be used for appendable files like MANIFEST and logs.
+// Beneath the covers, it tracks when EOF is reached, and reopens
+// the file in order to read the latest appended data. This is
+// necessary on some distributed file systems as they may have
+// stale metadata about the file.
+// TODO: Mirror the data read to a local file for troubleshooting
+//       purposes, as well as recovery in case the source dir is
+//       deleted.
+class OnDemandSequentialFile : public FSSequentialFile {
+ public:
+  OnDemandSequentialFile(std::unique_ptr<FSSequentialFile>&& file,
+                         OnDemandFileSystem* fs, const FileOptions& file_opts,
+                         const std::string& path)
+      : file_(std::move(file)),
+        fs_(fs),
+        file_opts_(file_opts),
+        path_(path),
+        eof_(false),
+        offset_(0) {}
+
+  virtual ~OnDemandSequentialFile() {}
+
+  IOStatus Read(size_t n, const IOOptions& options, Slice* result,
+                char* scratch, IODebugContext* dbg) override;
+
+  IOStatus Skip(uint64_t n) override;
+
+  bool use_direct_io() const override;
+
+  size_t GetRequiredBufferAlignment() const override;
+
+  IOStatus InvalidateCache(size_t /*offset*/, size_t /*length*/) override {
+    return IOStatus::NotSupported("InvalidateCache not supported.");
+  }
+
+  IOStatus PositionedRead(uint64_t /*offset*/, size_t /*n*/,
+                          const IOOptions& /*options*/, Slice* /*result*/,
+                          char* /*scratch*/, IODebugContext* /*dbg*/) override {
+    return IOStatus::NotSupported("PositionedRead");
+  }
+
+  Temperature GetTemperature() const override;
+
+ private:
+  std::unique_ptr<FSSequentialFile> file_;
+  OnDemandFileSystem* fs_;
+  const FileOptions file_opts_;
+  const std::string path_;
+  bool eof_;
+  uint64_t offset_;
+};
+
+std::shared_ptr<FileSystem> NewOnDemandFileSystem(
+    const std::shared_ptr<FileSystem>& fs, std::string remote_path,
+    std::string local_path);
+
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/env/fs_posix.cc

@@ -13,16 +13,17 @@
 #ifndef ROCKSDB_NO_DYNAMIC_EXTENSION
 #include <dlfcn.h>
 #endif
-#include <errno.h>
 #include <fcntl.h>
 #include <pthread.h>
-#include <signal.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
+
+#include <cerrno>
+#include <csignal>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
 #if defined(OS_LINUX) || defined(OS_SOLARIS) || defined(OS_ANDROID)
 #include <sys/statfs.h>
 #include <sys/sysmacros.h>
@@ -30,9 +31,9 @@
 #include <sys/statvfs.h>
 #include <sys/time.h>
 #include <sys/types.h>
-#include <time.h>
 
 #include <algorithm>
+#include <ctime>
 // Get nano time includes
 #if defined(OS_LINUX) || defined(OS_FREEBSD)
 #elif defined(__MACH__)
@@ -115,7 +116,7 @@ class PosixFileLock : public FileLock {
     filename.clear();
   }
 
-  virtual ~PosixFileLock() override {
+  ~PosixFileLock() override {
     // Check for destruction without UnlockFile
     assert(fd_ == -1);
   }
@@ -143,7 +144,7 @@ class PosixFileSystem : public FileSystem {
   const char* Name() const override { return kClassName(); }
   const char* NickName() const override { return kDefaultName(); }
 
-  ~PosixFileSystem() override {}
+  ~PosixFileSystem() override = default;
   bool IsInstanceOf(const std::string& name) const override {
     if (name == "posix") {
       return true;
@@ -805,7 +806,7 @@ class PosixFileSystem : public FileSystem {
 
   IOStatus UnlockFile(FileLock* lock, const IOOptions& /*opts*/,
                       IODebugContext* /*dbg*/) override {
-    PosixFileLock* my_lock = reinterpret_cast<PosixFileLock*>(lock);
+    PosixFileLock* my_lock = static_cast<PosixFileLock*>(lock);
     IOStatus result;
     mutex_locked_files.Lock();
     // If we are unlocking, then verify that we had locked it earlier,
@@ -997,16 +998,14 @@ class PosixFileSystem : public FileSystem {
   }
 #endif  // ROCKSDB_IOURING_PRESENT
 
-  // EXPERIMENTAL
-  //
-  // TODO akankshamahajan:
+  // TODO:
   // 1. Update Poll API to take into account min_completions
   // and returns if number of handles in io_handles (any order) completed is
   // equal to atleast min_completions.
   // 2. Currently in case of direct_io, Read API is called because of which call
   // to Poll API fails as it expects IOHandle to be populated.
-  virtual IOStatus Poll(std::vector<void*>& io_handles,
-                        size_t /*min_completions*/) override {
+  IOStatus Poll(std::vector<void*>& io_handles,
+                size_t /*min_completions*/) override {
 #if defined(ROCKSDB_IOURING_PRESENT)
     // io_uring_queue_init.
     struct io_uring* iu = nullptr;
@@ -1078,7 +1077,7 @@ class PosixFileSystem : public FileSystem {
 #endif
   }
 
-  virtual IOStatus AbortIO(std::vector<void*>& io_handles) override {
+  IOStatus AbortIO(std::vector<void*>& io_handles) override {
 #if defined(ROCKSDB_IOURING_PRESENT)
     // io_uring_queue_init.
     struct io_uring* iu = nullptr;

package/deps/rocksdb/rocksdb/env/io_posix.cc

@@ -10,23 +10,24 @@
 #ifdef ROCKSDB_LIB_IO_POSIX
 #include "env/io_posix.h"
 
-#include <errno.h>
 #include <fcntl.h>
 
 #include <algorithm>
+#include <cerrno>
 #if defined(OS_LINUX)
 #include <linux/fs.h>
 #ifndef FALLOC_FL_KEEP_SIZE
 #include <linux/falloc.h>
 #endif
 #endif
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
 #ifdef OS_LINUX
 #include <sys/statfs.h>
 #include <sys/sysmacros.h>
@@ -437,7 +438,7 @@ void LogicalBlockSizeCache::UnrefAndTryRemoveCachedLogicalBlockSize(
 
 size_t LogicalBlockSizeCache::GetLogicalBlockSize(const std::string& fname,
                                                   int fd) {
-  std::string dir = fname.substr(0, fname.find_last_of("/"));
+  std::string dir = fname.substr(0, fname.find_last_of('/'));
   if (dir.empty()) {
     dir = "/";
   }
@@ -654,7 +655,9 @@ IOStatus PosixRandomAccessFile::MultiRead(FSReadRequest* reqs, size_t num_reqs,
     size_t this_reqs = (num_reqs - reqs_off) + incomplete_rq_list.size();
 
     // If requests exceed depth, split it into batches
-    if (this_reqs > kIoUringDepth) this_reqs = kIoUringDepth;
+    if (this_reqs > kIoUringDepth) {
+      this_reqs = kIoUringDepth;
+    }
 
     assert(incomplete_rq_list.size() <= this_reqs);
     for (size_t i = 0; i < this_reqs; i++) {
@@ -854,7 +857,7 @@ IOStatus PosixRandomAccessFile::InvalidateCache(size_t offset, size_t length) {
 
 IOStatus PosixRandomAccessFile::ReadAsync(
     FSReadRequest& req, const IOOptions& /*opts*/,
-    std::function<void(const FSReadRequest&, void*)> cb, void* cb_arg,
+    std::function<void(FSReadRequest&, void*)> cb, void* cb_arg,
     void** io_handle, IOHandleDeleter* del_fn, IODebugContext* /*dbg*/) {
   if (use_direct_io()) {
     assert(IsSectorAligned(req.offset, GetRequiredBufferAlignment()));
@@ -965,7 +968,7 @@ IOStatus PosixMmapReadableFile::Read(uint64_t offset, size_t n,
   } else if (offset + n > length_) {
     n = static_cast<size_t>(length_ - offset);
   }
-  *result = Slice(reinterpret_cast<char*>(mmapped_region_) + offset, n);
+  *result = Slice(static_cast<char*>(mmapped_region_) + offset, n);
   return s;
 }
 
@@ -1064,7 +1067,7 @@ IOStatus PosixMmapFile::MapNewRegion() {
   }
   TEST_KILL_RANDOM("PosixMmapFile::Append:2");
 
-  base_ = reinterpret_cast<char*>(ptr);
+  base_ = static_cast<char*>(ptr);
   limit_ = base_ + map_size_;
   dst_ = base_;
   last_sync_ = base_;
@@ -1438,10 +1441,12 @@ void PosixWritableFile::SetWriteLifeTimeHint(Env::WriteLifeTimeHint hint) {
 #ifdef OS_LINUX
 // Suppress Valgrind "Unimplemented functionality" error.
 #ifndef ROCKSDB_VALGRIND_RUN
+  uint64_t fcntl_hint = hint;
+
   if (hint == write_hint_) {
     return;
   }
-  if (fcntl(fd_, F_SET_RW_HINT, &hint) == 0) {
+  if (fcntl(fd_, F_SET_RW_HINT, &fcntl_hint) == 0) {
     write_hint_ = hint;
   }
 #else