Adding upstream version 18.2.2.upstream/18.2.2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 402 insertions, 0 deletions

diff --git a/src/rgw/rgw_sal.cc b/src/rgw/rgw_sal.cc
new file mode 100644
index 000000000..58a21f707
--- /dev/null
+++ b/src/rgw/rgw_sal.cc
@@ -0,0 +1,402 @@
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab ft=cpp
+
+/*
+ * Ceph - scalable distributed file system
+ *
+ * Copyright (C) 2019 Red Hat, Inc.
+ *
+ * This is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software
+ * Foundation. See file COPYING.
+ *
+ */
+
+#include <errno.h>
+#include <stdlib.h>
+#include <system_error>
+#include <unistd.h>
+#include <sstream>
+
+#include "common/errno.h"
+
+#include "rgw_sal.h"
+#include "rgw_sal_rados.h"
+#include "driver/rados/config/store.h"
+#include "driver/json_config/store.h"
+#include "rgw_d3n_datacache.h"
+
+#ifdef WITH_RADOSGW_DBSTORE
+#include "rgw_sal_dbstore.h"
+#include "driver/dbstore/config/store.h"
+#endif
+
+#ifdef WITH_RADOSGW_MOTR
+#include "rgw_sal_motr.h"
+#endif
+
+#ifdef WITH_RADOSGW_DAOS
+#include "rgw_sal_daos.h"
+#endif
+
+#define dout_subsys ceph_subsys_rgw
+
+extern "C" {
+extern rgw::sal::Driver* newRadosStore(void);
+#ifdef WITH_RADOSGW_DBSTORE
+extern rgw::sal::Driver* newDBStore(CephContext *cct);
+#endif
+#ifdef WITH_RADOSGW_MOTR
+extern rgw::sal::Driver* newMotrStore(CephContext *cct);
+#endif
+#ifdef WITH_RADOSGW_DAOS
+extern rgw::sal::Driver* newDaosStore(CephContext *cct);
+#endif
+extern rgw::sal::Driver* newBaseFilter(rgw::sal::Driver* next);
+
+}
+
+RGWObjState::RGWObjState() {
+}
+
+RGWObjState::~RGWObjState() {
+}
+
+RGWObjState::RGWObjState(const RGWObjState& rhs) : obj (rhs.obj) {
+  is_atomic = rhs.is_atomic;
+  has_attrs = rhs.has_attrs;
+  exists = rhs.exists;
+  size = rhs.size;
+  accounted_size = rhs.accounted_size;
+  mtime = rhs.mtime;
+  epoch = rhs.epoch;
+  if (rhs.obj_tag.length()) {
+    obj_tag = rhs.obj_tag;
+  }
+  if (rhs.tail_tag.length()) {
+    tail_tag = rhs.tail_tag;
+  }
+  write_tag = rhs.write_tag;
+  fake_tag = rhs.fake_tag;
+  shadow_obj = rhs.shadow_obj;
+  has_data = rhs.has_data;
+  if (rhs.data.length()) {
+    data = rhs.data;
+  }
+  prefetch_data = rhs.prefetch_data;
+  keep_tail = rhs.keep_tail;
+  is_olh = rhs.is_olh;
+  objv_tracker = rhs.objv_tracker;
+  pg_ver = rhs.pg_ver;
+  compressed = rhs.compressed;
+}
+
+rgw::sal::Driver* DriverManager::init_storage_provider(const DoutPrefixProvider* dpp,
+						     CephContext* cct,
+						     const Config& cfg,
+						     bool use_gc_thread,
+						     bool use_lc_thread,
+						     bool quota_threads,
+						     bool run_sync_thread,
+						     bool run_reshard_thread,
+						     bool use_cache,
+						     bool use_gc)
+{
+  rgw::sal::Driver* driver{nullptr};
+
+  if (cfg.store_name.compare("rados") == 0) {
+    driver = newRadosStore();
+    RGWRados* rados = static_cast<rgw::sal::RadosStore* >(driver)->getRados();
+
+    if ((*rados).set_use_cache(use_cache)
+                .set_use_datacache(false)
+                .set_use_gc(use_gc)
+                .set_run_gc_thread(use_gc_thread)
+                .set_run_lc_thread(use_lc_thread)
+                .set_run_quota_threads(quota_threads)
+                .set_run_sync_thread(run_sync_thread)
+                .set_run_reshard_thread(run_reshard_thread)
+                .init_begin(cct, dpp) < 0) {
+      delete driver;
+      return nullptr;
+    }
+    if (driver->initialize(cct, dpp) < 0) {
+      delete driver;
+      return nullptr;
+    }
+    if (rados->init_complete(dpp) < 0) {
+      delete driver;
+      return nullptr;
+    }
+  }
+  else if (cfg.store_name.compare("d3n") == 0) {
+    driver = new rgw::sal::RadosStore();
+    RGWRados* rados = new D3nRGWDataCache<RGWRados>;
+    dynamic_cast<rgw::sal::RadosStore*>(driver)->setRados(rados);
+    rados->set_store(static_cast<rgw::sal::RadosStore* >(driver));
+
+    if ((*rados).set_use_cache(use_cache)
+                .set_use_datacache(true)
+                .set_run_gc_thread(use_gc_thread)
+                .set_run_lc_thread(use_lc_thread)
+                .set_run_quota_threads(quota_threads)
+                .set_run_sync_thread(run_sync_thread)
+                .set_run_reshard_thread(run_reshard_thread)
+                .init_begin(cct, dpp) < 0) {
+      delete driver;
+      return nullptr;
+    }
+    if (driver->initialize(cct, dpp) < 0) {
+      delete driver;
+      return nullptr;
+    }
+    if (rados->init_complete(dpp) < 0) {
+      delete driver;
+      return nullptr;
+    }
+
+    lsubdout(cct, rgw, 1) << "rgw_d3n: rgw_d3n_l1_local_datacache_enabled=" <<
+      cct->_conf->rgw_d3n_l1_local_datacache_enabled << dendl;
+    lsubdout(cct, rgw, 1) << "rgw_d3n: rgw_d3n_l1_datacache_persistent_path='" <<
+      cct->_conf->rgw_d3n_l1_datacache_persistent_path << "'" << dendl;
+    lsubdout(cct, rgw, 1) << "rgw_d3n: rgw_d3n_l1_datacache_size=" <<
+      cct->_conf->rgw_d3n_l1_datacache_size << dendl;
+    lsubdout(cct, rgw, 1) << "rgw_d3n: rgw_d3n_l1_evict_cache_on_start=" <<
+      cct->_conf->rgw_d3n_l1_evict_cache_on_start << dendl;
+    lsubdout(cct, rgw, 1) << "rgw_d3n: rgw_d3n_l1_fadvise=" <<
+      cct->_conf->rgw_d3n_l1_fadvise << dendl;
+    lsubdout(cct, rgw, 1) << "rgw_d3n: rgw_d3n_l1_eviction_policy=" <<
+      cct->_conf->rgw_d3n_l1_eviction_policy << dendl;
+  }
+#ifdef WITH_RADOSGW_DBSTORE
+  else if (cfg.store_name.compare("dbstore") == 0) {
+    driver = newDBStore(cct);
+
+    if ((*(rgw::sal::DBStore*)driver).set_run_lc_thread(use_lc_thread)
+                                    .initialize(cct, dpp) < 0) {
+      delete driver;
+      return nullptr;
+    }
+  }
+#endif
+
+#ifdef WITH_RADOSGW_MOTR
+  else if (cfg.store_name.compare("motr") == 0) {
+    driver = newMotrStore(cct);
+    if (driver == nullptr) {
+      ldpp_dout(dpp, 0) << "newMotrStore() failed!" << dendl;
+      return driver;
+    }
+    ((rgw::sal::MotrStore *)driver)->init_metadata_cache(dpp, cct);
+
+    return store;
+  }
+#endif
+
+#ifdef WITH_RADOSGW_DAOS
+  else if (cfg.store_name.compare("daos") == 0) {
+    driver = newDaosStore(cct);
+    if (driver == nullptr) {
+      ldpp_dout(dpp, 0) << "newDaosStore() failed!" << dendl;
+      return driver;
+    }
+    int ret = driver->initialize(cct, dpp);
+    if (ret != 0) {
+      ldpp_dout(dpp, 20) << "ERROR: store->initialize() failed: " << ret << dendl;
+      delete driver;
+      return nullptr;
+    }
+  }
+#endif
+
+  if (cfg.filter_name.compare("base") == 0) {
+    rgw::sal::Driver* next = driver;
+    driver = newBaseFilter(next);
+
+    if (driver->initialize(cct, dpp) < 0) {
+      delete driver;
+      delete next;
+      return nullptr;
+    }
+  }
+
+  return driver;
+}
+
+rgw::sal::Driver* DriverManager::init_raw_storage_provider(const DoutPrefixProvider* dpp, CephContext* cct, const Config& cfg)
+{
+  rgw::sal::Driver* driver = nullptr;
+  if (cfg.store_name.compare("rados") == 0) {
+    driver = newRadosStore();
+    RGWRados* rados = static_cast<rgw::sal::RadosStore* >(driver)->getRados();
+
+    rados->set_context(cct);
+
+    int ret = rados->init_svc(true, dpp);
+    if (ret < 0) {
+      ldout(cct, 0) << "ERROR: failed to init services (ret=" << cpp_strerror(-ret) << ")" << dendl;
+      delete driver;
+      return nullptr;
+    }
+
+    if (rados->init_rados() < 0) {
+      delete driver;
+      return nullptr;
+    }
+    if (driver->initialize(cct, dpp) < 0) {
+      delete driver;
+      return nullptr;
+    }
+  } else if (cfg.store_name.compare("dbstore") == 0) {
+#ifdef WITH_RADOSGW_DBSTORE
+    driver = newDBStore(cct);
+
+    if ((*(rgw::sal::DBStore*)driver).initialize(cct, dpp) < 0) {
+      delete driver;
+      return nullptr;
+    }
+#else
+    driver = nullptr;
+#endif
+  } else if (cfg.store_name.compare("motr") == 0) {
+#ifdef WITH_RADOSGW_MOTR
+    driver = newMotrStore(cct);
+#else
+    driver = nullptr;
+#endif
+  } else if (cfg.store_name.compare("daos") == 0) {
+#ifdef WITH_RADOSGW_DAOS
+    driver = newDaosStore(cct);
+
+    if (driver->initialize(cct, dpp) < 0) {
+      delete driver;
+      return nullptr;
+    }
+#else
+    driver = nullptr;
+#endif
+  }
+
+  if (cfg.filter_name.compare("base") == 0) {
+    rgw::sal::Driver* next = driver;
+    driver = newBaseFilter(next);
+
+    if (driver->initialize(cct, dpp) < 0) {
+      delete driver;
+      delete next;
+      return nullptr;
+    }
+  }
+
+  return driver;
+}
+
+void DriverManager::close_storage(rgw::sal::Driver* driver)
+{
+  if (!driver)
+    return;
+
+  driver->finalize();
+
+  delete driver;
+}
+
+DriverManager::Config DriverManager::get_config(bool admin, CephContext* cct)
+{
+  DriverManager::Config cfg;
+
+  // Get the store backend
+  const auto& config_store = g_conf().get_val<std::string>("rgw_backend_store");
+  if (config_store == "rados") {
+    cfg.store_name = "rados";
+
+    /* Check to see if d3n is configured, but only for non-admin */
+    const auto& d3n = g_conf().get_val<bool>("rgw_d3n_l1_local_datacache_enabled");
+    if (!admin && d3n) {
+      if (g_conf().get_val<Option::size_t>("rgw_max_chunk_size") !=
+	  g_conf().get_val<Option::size_t>("rgw_obj_stripe_size")) {
+	lsubdout(cct, rgw_datacache, 0) << "rgw_d3n:  WARNING: D3N DataCache disabling (D3N requires that the chunk_size equals stripe_size)" << dendl;
+      } else if (!g_conf().get_val<bool>("rgw_beast_enable_async")) {
+	lsubdout(cct, rgw_datacache, 0) << "rgw_d3n:  WARNING: D3N DataCache disabling (D3N requires yield context - rgw_beast_enable_async=true)" << dendl;
+      } else {
+	cfg.store_name = "d3n";
+      }
+    }
+  }
+#ifdef WITH_RADOSGW_DBSTORE
+  else if (config_store == "dbstore") {
+    cfg.store_name = "dbstore";
+  }
+#endif
+#ifdef WITH_RADOSGW_MOTR
+  else if (config_store == "motr") {
+    cfg.store_name = "motr";
+  }
+#endif
+#ifdef WITH_RADOSGW_DAOS
+  else if (config_store == "daos") {
+    cfg.store_name = "daos";
+  }
+#endif
+
+  // Get the filter
+  cfg.filter_name = "none";
+  const auto& config_filter = g_conf().get_val<std::string>("rgw_filter");
+  if (config_filter == "base") {
+    cfg.filter_name = "base";
+  }
+
+  return cfg;
+}
+
+auto DriverManager::create_config_store(const DoutPrefixProvider* dpp,
+                                       std::string_view type)
+  -> std::unique_ptr<rgw::sal::ConfigStore>
+{
+  try {
+    if (type == "rados") {
+      return rgw::rados::create_config_store(dpp);
+#ifdef WITH_RADOSGW_DBSTORE
+    } else if (type == "dbstore") {
+      const auto uri = g_conf().get_val<std::string>("dbstore_config_uri");
+      return rgw::dbstore::create_config_store(dpp, uri);
+#endif
+    } else if (type == "json") {
+      auto filename = g_conf().get_val<std::string>("rgw_json_config");
+      return rgw::sal::create_json_config_store(dpp, filename);
+    } else {
+      ldpp_dout(dpp, -1) << "ERROR: unrecognized config store type '"
+          << type << "'" << dendl;
+      return nullptr;
+    }
+  } catch (const std::exception& e) {
+    ldpp_dout(dpp, -1) << "ERROR: failed to initialize config store '"
+        << type << "': " << e.what() << dendl;
+  }
+  return nullptr;
+}
+
+namespace rgw::sal {
+int Object::range_to_ofs(uint64_t obj_size, int64_t &ofs, int64_t &end)
+{
+  if (ofs < 0) {
+    ofs += obj_size;
+    if (ofs < 0)
+      ofs = 0;
+    end = obj_size - 1;
+  } else if (end < 0) {
+    end = obj_size - 1;
+  }
+
+  if (obj_size > 0) {
+    if (ofs >= (off_t)obj_size) {
+      return -ERANGE;
+    }
+    if (end >= (off_t)obj_size) {
+      end = obj_size - 1;
+    }
+  }
+  return 0;
+}
+} // namespace rgw::sal