Adding upstream version 18.2.2.upstream/18.2.2

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

1 files changed, 350 insertions, 0 deletions

diff --git a/src/osd/ClassHandler.cc b/src/osd/ClassHandler.cc
new file mode 100644
index 000000000..d1e726408
--- /dev/null
+++ b/src/osd/ClassHandler.cc
@@ -0,0 +1,350 @@
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- 
+// vim: ts=8 sw=2 smarttab
+
+#include "include/types.h"
+#include "ClassHandler.h"
+#include "common/errno.h"
+#include "common/ceph_context.h"
+#include "include/dlfcn_compat.h"
+
+#include <map>
+
+#if defined(__FreeBSD__)
+#include <sys/param.h>
+#endif
+
+#include "common/config.h"
+#include "common/debug.h"
+
+#define dout_subsys ceph_subsys_osd
+#undef dout_prefix
+#define dout_prefix *_dout
+
+
+#define CLS_PREFIX "libcls_"
+#define CLS_SUFFIX SHARED_LIB_SUFFIX
+
+using std::map;
+using std::set;
+using std::string;
+
+using ceph::bufferlist;
+
+
+int ClassHandler::open_class(const string& cname, ClassData **pcls)
+{
+  std::lock_guard lock(mutex);
+  ClassData *cls = _get_class(cname, true);
+  if (!cls)
+    return -EPERM;
+  if (cls->status != ClassData::CLASS_OPEN) {
+    int r = _load_class(cls);
+    if (r)
+      return r;
+  }
+  *pcls = cls;
+  return 0;
+}
+
+int ClassHandler::open_all_classes()
+{
+  ldout(cct, 10) << __func__ << dendl;
+  DIR *dir = ::opendir(cct->_conf->osd_class_dir.c_str());
+  if (!dir)
+    return -errno;
+
+  struct dirent *pde = nullptr;
+  int r = 0;
+  while ((pde = ::readdir(dir))) {
+    if (pde->d_name[0] == '.')
+      continue;
+    if (strlen(pde->d_name) > sizeof(CLS_PREFIX) - 1 + sizeof(CLS_SUFFIX) - 1 &&
+	strncmp(pde->d_name, CLS_PREFIX, sizeof(CLS_PREFIX) - 1) == 0 &&
+	strcmp(pde->d_name + strlen(pde->d_name) - (sizeof(CLS_SUFFIX) - 1), CLS_SUFFIX) == 0) {
+      char cname[PATH_MAX + 1];
+      strncpy(cname, pde->d_name + sizeof(CLS_PREFIX) - 1, sizeof(cname) -1);
+      cname[strlen(cname) - (sizeof(CLS_SUFFIX) - 1)] = '\0';
+      ldout(cct, 10) << __func__ << " found " << cname << dendl;
+      ClassData *cls;
+      // skip classes that aren't in 'osd class load list'
+      r = open_class(cname, &cls);
+      if (r < 0 && r != -EPERM)
+	goto out;
+    }
+  }
+ out:
+  closedir(dir);
+  return r;
+}
+
+void ClassHandler::shutdown()
+{
+  for (auto& cls : classes) {
+    if (cls.second.handle) {
+      dlclose(cls.second.handle);
+    }
+  }
+  classes.clear();
+}
+
+/*
+ * Check if @cname is in the whitespace delimited list @list, or the @list
+ * contains the wildcard "*".
+ *
+ * This is expensive but doesn't consume memory for an index, and is performed
+ * only once when a class is loaded.
+ */
+bool ClassHandler::in_class_list(const std::string& cname,
+    const std::string& list)
+{
+  std::istringstream ss(list);
+  std::istream_iterator<std::string> begin{ss};
+  std::istream_iterator<std::string> end{};
+
+  const std::vector<std::string> targets{cname, "*"};
+
+  auto it = std::find_first_of(begin, end,
+      targets.begin(), targets.end());
+
+  return it != end;
+}
+
+ClassHandler::ClassData *ClassHandler::_get_class(const string& cname,
+    bool check_allowed)
+{
+  ClassData *cls;
+  map<string, ClassData>::iterator iter = classes.find(cname);
+
+  if (iter != classes.end()) {
+    cls = &iter->second;
+  } else {
+    if (check_allowed && !in_class_list(cname, cct->_conf->osd_class_load_list)) {
+      ldout(cct, 0) << "_get_class not permitted to load " << cname << dendl;
+      return NULL;
+    }
+    cls = &classes[cname];
+    ldout(cct, 10) << "_get_class adding new class name " << cname << " " << cls << dendl;
+    cls->name = cname;
+    cls->handler = this;
+    cls->allowed = in_class_list(cname, cct->_conf->osd_class_default_list);
+  }
+  return cls;
+}
+
+int ClassHandler::_load_class(ClassData *cls)
+{
+  // already open
+  if (cls->status == ClassData::CLASS_OPEN)
+    return 0;
+
+  if (cls->status == ClassData::CLASS_UNKNOWN ||
+      cls->status == ClassData::CLASS_MISSING) {
+    char fname[PATH_MAX];
+    snprintf(fname, sizeof(fname), "%s/" CLS_PREFIX "%s" CLS_SUFFIX,
+	     cct->_conf->osd_class_dir.c_str(),
+	     cls->name.c_str());
+    ldout(cct, 10) << "_load_class " << cls->name << " from " << fname << dendl;
+
+    cls->handle = dlopen(fname, RTLD_NOW);
+    if (!cls->handle) {
+      struct stat st;
+      int r = ::stat(fname, &st);
+      if (r < 0) {
+        r = -errno;
+	ldout(cct, 0) << __func__ << " could not stat class " << fname
+		      << ": " << cpp_strerror(r) << dendl;
+      } else {
+	ldout(cct, 0) << "_load_class could not open class " << fname
+		      << " (dlopen failed): " << dlerror() << dendl;
+	r = -EIO;
+      }
+      cls->status = ClassData::CLASS_MISSING;
+      return r;
+    }
+
+    cls_deps_t *(*cls_deps)();
+    cls_deps = (cls_deps_t *(*)())dlsym(cls->handle, "class_deps");
+    if (cls_deps) {
+      cls_deps_t *deps = cls_deps();
+      while (deps) {
+	if (!deps->name)
+	  break;
+	ClassData *cls_dep = _get_class(deps->name, false);
+	cls->dependencies.insert(cls_dep);
+	if (cls_dep->status != ClassData::CLASS_OPEN)
+	  cls->missing_dependencies.insert(cls_dep);
+	deps++;
+      }
+    }
+  }
+
+  // resolve dependencies
+  set<ClassData*>::iterator p = cls->missing_dependencies.begin();
+  while (p != cls->missing_dependencies.end()) {
+    ClassData *dc = *p;
+    int r = _load_class(dc);
+    if (r < 0) {
+      cls->status = ClassData::CLASS_MISSING_DEPS;
+      return r;
+    }
+
+    ldout(cct, 10) << "_load_class " << cls->name << " satisfied dependency " << dc->name << dendl;
+    cls->missing_dependencies.erase(p++);
+  }
+
+  // initialize
+  void (*cls_init)() = (void (*)())dlsym(cls->handle, "__cls_init");
+  if (cls_init) {
+    cls->status = ClassData::CLASS_INITIALIZING;
+    cls_init();
+  }
+
+  ldout(cct, 10) << "_load_class " << cls->name << " success" << dendl;
+  cls->status = ClassData::CLASS_OPEN;
+  return 0;
+}
+
+
+
+ClassHandler::ClassData *ClassHandler::register_class(const char *cname)
+{
+  ceph_assert(ceph_mutex_is_locked(mutex));
+
+  ClassData *cls = _get_class(cname, false);
+  ldout(cct, 10) << "register_class " << cname << " status " << cls->status << dendl;
+
+  if (cls->status != ClassData::CLASS_INITIALIZING) {
+    ldout(cct, 0) << "class " << cname << " isn't loaded; is the class registering under the wrong name?" << dendl;
+    return NULL;
+  }
+  return cls;
+}
+
+void ClassHandler::unregister_class(ClassHandler::ClassData *cls)
+{
+  /* FIXME: do we really need this one? */
+}
+
+ClassHandler::ClassMethod *ClassHandler::ClassData::register_method(const char *mname,
+                                                                    int flags,
+								    cls_method_call_t func)
+{
+  /* no need for locking, called under the class_init mutex */
+  if (!flags) {
+    lderr(handler->cct) << "register_method " << name << "." << mname
+			<< " flags " << flags << " " << (void*)func
+			<< " FAILED -- flags must be non-zero" << dendl;
+    return NULL;
+  }
+  ldout(handler->cct, 10) << "register_method " << name << "." << mname << " flags " << flags << " " << (void*)func << dendl;
+  [[maybe_unused]] auto [method, added] = methods_map.try_emplace(mname, mname, func, flags, this);
+  return &method->second;
+}
+
+ClassHandler::ClassMethod *ClassHandler::ClassData::register_cxx_method(const char *mname,
+                                                                        int flags,
+									cls_method_cxx_call_t func)
+{
+  /* no need for locking, called under the class_init mutex */
+  ldout(handler->cct, 10) << "register_cxx_method " << name << "." << mname << " flags " << flags << " " << (void*)func << dendl;
+  [[maybe_unused]] auto [method, added] = methods_map.try_emplace(mname, mname, func, flags, this);
+  return &method->second;
+}
+
+ClassHandler::ClassFilter *ClassHandler::ClassData::register_cxx_filter(
+    const std::string &filter_name,
+    cls_cxx_filter_factory_t fn)
+{
+  ClassFilter &filter = filters_map[filter_name];
+  filter.fn = fn;
+  filter.name = filter_name;
+  filter.cls = this;
+  return &filter;
+}
+
+ClassHandler::ClassMethod *ClassHandler::ClassData::_get_method(
+    const std::string& mname)
+{
+  if (auto iter = methods_map.find(mname); iter != methods_map.end()) {
+    return &(iter->second);
+  } else {
+    return nullptr;
+  }
+}
+
+int ClassHandler::ClassData::get_method_flags(const std::string& mname)
+{
+  std::lock_guard l(handler->mutex);
+  ClassMethod *method = _get_method(mname);
+  if (!method)
+    return -ENOENT;
+  return method->flags;
+}
+
+void ClassHandler::ClassData::unregister_method(ClassHandler::ClassMethod *method)
+{
+  /* no need for locking, called under the class_init mutex */
+   map<string, ClassMethod>::iterator iter = methods_map.find(method->name);
+   if (iter == methods_map.end())
+     return;
+   methods_map.erase(iter);
+}
+
+void ClassHandler::ClassMethod::unregister()
+{
+  cls->unregister_method(this);
+}
+
+void ClassHandler::ClassData::unregister_filter(ClassHandler::ClassFilter *filter)
+{
+  /* no need for locking, called under the class_init mutex */
+   map<string, ClassFilter>::iterator iter = filters_map.find(filter->name);
+   if (iter == filters_map.end())
+     return;
+   filters_map.erase(iter);
+}
+
+void ClassHandler::ClassFilter::unregister()
+{
+  cls->unregister_filter(this);
+}
+
+int ClassHandler::ClassMethod::exec(cls_method_context_t ctx, bufferlist& indata, bufferlist& outdata)
+{
+  int ret = 0;
+  std::visit([&](auto method) {
+    using method_t = decltype(method);
+    if constexpr (std::is_same_v<method_t, cls_method_cxx_call_t>) {
+      // C++ call version
+      ret = method(ctx, &indata, &outdata);
+    } else if constexpr (std::is_same_v<method_t, cls_method_call_t>) {
+      // C version
+      char *out = nullptr;
+      int olen = 0;
+      ret = method(ctx, indata.c_str(), indata.length(), &out, &olen);
+      if (out) {
+        // assume *out was allocated via cls_alloc (which calls malloc!)
+	ceph::buffer::ptr bp = ceph::buffer::claim_malloc(olen, out);
+        outdata.push_back(bp);
+      }
+    } else {
+      static_assert(std::is_same_v<method_t, void>);
+    }
+  }, func);
+  return ret;
+}
+
+ClassHandler& ClassHandler::get_instance()
+{
+#ifdef WITH_SEASTAR
+  // the context is being used solely for:
+  //   1. random number generation (cls_gen_random_bytes)
+  //   2. accessing the configuration
+  //   3. logging
+  static CephContext cct;
+  static ClassHandler single(&cct);
+#else
+  static ClassHandler single(g_ceph_context);
+#endif // WITH_SEASTAR
+  return single;
+}