@nxtedition/rocksdb 5.2.21 → 5.2.26

package/deps/rocksdb/rocksdb/env/env_basic_test.cc

@@ -17,15 +17,82 @@
 #include "test_util/testharness.h"
 
 namespace ROCKSDB_NAMESPACE {
+namespace {
+using CreateEnvFunc = Env*();
+
+// These functions are used to create the various environments under which this
+// test can execute. These functions are used to allow the test cases to be
+// created without the Env being initialized, thereby eliminating a potential
+// static initialization fiasco/race condition when attempting to get a
+// custom/configured env prior to main being invoked.
+
+static Env* GetDefaultEnv() { return Env::Default(); }
 
-class EnvBasicTestWithParam : public testing::Test,
-                              public ::testing::WithParamInterface<Env*> {
+static Env* GetMockEnv() {
+  static std::unique_ptr<Env> mock_env(MockEnv::Create(Env::Default()));
+  return mock_env.get();
+}
+#ifndef ROCKSDB_LITE
+static Env* NewTestEncryptedEnv(Env* base, const std::string& provider_id) {
+  ConfigOptions config_opts;
+  config_opts.invoke_prepare_options = false;
+
+  std::shared_ptr<EncryptionProvider> provider;
+  EXPECT_OK(EncryptionProvider::CreateFromString(config_opts, provider_id,
+                                                 &provider));
+  return NewEncryptedEnv(base, provider);
+}
+
+static Env* GetCtrEncryptedEnv() {
+  static std::unique_ptr<Env> ctr_encrypt_env(
+      NewTestEncryptedEnv(Env::Default(), "CTR://test"));
+  return ctr_encrypt_env.get();
+}
+
+static Env* GetMemoryEnv() {
+  static std::unique_ptr<Env> mem_env(NewMemEnv(Env::Default()));
+  return mem_env.get();
+}
+
+static Env* GetTestEnv() {
+  static std::shared_ptr<Env> env_guard;
+  static Env* custom_env = nullptr;
+  if (custom_env == nullptr) {
+    const char* uri = getenv("TEST_ENV_URI");
+    if (uri != nullptr) {
+      EXPECT_OK(Env::CreateFromUri(ConfigOptions(), uri, "", &custom_env,
+                                   &env_guard));
+    }
+  }
+  EXPECT_NE(custom_env, nullptr);
+  return custom_env;
+}
+
+static Env* GetTestFS() {
+  static std::shared_ptr<Env> fs_env_guard;
+  static Env* fs_env = nullptr;
+  if (fs_env == nullptr) {
+    const char* uri = getenv("TEST_FS_URI");
+    if (uri != nullptr) {
+      EXPECT_OK(
+          Env::CreateFromUri(ConfigOptions(), uri, "", &fs_env, &fs_env_guard));
+    }
+  }
+  EXPECT_NE(fs_env, nullptr);
+  return fs_env;
+}
+#endif  // ROCKSDB_LITE
+
+}  // namespace
+class EnvBasicTestWithParam
+    : public testing::Test,
+      public ::testing::WithParamInterface<CreateEnvFunc*> {
  public:
   Env* env_;
   const EnvOptions soptions_;
   std::string test_dir_;
 
-  EnvBasicTestWithParam() : env_(GetParam()) {
+  EnvBasicTestWithParam() : env_(GetParam()()) {
     test_dir_ = test::PerThreadDBPath(env_, "env_basic_test");
   }
 
@@ -37,35 +104,22 @@ class EnvBasicTestWithParam : public testing::Test,
 class EnvMoreTestWithParam : public EnvBasicTestWithParam {};
 
 INSTANTIATE_TEST_CASE_P(EnvDefault, EnvBasicTestWithParam,
-                        ::testing::Values(Env::Default()));
+                        ::testing::Values(&GetDefaultEnv));
 INSTANTIATE_TEST_CASE_P(EnvDefault, EnvMoreTestWithParam,
-                        ::testing::Values(Env::Default()));
+                        ::testing::Values(&GetDefaultEnv));
 
-static std::unique_ptr<Env> mock_env(new MockEnv(Env::Default()));
 INSTANTIATE_TEST_CASE_P(MockEnv, EnvBasicTestWithParam,
-                        ::testing::Values(mock_env.get()));
+                        ::testing::Values(&GetMockEnv));
 
 #ifndef ROCKSDB_LITE
-static Env* NewTestEncryptedEnv(Env* base, const std::string& provider_id) {
-  std::shared_ptr<EncryptionProvider> provider;
-  EXPECT_OK(EncryptionProvider::CreateFromString(ConfigOptions(), provider_id,
-                                                 &provider));
-  return NewEncryptedEnv(base, provider);
-}
-
 // next statements run env test against default encryption code.
-static std::unique_ptr<Env> ctr_encrypt_env(NewTestEncryptedEnv(Env::Default(),
-                                                                "test://CTR"));
 INSTANTIATE_TEST_CASE_P(EncryptedEnv, EnvBasicTestWithParam,
-                        ::testing::Values(ctr_encrypt_env.get()));
+                        ::testing::Values(&GetCtrEncryptedEnv));
 INSTANTIATE_TEST_CASE_P(EncryptedEnv, EnvMoreTestWithParam,
-                        ::testing::Values(ctr_encrypt_env.get()));
-#endif  // ROCKSDB_LITE
+                        ::testing::Values(&GetCtrEncryptedEnv));
 
-#ifndef ROCKSDB_LITE
-static std::unique_ptr<Env> mem_env(NewMemEnv(Env::Default()));
 INSTANTIATE_TEST_CASE_P(MemEnv, EnvBasicTestWithParam,
-                        ::testing::Values(mem_env.get()));
+                        ::testing::Values(&GetMemoryEnv));
 
 namespace {
 
@@ -74,20 +128,15 @@ namespace {
 //
 // The purpose of returning an empty vector (instead of nullptr) is that gtest
 // ValuesIn() will skip running tests when given an empty collection.
-std::vector<Env*> GetCustomEnvs() {
-  static Env* custom_env;
-  static bool init = false;
-  if (!init) {
-    init = true;
-    const char* uri = getenv("TEST_ENV_URI");
-    if (uri != nullptr) {
-      Env::LoadEnv(uri, &custom_env);
-    }
+std::vector<CreateEnvFunc*> GetCustomEnvs() {
+  std::vector<CreateEnvFunc*> res;
+  const char* uri = getenv("TEST_ENV_URI");
+  if (uri != nullptr) {
+    res.push_back(&GetTestEnv);
   }
-
-  std::vector<Env*> res;
-  if (custom_env != nullptr) {
-    res.emplace_back(custom_env);
+  uri = getenv("TEST_FS_URI");
+  if (uri != nullptr) {
+    res.push_back(&GetTestFS);
   }
   return res;
 }
@@ -99,7 +148,6 @@ INSTANTIATE_TEST_CASE_P(CustomEnv, EnvBasicTestWithParam,
 
 INSTANTIATE_TEST_CASE_P(CustomEnv, EnvMoreTestWithParam,
                         ::testing::ValuesIn(GetCustomEnvs()));
-
 #endif  // ROCKSDB_LITE
 
 TEST_P(EnvBasicTestWithParam, Basics) {

package/deps/rocksdb/rocksdb/env/env_chroot.cc

@@ -7,28 +7,41 @@
 
 #include "env/env_chroot.h"
 
-#include <errno.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
+#include <errno.h>   // errno
+#include <stdlib.h>  // realpath, free
+#include <unistd.h>  // geteuid
 
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "rocksdb/status.h"
+#include "env/composite_env_wrapper.h"
+#include "env/fs_remap.h"
+#include "rocksdb/utilities/options_type.h"
+#include "util/string_util.h"  // errnoStr
 
 namespace ROCKSDB_NAMESPACE {
+namespace {
+static std::unordered_map<std::string, OptionTypeInfo> chroot_fs_type_info = {
+    {"chroot_dir", {0, OptionType::kString}}};
+}  // namespace
+ChrootFileSystem::ChrootFileSystem(const std::shared_ptr<FileSystem>& base,
+                                   const std::string& chroot_dir)
+    : RemapFileSystem(base), chroot_dir_(chroot_dir) {
+  RegisterOptions("chroot_dir", &chroot_dir_, &chroot_fs_type_info);
+}
 
-class ChrootEnv : public EnvWrapper {
- public:
-  ChrootEnv(Env* base_env, const std::string& chroot_dir)
-      : EnvWrapper(base_env) {
+Status ChrootFileSystem::PrepareOptions(const ConfigOptions& options) {
+  Status s = FileSystemWrapper::PrepareOptions(options);
+  if (!s.ok()) {
+    return s;
+  } else if (chroot_dir_.empty()) {
+    s = Status::InvalidArgument("ChRootFileSystem requires a chroot dir");
+  } else {
+    s = target_->FileExists(chroot_dir_, IOOptions(), nullptr);
+  }
+  if (s.ok()) {
 #if defined(OS_AIX)
     char resolvedName[PATH_MAX];
-    char* real_chroot_dir = realpath(chroot_dir.c_str(), resolvedName);
+    char* real_chroot_dir = realpath(chroot_dir_.c_str(), resolvedName);
 #else
-    char* real_chroot_dir = realpath(chroot_dir.c_str(), nullptr);
+    char* real_chroot_dir = realpath(chroot_dir_.c_str(), nullptr);
 #endif
     // chroot_dir must exist so realpath() returns non-nullptr.
     assert(real_chroot_dir != nullptr);
@@ -37,256 +50,32 @@ class ChrootEnv : public EnvWrapper {
     free(real_chroot_dir);
 #endif
   }
+  return s;
+}
 
-  Status RegisterDbPaths(const std::vector<std::string>& paths) override {
-    std::vector<std::string> encoded_paths;
-    encoded_paths.reserve(paths.size());
-    for (auto& path : paths) {
-      auto status_and_enc_path = EncodePathWithNewBasename(path);
-      if (!status_and_enc_path.first.ok()) {
-        return status_and_enc_path.first;
-      }
-      encoded_paths.emplace_back(status_and_enc_path.second);
-    }
-    return EnvWrapper::Env::RegisterDbPaths(encoded_paths);
-  }
-
-  Status UnregisterDbPaths(const std::vector<std::string>& paths) override {
-    std::vector<std::string> encoded_paths;
-    encoded_paths.reserve(paths.size());
-    for (auto& path : paths) {
-      auto status_and_enc_path = EncodePathWithNewBasename(path);
-      if (!status_and_enc_path.first.ok()) {
-        return status_and_enc_path.first;
-      }
-      encoded_paths.emplace_back(status_and_enc_path.second);
-    }
-    return EnvWrapper::Env::UnregisterDbPaths(encoded_paths);
-  }
-
-  Status NewSequentialFile(const std::string& fname,
-                           std::unique_ptr<SequentialFile>* result,
-                           const EnvOptions& options) override {
-    auto status_and_enc_path = EncodePathWithNewBasename(fname);
-    if (!status_and_enc_path.first.ok()) {
-      return status_and_enc_path.first;
-    }
-    return EnvWrapper::NewSequentialFile(status_and_enc_path.second, result,
-                                         options);
-  }
-
-  Status NewRandomAccessFile(const std::string& fname,
-                             std::unique_ptr<RandomAccessFile>* result,
-                             const EnvOptions& options) override {
-    auto status_and_enc_path = EncodePathWithNewBasename(fname);
-    if (!status_and_enc_path.first.ok()) {
-      return status_and_enc_path.first;
-    }
-    return EnvWrapper::NewRandomAccessFile(status_and_enc_path.second, result,
-                                           options);
-  }
-
-  Status NewWritableFile(const std::string& fname,
-                         std::unique_ptr<WritableFile>* result,
-                         const EnvOptions& options) override {
-    auto status_and_enc_path = EncodePathWithNewBasename(fname);
-    if (!status_and_enc_path.first.ok()) {
-      return status_and_enc_path.first;
-    }
-    return EnvWrapper::NewWritableFile(status_and_enc_path.second, result,
-                                       options);
-  }
-
-  Status ReuseWritableFile(const std::string& fname,
-                           const std::string& old_fname,
-                           std::unique_ptr<WritableFile>* result,
-                           const EnvOptions& options) override {
-    auto status_and_enc_path = EncodePathWithNewBasename(fname);
-    if (!status_and_enc_path.first.ok()) {
-      return status_and_enc_path.first;
-    }
-    auto status_and_old_enc_path = EncodePath(old_fname);
-    if (!status_and_old_enc_path.first.ok()) {
-      return status_and_old_enc_path.first;
-    }
-    return EnvWrapper::ReuseWritableFile(status_and_old_enc_path.second,
-                                         status_and_old_enc_path.second, result,
-                                         options);
-  }
-
-  Status NewRandomRWFile(const std::string& fname,
-                         std::unique_ptr<RandomRWFile>* result,
-                         const EnvOptions& options) override {
-    auto status_and_enc_path = EncodePathWithNewBasename(fname);
-    if (!status_and_enc_path.first.ok()) {
-      return status_and_enc_path.first;
-    }
-    return EnvWrapper::NewRandomRWFile(status_and_enc_path.second, result,
-                                       options);
-  }
-
-  Status NewDirectory(const std::string& dir,
-                      std::unique_ptr<Directory>* result) override {
-    auto status_and_enc_path = EncodePathWithNewBasename(dir);
-    if (!status_and_enc_path.first.ok()) {
-      return status_and_enc_path.first;
-    }
-    return EnvWrapper::NewDirectory(status_and_enc_path.second, result);
-  }
-
-  Status FileExists(const std::string& fname) override {
-    auto status_and_enc_path = EncodePathWithNewBasename(fname);
-    if (!status_and_enc_path.first.ok()) {
-      return status_and_enc_path.first;
-    }
-    return EnvWrapper::FileExists(status_and_enc_path.second);
-  }
-
-  Status GetChildren(const std::string& dir,
-                     std::vector<std::string>* result) override {
-    auto status_and_enc_path = EncodePath(dir);
-    if (!status_and_enc_path.first.ok()) {
-      return status_and_enc_path.first;
-    }
-    return EnvWrapper::GetChildren(status_and_enc_path.second, result);
-  }
-
-  Status GetChildrenFileAttributes(
-      const std::string& dir, std::vector<FileAttributes>* result) override {
-    auto status_and_enc_path = EncodePath(dir);
-    if (!status_and_enc_path.first.ok()) {
-      return status_and_enc_path.first;
-    }
-    return EnvWrapper::GetChildrenFileAttributes(status_and_enc_path.second,
-                                                 result);
-  }
-
-  Status DeleteFile(const std::string& fname) override {
-    auto status_and_enc_path = EncodePath(fname);
-    if (!status_and_enc_path.first.ok()) {
-      return status_and_enc_path.first;
-    }
-    return EnvWrapper::DeleteFile(status_and_enc_path.second);
-  }
-
-  Status CreateDir(const std::string& dirname) override {
-    auto status_and_enc_path = EncodePathWithNewBasename(dirname);
-    if (!status_and_enc_path.first.ok()) {
-      return status_and_enc_path.first;
-    }
-    return EnvWrapper::CreateDir(status_and_enc_path.second);
-  }
-
-  Status CreateDirIfMissing(const std::string& dirname) override {
-    auto status_and_enc_path = EncodePathWithNewBasename(dirname);
-    if (!status_and_enc_path.first.ok()) {
-      return status_and_enc_path.first;
-    }
-    return EnvWrapper::CreateDirIfMissing(status_and_enc_path.second);
-  }
-
-  Status DeleteDir(const std::string& dirname) override {
-    auto status_and_enc_path = EncodePath(dirname);
-    if (!status_and_enc_path.first.ok()) {
-      return status_and_enc_path.first;
-    }
-    return EnvWrapper::DeleteDir(status_and_enc_path.second);
-  }
-
-  Status GetFileSize(const std::string& fname, uint64_t* file_size) override {
-    auto status_and_enc_path = EncodePath(fname);
-    if (!status_and_enc_path.first.ok()) {
-      return status_and_enc_path.first;
-    }
-    return EnvWrapper::GetFileSize(status_and_enc_path.second, file_size);
-  }
-
-  Status GetFileModificationTime(const std::string& fname,
-                                 uint64_t* file_mtime) override {
-    auto status_and_enc_path = EncodePath(fname);
-    if (!status_and_enc_path.first.ok()) {
-      return status_and_enc_path.first;
-    }
-    return EnvWrapper::GetFileModificationTime(status_and_enc_path.second,
-                                               file_mtime);
-  }
-
-  Status RenameFile(const std::string& src, const std::string& dest) override {
-    auto status_and_src_enc_path = EncodePath(src);
-    if (!status_and_src_enc_path.first.ok()) {
-      return status_and_src_enc_path.first;
-    }
-    auto status_and_dest_enc_path = EncodePathWithNewBasename(dest);
-    if (!status_and_dest_enc_path.first.ok()) {
-      return status_and_dest_enc_path.first;
-    }
-    return EnvWrapper::RenameFile(status_and_src_enc_path.second,
-                                  status_and_dest_enc_path.second);
-  }
-
-  Status LinkFile(const std::string& src, const std::string& dest) override {
-    auto status_and_src_enc_path = EncodePath(src);
-    if (!status_and_src_enc_path.first.ok()) {
-      return status_and_src_enc_path.first;
-    }
-    auto status_and_dest_enc_path = EncodePathWithNewBasename(dest);
-    if (!status_and_dest_enc_path.first.ok()) {
-      return status_and_dest_enc_path.first;
-    }
-    return EnvWrapper::LinkFile(status_and_src_enc_path.second,
-                                status_and_dest_enc_path.second);
-  }
-
-  Status LockFile(const std::string& fname, FileLock** lock) override {
-    auto status_and_enc_path = EncodePathWithNewBasename(fname);
-    if (!status_and_enc_path.first.ok()) {
-      return status_and_enc_path.first;
-    }
-    // FileLock subclasses may store path (e.g., PosixFileLock stores it). We
-    // can skip stripping the chroot directory from this path because callers
-    // shouldn't use it.
-    return EnvWrapper::LockFile(status_and_enc_path.second, lock);
-  }
-
-  Status GetTestDirectory(std::string* path) override {
-    // Adapted from PosixEnv's implementation since it doesn't provide a way to
-    // create directory in the chroot.
-    char buf[256];
-    snprintf(buf, sizeof(buf), "/rocksdbtest-%d", static_cast<int>(geteuid()));
-    *path = buf;
-
-    // Directory may already exist, so ignore return
-    return CreateDirIfMissing(*path);
-  }
-
-  Status NewLogger(const std::string& fname,
-                   std::shared_ptr<Logger>* result) override {
-    auto status_and_enc_path = EncodePathWithNewBasename(fname);
-    if (!status_and_enc_path.first.ok()) {
-      return status_and_enc_path.first;
-    }
-    return EnvWrapper::NewLogger(status_and_enc_path.second, result);
-  }
-
-  Status GetAbsolutePath(const std::string& db_path,
-                         std::string* output_path) override {
-    auto status_and_enc_path = EncodePath(db_path);
-    if (!status_and_enc_path.first.ok()) {
-      return status_and_enc_path.first;
-    }
-    return EnvWrapper::GetAbsolutePath(status_and_enc_path.second, output_path);
-  }
+IOStatus ChrootFileSystem::GetTestDirectory(const IOOptions& options,
+                                            std::string* path,
+                                            IODebugContext* dbg) {
+  // Adapted from PosixEnv's implementation since it doesn't provide a way to
+  // create directory in the chroot.
+  char buf[256];
+  snprintf(buf, sizeof(buf), "/rocksdbtest-%d", static_cast<int>(geteuid()));
+  *path = buf;
+
+  // Directory may already exist, so ignore return
+  return CreateDirIfMissing(*path, options, dbg);
+}
 
- private:
   // Returns status and expanded absolute path including the chroot directory.
   // Checks whether the provided path breaks out of the chroot. If it returns
   // non-OK status, the returned path should not be used.
-  std::pair<Status, std::string> EncodePath(const std::string& path) {
-    if (path.empty() || path[0] != '/') {
-      return {Status::InvalidArgument(path, "Not an absolute path"), ""};
-    }
-    std::pair<Status, std::string> res;
-    res.second = chroot_dir_ + path;
+std::pair<IOStatus, std::string> ChrootFileSystem::EncodePath(
+    const std::string& path) {
+  if (path.empty() || path[0] != '/') {
+    return {IOStatus::InvalidArgument(path, "Not an absolute path"), ""};
+  }
+  std::pair<IOStatus, std::string> res;
+  res.second = chroot_dir_ + path;
 #if defined(OS_AIX)
     char resolvedName[PATH_MAX];
     char* normalized_path = realpath(res.second.c_str(), resolvedName);
@@ -294,51 +83,64 @@ class ChrootEnv : public EnvWrapper {
     char* normalized_path = realpath(res.second.c_str(), nullptr);
 #endif
     if (normalized_path == nullptr) {
-      res.first = Status::NotFound(res.second, strerror(errno));
+      res.first = IOStatus::NotFound(res.second, errnoStr(errno).c_str());
     } else if (strlen(normalized_path) < chroot_dir_.size() ||
                strncmp(normalized_path, chroot_dir_.c_str(),
                        chroot_dir_.size()) != 0) {
-      res.first = Status::IOError(res.second,
-                                  "Attempted to access path outside chroot");
+      res.first = IOStatus::IOError(res.second,
+                                    "Attempted to access path outside chroot");
     } else {
-      res.first = Status::OK();
+      res.first = IOStatus::OK();
     }
 #if !defined(OS_AIX)
     free(normalized_path);
 #endif
     return res;
-  }
+}
 
   // Similar to EncodePath() except assumes the basename in the path hasn't been
   // created yet.
-  std::pair<Status, std::string> EncodePathWithNewBasename(
-      const std::string& path) {
-    if (path.empty() || path[0] != '/') {
-      return {Status::InvalidArgument(path, "Not an absolute path"), ""};
-    }
-    // Basename may be followed by trailing slashes
-    size_t final_idx = path.find_last_not_of('/');
-    if (final_idx == std::string::npos) {
-      // It's only slashes so no basename to extract
-      return EncodePath(path);
-    }
+std::pair<IOStatus, std::string> ChrootFileSystem::EncodePathWithNewBasename(
+    const std::string& path) {
+  if (path.empty() || path[0] != '/') {
+    return {IOStatus::InvalidArgument(path, "Not an absolute path"), ""};
+  }
+  // Basename may be followed by trailing slashes
+  size_t final_idx = path.find_last_not_of('/');
+  if (final_idx == std::string::npos) {
+    // It's only slashes so no basename to extract
+    return EncodePath(path);
+  }
+
+  // Pull off the basename temporarily since realname(3) (used by
+  // EncodePath()) requires a path that exists
+  size_t base_sep = path.rfind('/', final_idx);
+  auto status_and_enc_path = EncodePath(path.substr(0, base_sep + 1));
+  status_and_enc_path.second.append(path.substr(base_sep + 1));
+  return status_and_enc_path;
+}
 
-    // Pull off the basename temporarily since realname(3) (used by
-    // EncodePath()) requires a path that exists
-    size_t base_sep = path.rfind('/', final_idx);
-    auto status_and_enc_path = EncodePath(path.substr(0, base_sep + 1));
-    status_and_enc_path.second.append(path.substr(base_sep + 1));
-    return status_and_enc_path;
+std::shared_ptr<FileSystem> NewChrootFileSystem(
+    const std::shared_ptr<FileSystem>& base, const std::string& chroot_dir) {
+  auto chroot_fs = std::make_shared<ChrootFileSystem>(base, chroot_dir);
+  Status s = chroot_fs->PrepareOptions(ConfigOptions());
+  if (s.ok()) {
+    return chroot_fs;
+  } else {
+    return nullptr;
   }
-
-  std::string chroot_dir_;
-};
+}
 
 Env* NewChrootEnv(Env* base_env, const std::string& chroot_dir) {
   if (!base_env->FileExists(chroot_dir).ok()) {
     return nullptr;
   }
-  return new ChrootEnv(base_env, chroot_dir);
+  auto chroot_fs = NewChrootFileSystem(base_env->GetFileSystem(), chroot_dir);
+  if (chroot_fs != nullptr) {
+    return new CompositeEnvWrapper(base_env, chroot_fs);
+  } else {
+    return nullptr;
+  }
 }
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/env/env_chroot.h

@@ -9,13 +9,46 @@
 
 #include <string>
 
-#include "rocksdb/env.h"
+#include "env/fs_remap.h"
+#include "rocksdb/file_system.h"
 
 namespace ROCKSDB_NAMESPACE {
+class ChrootFileSystem : public RemapFileSystem {
+ public:
+  ChrootFileSystem(const std::shared_ptr<FileSystem>& base,
+                   const std::string& chroot_dir);
+
+  static const char* kClassName() { return "ChrootFS"; }
+  const char* Name() const override { return kClassName(); }
+
+  IOStatus GetTestDirectory(const IOOptions& options, std::string* path,
+                            IODebugContext* dbg) override;
+
+  Status PrepareOptions(const ConfigOptions& options) override;
+
+ protected:
+  // Returns status and expanded absolute path including the chroot directory.
+  // Checks whether the provided path breaks out of the chroot. If it returns
+  // non-OK status, the returned path should not be used.
+  std::pair<IOStatus, std::string> EncodePath(const std::string& path) override;
+
+  // Similar to EncodePath() except assumes the basename in the path hasn't been
+  // created yet.
+  std::pair<IOStatus, std::string> EncodePathWithNewBasename(
+      const std::string& path) override;
+
+ private:
+  std::string chroot_dir_;
+};
 
 // Returns an Env that translates paths such that the root directory appears to
 // be chroot_dir. chroot_dir should refer to an existing directory.
+//
+// This class has not been fully analyzed for providing strong security
+// guarantees.
 Env* NewChrootEnv(Env* base_env, const std::string& chroot_dir);
+std::shared_ptr<FileSystem> NewChrootFileSystem(
+    const std::shared_ptr<FileSystem>& base, const std::string& chroot_dir);
 
 }  // namespace ROCKSDB_NAMESPACE