diff options
Diffstat (limited to 'src/librados/librados_c.cc')
| -rw-r--r-- | src/librados/librados_c.cc | 4057 |
1 files changed, 4057 insertions, 0 deletions
diff --git a/src/librados/librados_c.cc b/src/librados/librados_c.cc new file mode 100644 index 00000000..f4f8dbe8 --- /dev/null +++ b/src/librados/librados_c.cc @@ -0,0 +1,4057 @@ +// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- +// vim: ts=8 sw=2 smarttab + +#include <limits.h> + +#include "common/config.h" +#include "common/errno.h" +#include "common/ceph_argparse.h" +#include "common/ceph_json.h" +#include "common/common_init.h" +#include "common/TracepointProvider.h" +#include "common/hobject.h" +#include "include/rados/librados.h" +#include "include/types.h" +#include <include/stringify.h> + +#include "librados/librados_c.h" +#include "librados/AioCompletionImpl.h" +#include "librados/IoCtxImpl.h" +#include "librados/PoolAsyncCompletionImpl.h" +#include "librados/RadosClient.h" +#include "librados/RadosXattrIter.h" +#include "librados/ListObjectImpl.h" +#include "librados/librados_util.h" +#include <cls/lock/cls_lock_client.h> + +#include <string> +#include <map> +#include <set> +#include <vector> +#include <list> +#include <stdexcept> + +#ifdef WITH_LTTNG +#define TRACEPOINT_DEFINE +#define TRACEPOINT_PROBE_DYNAMIC_LINKAGE +#include "tracing/librados.h" +#undef TRACEPOINT_PROBE_DYNAMIC_LINKAGE +#undef TRACEPOINT_DEFINE +#else +#define tracepoint(...) +#endif + +#define LIBRADOS_C_API_BASE(fn) \ + asm(".symver _" #fn "_base, " #fn "@") +#define LIBRADOS_C_API_BASE_DEFAULT(fn) \ + asm(".symver _" #fn ", " #fn "@@") +#define LIBRADOS_C_API_DEFAULT(fn, ver) \ + asm(".symver _" #fn ", " #fn "@@LIBRADOS_" #ver) + +using std::string; +using std::map; +using std::set; +using std::vector; +using std::list; + +#define dout_subsys ceph_subsys_rados +#undef dout_prefix +#define dout_prefix *_dout << "librados: " + +#define RADOS_LIST_MAX_ENTRIES 1024 + +static TracepointProvider::Traits tracepoint_traits("librados_tp.so", "rados_tracing"); + +/* + * Structure of this file + * + * RadosClient and the related classes are the internal implementation of librados. + * Above that layer sits the C API, found in include/rados/librados.h, and + * the C++ API, found in include/rados/librados.hpp + * + * The C++ API sometimes implements things in terms of the C API. + * Both the C++ and C API rely on RadosClient. + * + * Visually: + * +--------------------------------------+ + * | C++ API | + * +--------------------+ | + * | C API | | + * +--------------------+-----------------+ + * | RadosClient | + * +--------------------------------------+ + */ + +///////////////////////////// C API ////////////////////////////// + +static CephContext *rados_create_cct(const char * const clustername, + CephInitParameters *iparams) +{ + // missing things compared to global_init: + // g_ceph_context, g_conf, g_lockdep, signal handlers + CephContext *cct = common_preinit(*iparams, CODE_ENVIRONMENT_LIBRARY, 0); + if (clustername) + cct->_conf->cluster = clustername; + cct->_conf.parse_env(cct->get_module_type()); // environment variables override + cct->_conf.apply_changes(nullptr); + + TracepointProvider::initialize<tracepoint_traits>(cct); + return cct; +} + +extern "C" int _rados_create(rados_t *pcluster, const char * const id) +{ + CephInitParameters iparams(CEPH_ENTITY_TYPE_CLIENT); + if (id) { + iparams.name.set(CEPH_ENTITY_TYPE_CLIENT, id); + } + CephContext *cct = rados_create_cct("", &iparams); + + tracepoint(librados, rados_create_enter, id); + *pcluster = reinterpret_cast<rados_t>(new librados::RadosClient(cct)); + tracepoint(librados, rados_create_exit, 0, *pcluster); + + cct->put(); + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_create); + +// as above, but +// 1) don't assume 'client.'; name is a full type.id namestr +// 2) allow setting clustername +// 3) flags is for future expansion (maybe some of the global_init() +// behavior is appropriate for some consumers of librados, for instance) + +extern "C" int _rados_create2(rados_t *pcluster, const char *const clustername, + const char * const name, uint64_t flags) +{ + // client is assumed, but from_str will override + int retval = 0; + CephInitParameters iparams(CEPH_ENTITY_TYPE_CLIENT); + if (!name || !iparams.name.from_str(name)) { + retval = -EINVAL; + } + + CephContext *cct = rados_create_cct(clustername, &iparams); + tracepoint(librados, rados_create2_enter, clustername, name, flags); + if (retval == 0) { + *pcluster = reinterpret_cast<rados_t>(new librados::RadosClient(cct)); + } + tracepoint(librados, rados_create2_exit, retval, *pcluster); + + cct->put(); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_create2); + +/* This function is intended for use by Ceph daemons. These daemons have + * already called global_init and want to use that particular configuration for + * their cluster. + */ +extern "C" int _rados_create_with_context(rados_t *pcluster, rados_config_t cct_) +{ + CephContext *cct = (CephContext *)cct_; + TracepointProvider::initialize<tracepoint_traits>(cct); + + tracepoint(librados, rados_create_with_context_enter, cct_); + librados::RadosClient *radosp = new librados::RadosClient(cct); + *pcluster = (void *)radosp; + tracepoint(librados, rados_create_with_context_exit, 0, *pcluster); + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_create_with_context); + +extern "C" rados_config_t _rados_cct(rados_t cluster) +{ + tracepoint(librados, rados_cct_enter, cluster); + librados::RadosClient *client = (librados::RadosClient *)cluster; + rados_config_t retval = (rados_config_t)client->cct; + tracepoint(librados, rados_cct_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_cct); + +extern "C" int _rados_connect(rados_t cluster) +{ + tracepoint(librados, rados_connect_enter, cluster); + librados::RadosClient *client = (librados::RadosClient *)cluster; + int retval = client->connect(); + tracepoint(librados, rados_connect_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_connect); + +extern "C" void _rados_shutdown(rados_t cluster) +{ + tracepoint(librados, rados_shutdown_enter, cluster); + librados::RadosClient *radosp = (librados::RadosClient *)cluster; + radosp->shutdown(); + delete radosp; + tracepoint(librados, rados_shutdown_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_shutdown); + +extern "C" uint64_t _rados_get_instance_id(rados_t cluster) +{ + tracepoint(librados, rados_get_instance_id_enter, cluster); + librados::RadosClient *client = (librados::RadosClient *)cluster; + uint64_t retval = client->get_instance_id(); + tracepoint(librados, rados_get_instance_id_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_get_instance_id); + +extern "C" int _rados_get_min_compatible_osd(rados_t cluster, + int8_t* require_osd_release) +{ + librados::RadosClient *client = (librados::RadosClient *)cluster; + return client->get_min_compatible_osd(require_osd_release); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_get_min_compatible_osd); + +extern "C" int _rados_get_min_compatible_client(rados_t cluster, + int8_t* min_compat_client, + int8_t* require_min_compat_client) +{ + librados::RadosClient *client = (librados::RadosClient *)cluster; + return client->get_min_compatible_client(min_compat_client, + require_min_compat_client); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_get_min_compatible_client); + +extern "C" void _rados_version(int *major, int *minor, int *extra) +{ + tracepoint(librados, rados_version_enter, major, minor, extra); + if (major) + *major = LIBRADOS_VER_MAJOR; + if (minor) + *minor = LIBRADOS_VER_MINOR; + if (extra) + *extra = LIBRADOS_VER_EXTRA; + tracepoint(librados, rados_version_exit, LIBRADOS_VER_MAJOR, LIBRADOS_VER_MINOR, LIBRADOS_VER_EXTRA); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_version); + + +// -- config -- +extern "C" int _rados_conf_read_file(rados_t cluster, const char *path_list) +{ + tracepoint(librados, rados_conf_read_file_enter, cluster, path_list); + librados::RadosClient *client = (librados::RadosClient *)cluster; + auto& conf = client->cct->_conf; + ostringstream warnings; + int ret = conf.parse_config_files(path_list, &warnings, 0); + if (ret) { + if (warnings.tellp() > 0) + lderr(client->cct) << warnings.str() << dendl; + client->cct->_conf.complain_about_parse_errors(client->cct); + tracepoint(librados, rados_conf_read_file_exit, ret); + return ret; + } + conf.parse_env(client->cct->get_module_type()); // environment variables override + + conf.apply_changes(nullptr); + client->cct->_conf.complain_about_parse_errors(client->cct); + tracepoint(librados, rados_conf_read_file_exit, 0); + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_conf_read_file); + +extern "C" int _rados_conf_parse_argv(rados_t cluster, int argc, const char **argv) +{ + tracepoint(librados, rados_conf_parse_argv_enter, cluster, argc); + int i; + for(i = 0; i < argc; i++) { + tracepoint(librados, rados_conf_parse_argv_arg, argv[i]); + } + librados::RadosClient *client = (librados::RadosClient *)cluster; + auto& conf = client->cct->_conf; + vector<const char*> args; + argv_to_vec(argc, argv, args); + int ret = conf.parse_argv(args); + if (ret) { + tracepoint(librados, rados_conf_parse_argv_exit, ret); + return ret; + } + conf.apply_changes(nullptr); + tracepoint(librados, rados_conf_parse_argv_exit, 0); + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_conf_parse_argv); + +// like above, but return the remainder of argv to contain remaining +// unparsed args. Must be allocated to at least argc by caller. +// remargv will contain n <= argc pointers to original argv[], the end +// of which may be NULL + +extern "C" int _rados_conf_parse_argv_remainder(rados_t cluster, int argc, + const char **argv, + const char **remargv) +{ + tracepoint(librados, rados_conf_parse_argv_remainder_enter, cluster, argc); + unsigned int i; + for(i = 0; i < (unsigned int) argc; i++) { + tracepoint(librados, rados_conf_parse_argv_remainder_arg, argv[i]); + } + librados::RadosClient *client = (librados::RadosClient *)cluster; + auto& conf = client->cct->_conf; + vector<const char*> args; + for (int i=0; i<argc; i++) + args.push_back(argv[i]); + int ret = conf.parse_argv(args); + if (ret) { + tracepoint(librados, rados_conf_parse_argv_remainder_exit, ret); + return ret; + } + conf.apply_changes(NULL); + ceph_assert(args.size() <= (unsigned int)argc); + for (i = 0; i < (unsigned int)argc; ++i) { + if (i < args.size()) + remargv[i] = args[i]; + else + remargv[i] = (const char *)NULL; + tracepoint(librados, rados_conf_parse_argv_remainder_remarg, remargv[i]); + } + tracepoint(librados, rados_conf_parse_argv_remainder_exit, 0); + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_conf_parse_argv_remainder); + +extern "C" int _rados_conf_parse_env(rados_t cluster, const char *env) +{ + tracepoint(librados, rados_conf_parse_env_enter, cluster, env); + librados::RadosClient *client = (librados::RadosClient *)cluster; + auto& conf = client->cct->_conf; + conf.parse_env(client->cct->get_module_type(), env); + conf.apply_changes(nullptr); + tracepoint(librados, rados_conf_parse_env_exit, 0); + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_conf_parse_env); + +extern "C" int _rados_conf_set(rados_t cluster, const char *option, const char *value) +{ + tracepoint(librados, rados_conf_set_enter, cluster, option, value); + librados::RadosClient *client = (librados::RadosClient *)cluster; + auto& conf = client->cct->_conf; + int ret = conf.set_val(option, value); + if (ret) { + tracepoint(librados, rados_conf_set_exit, ret); + return ret; + } + conf.apply_changes(nullptr); + tracepoint(librados, rados_conf_set_exit, 0); + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_conf_set); + +/* cluster info */ +extern "C" int _rados_cluster_stat(rados_t cluster, rados_cluster_stat_t *result) +{ + tracepoint(librados, rados_cluster_stat_enter, cluster); + librados::RadosClient *client = (librados::RadosClient *)cluster; + + ceph_statfs stats; + int r = client->get_fs_stats(stats); + result->kb = stats.kb; + result->kb_used = stats.kb_used; + result->kb_avail = stats.kb_avail; + result->num_objects = stats.num_objects; + tracepoint(librados, rados_cluster_stat_exit, r, result->kb, result->kb_used, result->kb_avail, result->num_objects); + return r; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_cluster_stat); + +extern "C" int _rados_conf_get(rados_t cluster, const char *option, char *buf, size_t len) +{ + tracepoint(librados, rados_conf_get_enter, cluster, option, len); + char *tmp = buf; + librados::RadosClient *client = (librados::RadosClient *)cluster; + const auto& conf = client->cct->_conf; + int retval = conf.get_val(option, &tmp, len); + tracepoint(librados, rados_conf_get_exit, retval, retval ? "" : option); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_conf_get); + +extern "C" int64_t _rados_pool_lookup(rados_t cluster, const char *name) +{ + tracepoint(librados, rados_pool_lookup_enter, cluster, name); + librados::RadosClient *radosp = (librados::RadosClient *)cluster; + int64_t retval = radosp->lookup_pool(name); + tracepoint(librados, rados_pool_lookup_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_pool_lookup); + +extern "C" int _rados_pool_reverse_lookup(rados_t cluster, int64_t id, + char *buf, size_t maxlen) +{ + tracepoint(librados, rados_pool_reverse_lookup_enter, cluster, id, maxlen); + librados::RadosClient *radosp = (librados::RadosClient *)cluster; + std::string name; + int r = radosp->pool_get_name(id, &name); + if (r < 0) { + tracepoint(librados, rados_pool_reverse_lookup_exit, r, ""); + return r; + } + if (name.length() >= maxlen) { + tracepoint(librados, rados_pool_reverse_lookup_exit, -ERANGE, ""); + return -ERANGE; + } + strcpy(buf, name.c_str()); + int retval = name.length(); + tracepoint(librados, rados_pool_reverse_lookup_exit, retval, buf); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_pool_reverse_lookup); + +extern "C" int _rados_cluster_fsid(rados_t cluster, char *buf, + size_t maxlen) +{ + tracepoint(librados, rados_cluster_fsid_enter, cluster, maxlen); + librados::RadosClient *radosp = (librados::RadosClient *)cluster; + std::string fsid; + radosp->get_fsid(&fsid); + if (fsid.length() >= maxlen) { + tracepoint(librados, rados_cluster_fsid_exit, -ERANGE, ""); + return -ERANGE; + } + strcpy(buf, fsid.c_str()); + int retval = fsid.length(); + tracepoint(librados, rados_cluster_fsid_exit, retval, buf); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_cluster_fsid); + +extern "C" int _rados_wait_for_latest_osdmap(rados_t cluster) +{ + tracepoint(librados, rados_wait_for_latest_osdmap_enter, cluster); + librados::RadosClient *radosp = (librados::RadosClient *)cluster; + int retval = radosp->wait_for_latest_osdmap(); + tracepoint(librados, rados_wait_for_latest_osdmap_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_wait_for_latest_osdmap); + +extern "C" int _rados_blacklist_add(rados_t cluster, char *client_address, + uint32_t expire_seconds) +{ + librados::RadosClient *radosp = (librados::RadosClient *)cluster; + return radosp->blacklist_add(client_address, expire_seconds); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_blacklist_add); + +extern "C" int _rados_getaddrs(rados_t cluster, char** addrs) +{ + librados::RadosClient *radosp = (librados::RadosClient *)cluster; + auto s = radosp->get_addrs(); + *addrs = strdup(s.c_str()); + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_getaddrs); + +extern "C" void _rados_set_osdmap_full_try(rados_ioctx_t io) +{ + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + ctx->objecter->set_osdmap_full_try(); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_set_osdmap_full_try); + +extern "C" void _rados_unset_osdmap_full_try(rados_ioctx_t io) +{ + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + ctx->objecter->unset_osdmap_full_try(); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_unset_osdmap_full_try); + +extern "C" int _rados_application_enable(rados_ioctx_t io, const char *app_name, + int force) +{ + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + return ctx->application_enable(app_name, force != 0); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_application_enable); + +extern "C" int _rados_application_list(rados_ioctx_t io, char *values, + size_t *values_len) +{ + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + std::set<std::string> app_names; + int r = ctx->application_list(&app_names); + if (r < 0) { + return r; + } + + size_t total_len = 0; + for (auto app_name : app_names) { + total_len += app_name.size() + 1; + } + + if (*values_len < total_len) { + *values_len = total_len; + return -ERANGE; + } + + char *values_p = values; + for (auto app_name : app_names) { + size_t len = app_name.size() + 1; + strncpy(values_p, app_name.c_str(), len); + values_p += len; + } + *values_p = '\0'; + *values_len = total_len; + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_application_list); + +extern "C" int _rados_application_metadata_get(rados_ioctx_t io, + const char *app_name, + const char *key, char *value, + size_t *value_len) +{ + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + std::string value_str; + int r = ctx->application_metadata_get(app_name, key, &value_str); + if (r < 0) { + return r; + } + + size_t len = value_str.size() + 1; + if (*value_len < len) { + *value_len = len; + return -ERANGE; + } + + strncpy(value, value_str.c_str(), len); + *value_len = len; + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_application_metadata_get); + +extern "C" int _rados_application_metadata_set(rados_ioctx_t io, + const char *app_name, + const char *key, + const char *value) +{ + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + return ctx->application_metadata_set(app_name, key, value); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_application_metadata_set); + +extern "C" int _rados_application_metadata_remove(rados_ioctx_t io, + const char *app_name, + const char *key) +{ + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + return ctx->application_metadata_remove(app_name, key); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_application_metadata_remove); + +extern "C" int _rados_application_metadata_list(rados_ioctx_t io, + const char *app_name, + char *keys, size_t *keys_len, + char *values, size_t *vals_len) +{ + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + std::map<std::string, std::string> metadata; + int r = ctx->application_metadata_list(app_name, &metadata); + if (r < 0) { + return r; + } + + size_t total_key_len = 0; + size_t total_val_len = 0; + for (auto pair : metadata) { + total_key_len += pair.first.size() + 1; + total_val_len += pair.second.size() + 1; + } + + if (*keys_len < total_key_len || *vals_len < total_val_len) { + *keys_len = total_key_len; + *vals_len = total_val_len; + return -ERANGE; + } + + char *keys_p = keys; + char *vals_p = values; + for (auto pair : metadata) { + size_t key_len = pair.first.size() + 1; + strncpy(keys_p, pair.first.c_str(), key_len); + keys_p += key_len; + + size_t val_len = pair.second.size() + 1; + strncpy(vals_p, pair.second.c_str(), val_len); + vals_p += val_len; + } + *keys_p = '\0'; + *keys_len = total_key_len; + + *vals_p = '\0'; + *vals_len = total_val_len; + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_application_metadata_list); + +extern "C" int _rados_pool_list(rados_t cluster, char *buf, size_t len) +{ + tracepoint(librados, rados_pool_list_enter, cluster, len); + librados::RadosClient *client = (librados::RadosClient *)cluster; + std::list<std::pair<int64_t, std::string> > pools; + int r = client->pool_list(pools); + if (r < 0) { + tracepoint(librados, rados_pool_list_exit, r); + return r; + } + + if (len > 0 && !buf) { + tracepoint(librados, rados_pool_list_exit, -EINVAL); + return -EINVAL; + } + + char *b = buf; + if (b) { + // FIPS zeroization audit 20191116: this memset is not security related. + memset(b, 0, len); + } + int needed = 0; + std::list<std::pair<int64_t, std::string> >::const_iterator i = pools.begin(); + std::list<std::pair<int64_t, std::string> >::const_iterator p_end = + pools.end(); + for (; i != p_end; ++i) { + int rl = i->second.length() + 1; + if (len < (unsigned)rl) + break; + const char* pool = i->second.c_str(); + tracepoint(librados, rados_pool_list_pool, pool); + if (b) { + strncat(b, pool, rl); + b += rl; + } + needed += rl; + len -= rl; + } + for (; i != p_end; ++i) { + int rl = i->second.length() + 1; + needed += rl; + } + int retval = needed + 1; + tracepoint(librados, rados_pool_list_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_pool_list); + +extern "C" int _rados_inconsistent_pg_list(rados_t cluster, int64_t pool_id, + char *buf, size_t len) +{ + tracepoint(librados, rados_inconsistent_pg_list_enter, cluster, pool_id, len); + librados::RadosClient *client = (librados::RadosClient *)cluster; + std::vector<std::string> pgs; + if (int r = client->get_inconsistent_pgs(pool_id, &pgs); r < 0) { + tracepoint(librados, rados_inconsistent_pg_list_exit, r); + return r; + } + + if (len > 0 && !buf) { + tracepoint(librados, rados_inconsistent_pg_list_exit, -EINVAL); + return -EINVAL; + } + + char *b = buf; + if (b) { + // FIPS zeroization audit 20191116: this memset is not security related. + memset(b, 0, len); + } + int needed = 0; + for (const auto& s : pgs) { + unsigned rl = s.length() + 1; + if (b && len >= rl) { + tracepoint(librados, rados_inconsistent_pg_list_pg, s.c_str()); + strncat(b, s.c_str(), rl); + b += rl; + len -= rl; + } + needed += rl; + } + int retval = needed + 1; + tracepoint(librados, rados_inconsistent_pg_list_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_inconsistent_pg_list); + + +static void dict_to_map(const char *dict, + std::map<std::string, std::string>* dict_map) +{ + while (*dict != '\0') { + const char* key = dict; + dict += strlen(key) + 1; + const char* value = dict; + dict += strlen(value) + 1; + (*dict_map)[key] = value; + } +} + +extern "C" int _rados_service_register(rados_t cluster, const char *service, + const char *daemon, + const char *metadata_dict) +{ + librados::RadosClient *client = (librados::RadosClient *)cluster; + + std::map<std::string, std::string> metadata; + dict_to_map(metadata_dict, &metadata); + + return client->service_daemon_register(service, daemon, metadata); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_service_register); + +extern "C" int _rados_service_update_status(rados_t cluster, + const char *status_dict) +{ + librados::RadosClient *client = (librados::RadosClient *)cluster; + + std::map<std::string, std::string> status; + dict_to_map(status_dict, &status); + + return client->service_daemon_update_status(std::move(status)); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_service_update_status); + +static void do_out_buffer(bufferlist& outbl, char **outbuf, size_t *outbuflen) +{ + if (outbuf) { + if (outbl.length() > 0) { + *outbuf = (char *)malloc(outbl.length()); + memcpy(*outbuf, outbl.c_str(), outbl.length()); + } else { + *outbuf = NULL; + } + } + if (outbuflen) + *outbuflen = outbl.length(); +} + +static void do_out_buffer(string& outbl, char **outbuf, size_t *outbuflen) +{ + if (outbuf) { + if (outbl.length() > 0) { + *outbuf = (char *)malloc(outbl.length()); + memcpy(*outbuf, outbl.c_str(), outbl.length()); + } else { + *outbuf = NULL; + } + } + if (outbuflen) + *outbuflen = outbl.length(); +} + +extern "C" int _rados_ping_monitor(rados_t cluster, const char *mon_id, + char **outstr, size_t *outstrlen) +{ + tracepoint(librados, rados_ping_monitor_enter, cluster, mon_id); + librados::RadosClient *client = (librados::RadosClient *)cluster; + string str; + + if (!mon_id) { + tracepoint(librados, rados_ping_monitor_exit, -EINVAL, NULL, NULL); + return -EINVAL; + } + + int ret = client->ping_monitor(mon_id, &str); + if (ret == 0) { + do_out_buffer(str, outstr, outstrlen); + } + tracepoint(librados, rados_ping_monitor_exit, ret, ret < 0 ? NULL : outstr, ret < 0 ? NULL : outstrlen); + return ret; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ping_monitor); + +extern "C" int _rados_mon_command(rados_t cluster, const char **cmd, + size_t cmdlen, + const char *inbuf, size_t inbuflen, + char **outbuf, size_t *outbuflen, + char **outs, size_t *outslen) +{ + tracepoint(librados, rados_mon_command_enter, cluster, cmdlen, inbuf, inbuflen); + librados::RadosClient *client = (librados::RadosClient *)cluster; + bufferlist inbl; + bufferlist outbl; + string outstring; + vector<string> cmdvec; + + for (size_t i = 0; i < cmdlen; i++) { + tracepoint(librados, rados_mon_command_cmd, cmd[i]); + cmdvec.push_back(cmd[i]); + } + + inbl.append(inbuf, inbuflen); + int ret = client->mon_command(cmdvec, inbl, &outbl, &outstring); + + do_out_buffer(outbl, outbuf, outbuflen); + do_out_buffer(outstring, outs, outslen); + tracepoint(librados, rados_mon_command_exit, ret, outbuf, outbuflen, outs, outslen); + return ret; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_mon_command); + +extern "C" int _rados_mon_command_target(rados_t cluster, const char *name, + const char **cmd, + size_t cmdlen, + const char *inbuf, size_t inbuflen, + char **outbuf, size_t *outbuflen, + char **outs, size_t *outslen) +{ + tracepoint(librados, rados_mon_command_target_enter, cluster, name, cmdlen, inbuf, inbuflen); + librados::RadosClient *client = (librados::RadosClient *)cluster; + bufferlist inbl; + bufferlist outbl; + string outstring; + vector<string> cmdvec; + + // is this a numeric id? + char *endptr; + errno = 0; + long rank = strtol(name, &endptr, 10); + if ((errno == ERANGE && (rank == LONG_MAX || rank == LONG_MIN)) || + (errno != 0 && rank == 0) || + endptr == name || // no digits + *endptr != '\0') { // extra characters + rank = -1; + } + + for (size_t i = 0; i < cmdlen; i++) { + tracepoint(librados, rados_mon_command_target_cmd, cmd[i]); + cmdvec.push_back(cmd[i]); + } + + inbl.append(inbuf, inbuflen); + int ret; + if (rank >= 0) + ret = client->mon_command(rank, cmdvec, inbl, &outbl, &outstring); + else + ret = client->mon_command(name, cmdvec, inbl, &outbl, &outstring); + + do_out_buffer(outbl, outbuf, outbuflen); + do_out_buffer(outstring, outs, outslen); + tracepoint(librados, rados_mon_command_target_exit, ret, outbuf, outbuflen, outs, outslen); + return ret; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_mon_command_target); + +extern "C" int _rados_osd_command(rados_t cluster, int osdid, const char **cmd, + size_t cmdlen, + const char *inbuf, size_t inbuflen, + char **outbuf, size_t *outbuflen, + char **outs, size_t *outslen) +{ + tracepoint(librados, rados_osd_command_enter, cluster, osdid, cmdlen, inbuf, inbuflen); + librados::RadosClient *client = (librados::RadosClient *)cluster; + bufferlist inbl; + bufferlist outbl; + string outstring; + vector<string> cmdvec; + + for (size_t i = 0; i < cmdlen; i++) { + tracepoint(librados, rados_osd_command_cmd, cmd[i]); + cmdvec.push_back(cmd[i]); + } + + inbl.append(inbuf, inbuflen); + int ret = client->osd_command(osdid, cmdvec, inbl, &outbl, &outstring); + + do_out_buffer(outbl, outbuf, outbuflen); + do_out_buffer(outstring, outs, outslen); + tracepoint(librados, rados_osd_command_exit, ret, outbuf, outbuflen, outs, outslen); + return ret; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_osd_command); + +extern "C" int _rados_mgr_command(rados_t cluster, const char **cmd, + size_t cmdlen, + const char *inbuf, size_t inbuflen, + char **outbuf, size_t *outbuflen, + char **outs, size_t *outslen) +{ + tracepoint(librados, rados_mgr_command_enter, cluster, cmdlen, inbuf, + inbuflen); + + librados::RadosClient *client = (librados::RadosClient *)cluster; + bufferlist inbl; + bufferlist outbl; + string outstring; + vector<string> cmdvec; + + for (size_t i = 0; i < cmdlen; i++) { + tracepoint(librados, rados_mgr_command_cmd, cmd[i]); + cmdvec.push_back(cmd[i]); + } + + inbl.append(inbuf, inbuflen); + int ret = client->mgr_command(cmdvec, inbl, &outbl, &outstring); + + do_out_buffer(outbl, outbuf, outbuflen); + do_out_buffer(outstring, outs, outslen); + tracepoint(librados, rados_mgr_command_exit, ret, outbuf, outbuflen, outs, + outslen); + return ret; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_mgr_command); + +extern "C" int _rados_pg_command(rados_t cluster, const char *pgstr, + const char **cmd, size_t cmdlen, + const char *inbuf, size_t inbuflen, + char **outbuf, size_t *outbuflen, + char **outs, size_t *outslen) +{ + tracepoint(librados, rados_pg_command_enter, cluster, pgstr, cmdlen, inbuf, inbuflen); + librados::RadosClient *client = (librados::RadosClient *)cluster; + bufferlist inbl; + bufferlist outbl; + string outstring; + pg_t pgid; + vector<string> cmdvec; + + for (size_t i = 0; i < cmdlen; i++) { + tracepoint(librados, rados_pg_command_cmd, cmd[i]); + cmdvec.push_back(cmd[i]); + } + + inbl.append(inbuf, inbuflen); + if (!pgid.parse(pgstr)) + return -EINVAL; + + int ret = client->pg_command(pgid, cmdvec, inbl, &outbl, &outstring); + + do_out_buffer(outbl, outbuf, outbuflen); + do_out_buffer(outstring, outs, outslen); + tracepoint(librados, rados_pg_command_exit, ret, outbuf, outbuflen, outs, outslen); + return ret; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_pg_command); + +extern "C" void _rados_buffer_free(char *buf) +{ + tracepoint(librados, rados_buffer_free_enter, buf); + if (buf) + free(buf); + tracepoint(librados, rados_buffer_free_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_buffer_free); + +extern "C" int _rados_monitor_log(rados_t cluster, const char *level, rados_log_callback_t cb, void *arg) +{ + tracepoint(librados, rados_monitor_log_enter, cluster, level, cb, arg); + librados::RadosClient *client = (librados::RadosClient *)cluster; + int retval = client->monitor_log(level, cb, nullptr, arg); + tracepoint(librados, rados_monitor_log_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_monitor_log); + +extern "C" int _rados_monitor_log2(rados_t cluster, const char *level, + rados_log_callback2_t cb, void *arg) +{ + tracepoint(librados, rados_monitor_log2_enter, cluster, level, cb, arg); + librados::RadosClient *client = (librados::RadosClient *)cluster; + int retval = client->monitor_log(level, nullptr, cb, arg); + tracepoint(librados, rados_monitor_log2_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_monitor_log2); + +extern "C" int _rados_ioctx_create(rados_t cluster, const char *name, rados_ioctx_t *io) +{ + tracepoint(librados, rados_ioctx_create_enter, cluster, name); + librados::RadosClient *client = (librados::RadosClient *)cluster; + librados::IoCtxImpl *ctx; + + int r = client->create_ioctx(name, &ctx); + if (r < 0) { + tracepoint(librados, rados_ioctx_create_exit, r, NULL); + return r; + } + + *io = ctx; + ctx->get(); + tracepoint(librados, rados_ioctx_create_exit, 0, ctx); + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_create); + +extern "C" int _rados_ioctx_create2(rados_t cluster, int64_t pool_id, + rados_ioctx_t *io) +{ + tracepoint(librados, rados_ioctx_create2_enter, cluster, pool_id); + librados::RadosClient *client = (librados::RadosClient *)cluster; + librados::IoCtxImpl *ctx; + + int r = client->create_ioctx(pool_id, &ctx); + if (r < 0) { + tracepoint(librados, rados_ioctx_create2_exit, r, NULL); + return r; + } + + *io = ctx; + ctx->get(); + tracepoint(librados, rados_ioctx_create2_exit, 0, ctx); + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_create2); + +extern "C" void _rados_ioctx_destroy(rados_ioctx_t io) +{ + tracepoint(librados, rados_ioctx_destroy_enter, io); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + ctx->put(); + tracepoint(librados, rados_ioctx_destroy_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_destroy); + +extern "C" int _rados_ioctx_pool_stat(rados_ioctx_t io, + struct rados_pool_stat_t *stats) +{ + tracepoint(librados, rados_ioctx_pool_stat_enter, io); + librados::IoCtxImpl *io_ctx_impl = (librados::IoCtxImpl *)io; + list<string> ls; + std::string pool_name; + + int err = io_ctx_impl->client->pool_get_name(io_ctx_impl->get_id(), &pool_name); + if (err) { + tracepoint(librados, rados_ioctx_pool_stat_exit, err, stats); + return err; + } + ls.push_back(pool_name); + + map<string, ::pool_stat_t> rawresult; + bool per_pool = false; + err = io_ctx_impl->client->get_pool_stats(ls, &rawresult, &per_pool); + if (err) { + tracepoint(librados, rados_ioctx_pool_stat_exit, err, stats); + return err; + } + + ::pool_stat_t& r = rawresult[pool_name]; + uint64_t allocated_bytes = r.get_allocated_bytes(per_pool); + // FIXME: raw_used_rate is unknown hence use 1.0 here + // meaning we keep net amount aggregated over all replicas + // Not a big deal so far since this field isn't exposed + uint64_t user_bytes = r.get_user_bytes(1.0, per_pool); + + stats->num_kb = shift_round_up(allocated_bytes, 10); + stats->num_bytes = allocated_bytes; + stats->num_objects = r.stats.sum.num_objects; + stats->num_object_clones = r.stats.sum.num_object_clones; + stats->num_object_copies = r.stats.sum.num_object_copies; + stats->num_objects_missing_on_primary = r.stats.sum.num_objects_missing_on_primary; + stats->num_objects_unfound = r.stats.sum.num_objects_unfound; + stats->num_objects_degraded = + r.stats.sum.num_objects_degraded + + r.stats.sum.num_objects_misplaced; // FIXME: this is imprecise + stats->num_rd = r.stats.sum.num_rd; + stats->num_rd_kb = r.stats.sum.num_rd_kb; + stats->num_wr = r.stats.sum.num_wr; + stats->num_wr_kb = r.stats.sum.num_wr_kb; + stats->num_user_bytes = user_bytes; + stats->compressed_bytes_orig = r.store_stats.data_compressed_original; + stats->compressed_bytes = r.store_stats.data_compressed; + stats->compressed_bytes_alloc = r.store_stats.data_compressed_allocated; + + tracepoint(librados, rados_ioctx_pool_stat_exit, 0, stats); + return 0; +} +LIBRADOS_C_API_DEFAULT(rados_ioctx_pool_stat, 14.2.0); + +extern "C" int _rados_ioctx_pool_stat_base( + rados_ioctx_t io, struct __librados_base::rados_pool_stat_t *stats) +{ + struct rados_pool_stat_t new_stats; + int r = _rados_ioctx_pool_stat(io, &new_stats); + if (r < 0) { + return r; + } + + stats->num_bytes = new_stats.num_bytes; + stats->num_kb = new_stats.num_kb; + stats->num_objects = new_stats.num_objects; + stats->num_object_clones = new_stats.num_object_clones; + stats->num_object_copies = new_stats.num_object_copies; + stats->num_objects_missing_on_primary = new_stats.num_objects_missing_on_primary; + stats->num_objects_unfound = new_stats.num_objects_unfound; + stats->num_objects_degraded = new_stats.num_objects_degraded; + stats->num_rd = new_stats.num_rd; + stats->num_rd_kb = new_stats.num_rd_kb; + stats->num_wr = new_stats.num_wr; + stats->num_wr_kb = new_stats.num_wr_kb; + return 0; +} +LIBRADOS_C_API_BASE(rados_ioctx_pool_stat); + +extern "C" rados_config_t _rados_ioctx_cct(rados_ioctx_t io) +{ + tracepoint(librados, rados_ioctx_cct_enter, io); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + rados_config_t retval = (rados_config_t)ctx->client->cct; + tracepoint(librados, rados_ioctx_cct_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_cct); + +extern "C" void _rados_ioctx_snap_set_read(rados_ioctx_t io, rados_snap_t seq) +{ + tracepoint(librados, rados_ioctx_snap_set_read_enter, io, seq); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + ctx->set_snap_read((snapid_t)seq); + tracepoint(librados, rados_ioctx_snap_set_read_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_snap_set_read); + +extern "C" int _rados_ioctx_selfmanaged_snap_set_write_ctx( + rados_ioctx_t io, rados_snap_t seq, rados_snap_t *snaps, int num_snaps) +{ + tracepoint(librados, rados_ioctx_selfmanaged_snap_set_write_ctx_enter, io, seq, snaps, num_snaps); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + vector<snapid_t> snv; + snv.resize(num_snaps); + for (int i=0; i<num_snaps; i++) { + snv[i] = (snapid_t)snaps[i]; + } + int retval = ctx->set_snap_write_context((snapid_t)seq, snv); + tracepoint(librados, rados_ioctx_selfmanaged_snap_set_write_ctx_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_selfmanaged_snap_set_write_ctx); + +extern "C" int _rados_write(rados_ioctx_t io, const char *o, const char *buf, size_t len, uint64_t off) +{ + tracepoint(librados, rados_write_enter, io, o, buf, len, off); + if (len > UINT_MAX/2) + return -E2BIG; + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + bufferlist bl; + bl.append(buf, len); + int retval = ctx->write(oid, bl, len, off); + tracepoint(librados, rados_write_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write); + +extern "C" int _rados_append(rados_ioctx_t io, const char *o, const char *buf, size_t len) +{ + tracepoint(librados, rados_append_enter, io, o, buf, len); + if (len > UINT_MAX/2) + return -E2BIG; + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + bufferlist bl; + bl.append(buf, len); + int retval = ctx->append(oid, bl, len); + tracepoint(librados, rados_append_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_append); + +extern "C" int _rados_write_full(rados_ioctx_t io, const char *o, const char *buf, size_t len) +{ + tracepoint(librados, rados_write_full_enter, io, o, buf, len); + if (len > UINT_MAX/2) + return -E2BIG; + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + bufferlist bl; + bl.append(buf, len); + int retval = ctx->write_full(oid, bl); + tracepoint(librados, rados_write_full_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_full); + +extern "C" int _rados_writesame(rados_ioctx_t io, + const char *o, + const char *buf, + size_t data_len, + size_t write_len, + uint64_t off) +{ + tracepoint(librados, rados_writesame_enter, io, o, buf, data_len, write_len, off); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + bufferlist bl; + bl.append(buf, data_len); + int retval = ctx->writesame(oid, bl, write_len, off); + tracepoint(librados, rados_writesame_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_writesame); + +extern "C" int _rados_trunc(rados_ioctx_t io, const char *o, uint64_t size) +{ + tracepoint(librados, rados_trunc_enter, io, o, size); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + int retval = ctx->trunc(oid, size); + tracepoint(librados, rados_trunc_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_trunc); + +extern "C" int _rados_remove(rados_ioctx_t io, const char *o) +{ + tracepoint(librados, rados_remove_enter, io, o); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + int retval = ctx->remove(oid); + tracepoint(librados, rados_remove_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_remove); + +extern "C" int _rados_read(rados_ioctx_t io, const char *o, char *buf, size_t len, uint64_t off) +{ + tracepoint(librados, rados_read_enter, io, o, buf, len, off); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + int ret; + object_t oid(o); + + bufferlist bl; + bufferptr bp = buffer::create_static(len, buf); + bl.push_back(bp); + + ret = ctx->read(oid, bl, len, off); + if (ret >= 0) { + if (bl.length() > len) { + tracepoint(librados, rados_read_exit, -ERANGE, NULL); + return -ERANGE; + } + if (!bl.is_provided_buffer(buf)) + bl.copy(0, bl.length(), buf); + ret = bl.length(); // hrm :/ + } + + tracepoint(librados, rados_read_exit, ret, buf); + return ret; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_read); + +extern "C" int _rados_checksum(rados_ioctx_t io, const char *o, + rados_checksum_type_t type, + const char *init_value, size_t init_value_len, + size_t len, uint64_t off, size_t chunk_size, + char *pchecksum, size_t checksum_len) +{ + tracepoint(librados, rados_checksum_enter, io, o, type, init_value, + init_value_len, len, off, chunk_size); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + + bufferlist init_value_bl; + init_value_bl.append(init_value, init_value_len); + + bufferlist checksum_bl; + + int retval = ctx->checksum(oid, get_checksum_op_type(type), init_value_bl, + len, off, chunk_size, &checksum_bl); + if (retval >= 0) { + if (checksum_bl.length() > checksum_len) { + tracepoint(librados, rados_checksum_exit, -ERANGE, NULL, 0); + return -ERANGE; + } + + checksum_bl.copy(0, checksum_bl.length(), pchecksum); + } + tracepoint(librados, rados_checksum_exit, retval, pchecksum, checksum_len); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_checksum); + +extern "C" uint64_t _rados_get_last_version(rados_ioctx_t io) +{ + tracepoint(librados, rados_get_last_version_enter, io); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + uint64_t retval = ctx->last_version(); + tracepoint(librados, rados_get_last_version_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_get_last_version); + +extern "C" int _rados_pool_create(rados_t cluster, const char *name) +{ + tracepoint(librados, rados_pool_create_enter, cluster, name); + librados::RadosClient *radosp = (librados::RadosClient *)cluster; + string sname(name); + int retval = radosp->pool_create(sname); + tracepoint(librados, rados_pool_create_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_pool_create); + +extern "C" int _rados_pool_create_with_auid(rados_t cluster, const char *name, + uint64_t auid) +{ + tracepoint(librados, rados_pool_create_with_auid_enter, cluster, name, auid); + librados::RadosClient *radosp = (librados::RadosClient *)cluster; + string sname(name); + int retval = 0; + if (auid != CEPH_AUTH_UID_DEFAULT) { + retval = -EINVAL; + } else { + retval = radosp->pool_create(sname); + } + tracepoint(librados, rados_pool_create_with_auid_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_pool_create_with_auid); + +extern "C" int _rados_pool_create_with_crush_rule(rados_t cluster, const char *name, + __u8 crush_rule_num) +{ + tracepoint(librados, rados_pool_create_with_crush_rule_enter, cluster, name, crush_rule_num); + librados::RadosClient *radosp = (librados::RadosClient *)cluster; + string sname(name); + int retval = radosp->pool_create(sname, crush_rule_num); + tracepoint(librados, rados_pool_create_with_crush_rule_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_pool_create_with_crush_rule); + +extern "C" int _rados_pool_create_with_all(rados_t cluster, const char *name, + uint64_t auid, __u8 crush_rule_num) +{ + tracepoint(librados, rados_pool_create_with_all_enter, cluster, name, auid, crush_rule_num); + librados::RadosClient *radosp = (librados::RadosClient *)cluster; + string sname(name); + int retval = 0; + if (auid != CEPH_AUTH_UID_DEFAULT) { + retval = -EINVAL; + } else { + retval = radosp->pool_create(sname, crush_rule_num); + } + tracepoint(librados, rados_pool_create_with_all_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_pool_create_with_all); + +extern "C" int _rados_pool_get_base_tier(rados_t cluster, int64_t pool_id, int64_t* base_tier) +{ + tracepoint(librados, rados_pool_get_base_tier_enter, cluster, pool_id); + librados::RadosClient *client = (librados::RadosClient *)cluster; + int retval = client->pool_get_base_tier(pool_id, base_tier); + tracepoint(librados, rados_pool_get_base_tier_exit, retval, *base_tier); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_pool_get_base_tier); + +extern "C" int _rados_pool_delete(rados_t cluster, const char *pool_name) +{ + tracepoint(librados, rados_pool_delete_enter, cluster, pool_name); + librados::RadosClient *client = (librados::RadosClient *)cluster; + int retval = client->pool_delete(pool_name); + tracepoint(librados, rados_pool_delete_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_pool_delete); + +extern "C" int _rados_ioctx_pool_set_auid(rados_ioctx_t io, uint64_t auid) +{ + tracepoint(librados, rados_ioctx_pool_set_auid_enter, io, auid); + int retval = -EOPNOTSUPP; + tracepoint(librados, rados_ioctx_pool_set_auid_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_pool_set_auid); + +extern "C" int _rados_ioctx_pool_get_auid(rados_ioctx_t io, uint64_t *auid) +{ + tracepoint(librados, rados_ioctx_pool_get_auid_enter, io); + int retval = -EOPNOTSUPP; + tracepoint(librados, rados_ioctx_pool_get_auid_exit, retval, *auid); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_pool_get_auid); + +extern "C" int _rados_ioctx_pool_requires_alignment(rados_ioctx_t io) +{ + tracepoint(librados, rados_ioctx_pool_requires_alignment_enter, io); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + int retval = ctx->client->pool_requires_alignment(ctx->get_id()); + tracepoint(librados, rados_ioctx_pool_requires_alignment_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_pool_requires_alignment); + +extern "C" int _rados_ioctx_pool_requires_alignment2(rados_ioctx_t io, + int *requires) +{ + tracepoint(librados, rados_ioctx_pool_requires_alignment_enter2, io); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + bool requires_alignment; + int retval = ctx->client->pool_requires_alignment2(ctx->get_id(), + &requires_alignment); + tracepoint(librados, rados_ioctx_pool_requires_alignment_exit2, retval, + requires_alignment); + if (requires) + *requires = requires_alignment; + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_pool_requires_alignment2); + +extern "C" uint64_t _rados_ioctx_pool_required_alignment(rados_ioctx_t io) +{ + tracepoint(librados, rados_ioctx_pool_required_alignment_enter, io); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + uint64_t retval = ctx->client->pool_required_alignment(ctx->get_id()); + tracepoint(librados, rados_ioctx_pool_required_alignment_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_pool_required_alignment); + +extern "C" int _rados_ioctx_pool_required_alignment2(rados_ioctx_t io, + uint64_t *alignment) +{ + tracepoint(librados, rados_ioctx_pool_required_alignment_enter2, io); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + int retval = ctx->client->pool_required_alignment2(ctx->get_id(), + alignment); + tracepoint(librados, rados_ioctx_pool_required_alignment_exit2, retval, + *alignment); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_pool_required_alignment2); + +extern "C" void _rados_ioctx_locator_set_key(rados_ioctx_t io, const char *key) +{ + tracepoint(librados, rados_ioctx_locator_set_key_enter, io, key); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + if (key) + ctx->oloc.key = key; + else + ctx->oloc.key = ""; + tracepoint(librados, rados_ioctx_locator_set_key_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_locator_set_key); + +extern "C" void _rados_ioctx_set_namespace(rados_ioctx_t io, const char *nspace) +{ + tracepoint(librados, rados_ioctx_set_namespace_enter, io, nspace); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + if (nspace) + ctx->oloc.nspace = nspace; + else + ctx->oloc.nspace = ""; + tracepoint(librados, rados_ioctx_set_namespace_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_set_namespace); + +extern "C" int _rados_ioctx_get_namespace(rados_ioctx_t io, char *s, + unsigned maxlen) +{ + tracepoint(librados, rados_ioctx_get_namespace_enter, io, maxlen); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + auto length = ctx->oloc.nspace.length(); + if (length >= maxlen) { + tracepoint(librados, rados_ioctx_get_namespace_exit, -ERANGE, ""); + return -ERANGE; + } + strcpy(s, ctx->oloc.nspace.c_str()); + int retval = (int)length; + tracepoint(librados, rados_ioctx_get_namespace_exit, retval, s); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_get_namespace); + +extern "C" rados_t _rados_ioctx_get_cluster(rados_ioctx_t io) +{ + tracepoint(librados, rados_ioctx_get_cluster_enter, io); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + rados_t retval = (rados_t)ctx->client; + tracepoint(librados, rados_ioctx_get_cluster_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_get_cluster); + +extern "C" int64_t _rados_ioctx_get_id(rados_ioctx_t io) +{ + tracepoint(librados, rados_ioctx_get_id_enter, io); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + int64_t retval = ctx->get_id(); + tracepoint(librados, rados_ioctx_get_id_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_get_id); + +extern "C" int _rados_ioctx_get_pool_name(rados_ioctx_t io, char *s, unsigned maxlen) +{ + tracepoint(librados, rados_ioctx_get_pool_name_enter, io, maxlen); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + std::string pool_name; + + int err = ctx->client->pool_get_name(ctx->get_id(), &pool_name); + if (err) { + tracepoint(librados, rados_ioctx_get_pool_name_exit, err, ""); + return err; + } + if (pool_name.length() >= maxlen) { + tracepoint(librados, rados_ioctx_get_pool_name_exit, -ERANGE, ""); + return -ERANGE; + } + strcpy(s, pool_name.c_str()); + int retval = pool_name.length(); + tracepoint(librados, rados_ioctx_get_pool_name_exit, retval, s); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_get_pool_name); + +// snaps + +extern "C" int _rados_ioctx_snap_create(rados_ioctx_t io, const char *snapname) +{ + tracepoint(librados, rados_ioctx_snap_create_enter, io, snapname); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + int retval = ctx->snap_create(snapname); + tracepoint(librados, rados_ioctx_snap_create_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_snap_create); + +extern "C" int _rados_ioctx_snap_remove(rados_ioctx_t io, const char *snapname) +{ + tracepoint(librados, rados_ioctx_snap_remove_enter, io, snapname); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + int retval = ctx->snap_remove(snapname); + tracepoint(librados, rados_ioctx_snap_remove_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_snap_remove); + +extern "C" int _rados_ioctx_snap_rollback(rados_ioctx_t io, const char *oid, + const char *snapname) +{ + tracepoint(librados, rados_ioctx_snap_rollback_enter, io, oid, snapname); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + int retval = ctx->rollback(oid, snapname); + tracepoint(librados, rados_ioctx_snap_rollback_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_snap_rollback); + +// Deprecated name kept for backward compatibility +extern "C" int _rados_rollback(rados_ioctx_t io, const char *oid, + const char *snapname) +{ + return _rados_ioctx_snap_rollback(io, oid, snapname); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_rollback); + +extern "C" int _rados_ioctx_selfmanaged_snap_create(rados_ioctx_t io, + uint64_t *snapid) +{ + tracepoint(librados, rados_ioctx_selfmanaged_snap_create_enter, io); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + int retval = ctx->selfmanaged_snap_create(snapid); + tracepoint(librados, rados_ioctx_selfmanaged_snap_create_exit, retval, *snapid); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_selfmanaged_snap_create); + +extern "C" void +_rados_aio_ioctx_selfmanaged_snap_create(rados_ioctx_t io, + rados_snap_t *snapid, + rados_completion_t completion) +{ + tracepoint(librados, rados_ioctx_selfmanaged_snap_create_enter, io); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + librados::AioCompletionImpl *c = (librados::AioCompletionImpl*)completion; + ctx->aio_selfmanaged_snap_create(snapid, c); + tracepoint(librados, rados_ioctx_selfmanaged_snap_create_exit, 0, 0); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_ioctx_selfmanaged_snap_create); + +extern "C" int _rados_ioctx_selfmanaged_snap_remove(rados_ioctx_t io, + uint64_t snapid) +{ + tracepoint(librados, rados_ioctx_selfmanaged_snap_remove_enter, io, snapid); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + int retval = ctx->selfmanaged_snap_remove(snapid); + tracepoint(librados, rados_ioctx_selfmanaged_snap_remove_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_selfmanaged_snap_remove); + +extern "C" void +_rados_aio_ioctx_selfmanaged_snap_remove(rados_ioctx_t io, + rados_snap_t snapid, + rados_completion_t completion) +{ + tracepoint(librados, rados_ioctx_selfmanaged_snap_remove_enter, io, snapid); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + librados::AioCompletionImpl *c = (librados::AioCompletionImpl*)completion; + ctx->aio_selfmanaged_snap_remove(snapid, c); + tracepoint(librados, rados_ioctx_selfmanaged_snap_remove_exit, 0); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_ioctx_selfmanaged_snap_remove); + +extern "C" int _rados_ioctx_selfmanaged_snap_rollback(rados_ioctx_t io, + const char *oid, + uint64_t snapid) +{ + tracepoint(librados, rados_ioctx_selfmanaged_snap_rollback_enter, io, oid, snapid); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + int retval = ctx->selfmanaged_snap_rollback_object(oid, ctx->snapc, snapid); + tracepoint(librados, rados_ioctx_selfmanaged_snap_rollback_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_selfmanaged_snap_rollback); + +extern "C" int _rados_ioctx_snap_list(rados_ioctx_t io, rados_snap_t *snaps, + int maxlen) +{ + tracepoint(librados, rados_ioctx_snap_list_enter, io, maxlen); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + vector<uint64_t> snapvec; + int r = ctx->snap_list(&snapvec); + if (r < 0) { + tracepoint(librados, rados_ioctx_snap_list_exit, r, snaps, 0); + return r; + } + if ((int)snapvec.size() <= maxlen) { + for (unsigned i=0; i<snapvec.size(); i++) { + snaps[i] = snapvec[i]; + } + int retval = snapvec.size(); + tracepoint(librados, rados_ioctx_snap_list_exit, retval, snaps, retval); + return retval; + } + int retval = -ERANGE; + tracepoint(librados, rados_ioctx_snap_list_exit, retval, snaps, 0); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_snap_list); + +extern "C" int _rados_ioctx_snap_lookup(rados_ioctx_t io, const char *name, + rados_snap_t *id) +{ + tracepoint(librados, rados_ioctx_snap_lookup_enter, io, name); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + int retval = ctx->snap_lookup(name, (uint64_t *)id); + tracepoint(librados, rados_ioctx_snap_lookup_exit, retval, *id); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_snap_lookup); + +extern "C" int _rados_ioctx_snap_get_name(rados_ioctx_t io, rados_snap_t id, + char *name, int maxlen) +{ + tracepoint(librados, rados_ioctx_snap_get_name_enter, io, id, maxlen); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + std::string sname; + int r = ctx->snap_get_name(id, &sname); + if (r < 0) { + tracepoint(librados, rados_ioctx_snap_get_name_exit, r, ""); + return r; + } + if ((int)sname.length() >= maxlen) { + int retval = -ERANGE; + tracepoint(librados, rados_ioctx_snap_get_name_exit, retval, ""); + return retval; + } + strncpy(name, sname.c_str(), maxlen); + tracepoint(librados, rados_ioctx_snap_get_name_exit, 0, name); + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_snap_get_name); + +extern "C" int _rados_ioctx_snap_get_stamp(rados_ioctx_t io, rados_snap_t id, time_t *t) +{ + tracepoint(librados, rados_ioctx_snap_get_stamp_enter, io, id); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + int retval = ctx->snap_get_stamp(id, t); + tracepoint(librados, rados_ioctx_snap_get_stamp_exit, retval, *t); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_ioctx_snap_get_stamp); + +extern "C" int _rados_cmpext(rados_ioctx_t io, const char *o, + const char *cmp_buf, size_t cmp_len, uint64_t off) +{ + tracepoint(librados, rados_cmpext_enter, io, o, cmp_buf, cmp_len, off); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + int ret; + object_t oid(o); + + bufferlist cmp_bl; + cmp_bl.append(cmp_buf, cmp_len); + + ret = ctx->cmpext(oid, off, cmp_bl); + tracepoint(librados, rados_cmpext_exit, ret); + + return ret; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_cmpext); + +extern "C" int _rados_getxattr(rados_ioctx_t io, const char *o, const char *name, + char *buf, size_t len) +{ + tracepoint(librados, rados_getxattr_enter, io, o, name, len); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + int ret; + object_t oid(o); + bufferlist bl; + bl.push_back(buffer::create_static(len, buf)); + ret = ctx->getxattr(oid, name, bl); + if (ret >= 0) { + if (bl.length() > len) { + tracepoint(librados, rados_getxattr_exit, -ERANGE, buf, 0); + return -ERANGE; + } + if (!bl.is_provided_buffer(buf)) + bl.copy(0, bl.length(), buf); + ret = bl.length(); + } + + tracepoint(librados, rados_getxattr_exit, ret, buf, ret); + return ret; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_getxattr); + +extern "C" int _rados_getxattrs(rados_ioctx_t io, const char *oid, + rados_xattrs_iter_t *iter) +{ + tracepoint(librados, rados_getxattrs_enter, io, oid); + librados::RadosXattrsIter *it = new librados::RadosXattrsIter(); + if (!it) { + tracepoint(librados, rados_getxattrs_exit, -ENOMEM, NULL); + return -ENOMEM; + } + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t obj(oid); + int ret = ctx->getxattrs(obj, it->attrset); + if (ret) { + delete it; + tracepoint(librados, rados_getxattrs_exit, ret, NULL); + return ret; + } + it->i = it->attrset.begin(); + + *iter = it; + tracepoint(librados, rados_getxattrs_exit, 0, *iter); + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_getxattrs); + +extern "C" int _rados_getxattrs_next(rados_xattrs_iter_t iter, + const char **name, const char **val, + size_t *len) +{ + tracepoint(librados, rados_getxattrs_next_enter, iter); + librados::RadosXattrsIter *it = static_cast<librados::RadosXattrsIter*>(iter); + if (it->val) { + free(it->val); + it->val = NULL; + } + if (it->i == it->attrset.end()) { + *name = NULL; + *val = NULL; + *len = 0; + tracepoint(librados, rados_getxattrs_next_exit, 0, NULL, NULL, 0); + return 0; + } + const std::string &s(it->i->first); + *name = s.c_str(); + bufferlist &bl(it->i->second); + size_t bl_len = bl.length(); + if (!bl_len) { + // malloc(0) is not guaranteed to return a valid pointer + *val = (char *)NULL; + } else { + it->val = (char*)malloc(bl_len); + if (!it->val) { + tracepoint(librados, rados_getxattrs_next_exit, -ENOMEM, *name, NULL, 0); + return -ENOMEM; + } + memcpy(it->val, bl.c_str(), bl_len); + *val = it->val; + } + *len = bl_len; + ++it->i; + tracepoint(librados, rados_getxattrs_next_exit, 0, *name, *val, *len); + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_getxattrs_next); + +extern "C" void _rados_getxattrs_end(rados_xattrs_iter_t iter) +{ + tracepoint(librados, rados_getxattrs_end_enter, iter); + librados::RadosXattrsIter *it = static_cast<librados::RadosXattrsIter*>(iter); + delete it; + tracepoint(librados, rados_getxattrs_end_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_getxattrs_end); + +extern "C" int _rados_setxattr(rados_ioctx_t io, const char *o, const char *name, const char *buf, size_t len) +{ + tracepoint(librados, rados_setxattr_enter, io, o, name, buf, len); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + bufferlist bl; + bl.append(buf, len); + int retval = ctx->setxattr(oid, name, bl); + tracepoint(librados, rados_setxattr_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_setxattr); + +extern "C" int _rados_rmxattr(rados_ioctx_t io, const char *o, const char *name) +{ + tracepoint(librados, rados_rmxattr_enter, io, o, name); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + int retval = ctx->rmxattr(oid, name); + tracepoint(librados, rados_rmxattr_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_rmxattr); + +extern "C" int _rados_stat(rados_ioctx_t io, const char *o, uint64_t *psize, time_t *pmtime) +{ + tracepoint(librados, rados_stat_enter, io, o); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + int retval = ctx->stat(oid, psize, pmtime); + tracepoint(librados, rados_stat_exit, retval, psize, pmtime); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_stat); + +extern "C" int _rados_tmap_update_base(rados_ioctx_t io, const char *o, + const char *cmdbuf, size_t cmdbuflen) +{ + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + bufferlist cmdbl; + cmdbl.append(cmdbuf, cmdbuflen); + return ctx->tmap_update(oid, cmdbl); +} +LIBRADOS_C_API_BASE(rados_tmap_update); + +extern "C" int _rados_tmap_update(rados_ioctx_t io, const char *o, + const char *cmdbuf, size_t cmdbuflen) +{ + return -ENOTSUP; +} +LIBRADOS_C_API_DEFAULT(rados_tmap_update, 14.2.0); + +extern "C" int _rados_tmap_put_base(rados_ioctx_t io, const char *o, + const char *buf, size_t buflen) +{ + bufferlist bl; + bl.append(buf, buflen); + + bufferlist header; + std::map<std::string, bufferlist> m; + bufferlist::const_iterator bl_it = bl.begin(); + decode(header, bl_it); + decode(m, bl_it); + + bufferlist out_bl; + encode(header, out_bl); + encode(m, out_bl); + + return _rados_write_full(io, o, out_bl.c_str(), out_bl.length()); +} +LIBRADOS_C_API_BASE(rados_tmap_put); + +extern "C" int _rados_tmap_put(rados_ioctx_t io, const char *o, + const char *buf, size_t buflen) +{ + return -EOPNOTSUPP; +} +LIBRADOS_C_API_DEFAULT(rados_tmap_put, 14.2.0); + +extern "C" int _rados_tmap_get_base(rados_ioctx_t io, const char *o, char *buf, + size_t buflen) +{ + return _rados_read(io, o, buf, buflen, 0); +} +LIBRADOS_C_API_BASE(rados_tmap_get); + +extern "C" int _rados_tmap_get(rados_ioctx_t io, const char *o, char *buf, + size_t buflen) +{ + return -EOPNOTSUPP; +} +LIBRADOS_C_API_DEFAULT(rados_tmap_get, 14.2.0); + +extern "C" int _rados_exec(rados_ioctx_t io, const char *o, const char *cls, const char *method, + const char *inbuf, size_t in_len, char *buf, size_t out_len) +{ + tracepoint(librados, rados_exec_enter, io, o, cls, method, inbuf, in_len, out_len); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + bufferlist inbl, outbl; + int ret; + inbl.append(inbuf, in_len); + ret = ctx->exec(oid, cls, method, inbl, outbl); + if (ret >= 0) { + if (outbl.length()) { + if (outbl.length() > out_len) { + tracepoint(librados, rados_exec_exit, -ERANGE, buf, 0); + return -ERANGE; + } + outbl.copy(0, outbl.length(), buf); + ret = outbl.length(); // hrm :/ + } + } + tracepoint(librados, rados_exec_exit, ret, buf, ret); + return ret; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_exec); + +extern "C" rados_object_list_cursor _rados_object_list_begin(rados_ioctx_t io) +{ + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + + hobject_t *result = new hobject_t(ctx->objecter->enumerate_objects_begin()); + return (rados_object_list_cursor)result; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_object_list_begin); + +extern "C" rados_object_list_cursor _rados_object_list_end(rados_ioctx_t io) +{ + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + + hobject_t *result = new hobject_t(ctx->objecter->enumerate_objects_end()); + return (rados_object_list_cursor)result; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_object_list_end); + +extern "C" int _rados_object_list_is_end( + rados_ioctx_t io, rados_object_list_cursor cur) +{ + hobject_t *hobj = (hobject_t*)cur; + return hobj->is_max(); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_object_list_is_end); + +extern "C" void _rados_object_list_cursor_free( + rados_ioctx_t io, rados_object_list_cursor cur) +{ + hobject_t *hobj = (hobject_t*)cur; + delete hobj; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_object_list_cursor_free); + +extern "C" int _rados_object_list_cursor_cmp( + rados_ioctx_t io, + rados_object_list_cursor lhs_cur, + rados_object_list_cursor rhs_cur) +{ + hobject_t *lhs = (hobject_t*)lhs_cur; + hobject_t *rhs = (hobject_t*)rhs_cur; + return cmp(*lhs, *rhs); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_object_list_cursor_cmp); + +extern "C" int _rados_object_list(rados_ioctx_t io, + const rados_object_list_cursor start, + const rados_object_list_cursor finish, + const size_t result_item_count, + const char *filter_buf, + const size_t filter_buf_len, + rados_object_list_item *result_items, + rados_object_list_cursor *next) +{ + ceph_assert(next); + + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + + // Zero out items so that they will be safe to free later + // FIPS zeroization audit 20191116: this memset is not security related. + memset(result_items, 0, sizeof(rados_object_list_item) * result_item_count); + + std::list<librados::ListObjectImpl> result; + hobject_t next_hash; + + bufferlist filter_bl; + if (filter_buf != nullptr) { + filter_bl.append(filter_buf, filter_buf_len); + } + + C_SaferCond cond; + ctx->objecter->enumerate_objects( + ctx->poolid, + ctx->oloc.nspace, + *((hobject_t*)start), + *((hobject_t*)finish), + result_item_count, + filter_bl, + &result, + &next_hash, + &cond); + + hobject_t *next_hobj = (hobject_t*)(*next); + ceph_assert(next_hobj); + + int r = cond.wait(); + if (r < 0) { + *next_hobj = hobject_t::get_max(); + return r; + } + + ceph_assert(result.size() <= result_item_count); // Don't overflow! + + int k = 0; + for (std::list<librados::ListObjectImpl>::iterator i = result.begin(); + i != result.end(); ++i) { + rados_object_list_item &item = result_items[k++]; + do_out_buffer(i->oid, &item.oid, &item.oid_length); + do_out_buffer(i->nspace, &item.nspace, &item.nspace_length); + do_out_buffer(i->locator, &item.locator, &item.locator_length); + } + + *next_hobj = next_hash; + + return result.size(); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_object_list); + +extern "C" void _rados_object_list_free( + const size_t result_size, + rados_object_list_item *results) +{ + ceph_assert(results); + + for (unsigned int i = 0; i < result_size; ++i) { + _rados_buffer_free(results[i].oid); + _rados_buffer_free(results[i].locator); + _rados_buffer_free(results[i].nspace); + } +} +LIBRADOS_C_API_BASE_DEFAULT(rados_object_list_free); + +/* list objects */ + +extern "C" int _rados_nobjects_list_open(rados_ioctx_t io, rados_list_ctx_t *listh) +{ + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + + tracepoint(librados, rados_nobjects_list_open_enter, io); + + Objecter::NListContext *h = new Objecter::NListContext; + h->pool_id = ctx->poolid; + h->pool_snap_seq = ctx->snap_seq; + h->nspace = ctx->oloc.nspace; // After dropping compatibility need nspace + *listh = (void *)new librados::ObjListCtx(ctx, h); + tracepoint(librados, rados_nobjects_list_open_exit, 0, *listh); + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_nobjects_list_open); + +extern "C" void _rados_nobjects_list_close(rados_list_ctx_t h) +{ + tracepoint(librados, rados_nobjects_list_close_enter, h); + librados::ObjListCtx *lh = (librados::ObjListCtx *)h; + delete lh; + tracepoint(librados, rados_nobjects_list_close_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_nobjects_list_close); + +extern "C" uint32_t _rados_nobjects_list_seek(rados_list_ctx_t listctx, + uint32_t pos) +{ + librados::ObjListCtx *lh = (librados::ObjListCtx *)listctx; + tracepoint(librados, rados_nobjects_list_seek_enter, listctx, pos); + uint32_t r = lh->ctx->nlist_seek(lh->nlc, pos); + tracepoint(librados, rados_nobjects_list_seek_exit, r); + return r; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_nobjects_list_seek); + +extern "C" uint32_t _rados_nobjects_list_seek_cursor(rados_list_ctx_t listctx, + rados_object_list_cursor cursor) +{ + librados::ObjListCtx *lh = (librados::ObjListCtx *)listctx; + + tracepoint(librados, rados_nobjects_list_seek_cursor_enter, listctx); + uint32_t r = lh->ctx->nlist_seek(lh->nlc, cursor); + tracepoint(librados, rados_nobjects_list_seek_cursor_exit, r); + return r; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_nobjects_list_seek_cursor); + +extern "C" int _rados_nobjects_list_get_cursor(rados_list_ctx_t listctx, + rados_object_list_cursor *cursor) +{ + librados::ObjListCtx *lh = (librados::ObjListCtx *)listctx; + + tracepoint(librados, rados_nobjects_list_get_cursor_enter, listctx); + *cursor = lh->ctx->nlist_get_cursor(lh->nlc); + tracepoint(librados, rados_nobjects_list_get_cursor_exit, 0); + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_nobjects_list_get_cursor); + +extern "C" uint32_t _rados_nobjects_list_get_pg_hash_position( + rados_list_ctx_t listctx) +{ + librados::ObjListCtx *lh = (librados::ObjListCtx *)listctx; + tracepoint(librados, rados_nobjects_list_get_pg_hash_position_enter, listctx); + uint32_t retval = lh->nlc->get_pg_hash_position(); + tracepoint(librados, rados_nobjects_list_get_pg_hash_position_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_nobjects_list_get_pg_hash_position); + +extern "C" int _rados_nobjects_list_next(rados_list_ctx_t listctx, const char **entry, const char **key, const char **nspace) +{ + tracepoint(librados, rados_nobjects_list_next_enter, listctx); + uint32_t retval = rados_nobjects_list_next2(listctx, entry, key, nspace, NULL, NULL, NULL); + tracepoint(librados, rados_nobjects_list_next_exit, 0, *entry, key, nspace); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_nobjects_list_next); + +extern "C" int _rados_nobjects_list_next2( + rados_list_ctx_t listctx, + const char **entry, + const char **key, + const char **nspace, + size_t *entry_size, + size_t *key_size, + size_t *nspace_size) +{ + tracepoint(librados, rados_nobjects_list_next2_enter, listctx); + librados::ObjListCtx *lh = (librados::ObjListCtx *)listctx; + Objecter::NListContext *h = lh->nlc; + + // if the list is non-empty, this method has been called before + if (!h->list.empty()) + // so let's kill the previously-returned object + h->list.pop_front(); + + if (h->list.empty()) { + int ret = lh->ctx->nlist(lh->nlc, RADOS_LIST_MAX_ENTRIES); + if (ret < 0) { + tracepoint(librados, rados_nobjects_list_next2_exit, ret, NULL, NULL, NULL, NULL, NULL, NULL); + return ret; + } + if (h->list.empty()) { + tracepoint(librados, rados_nobjects_list_next2_exit, -ENOENT, NULL, NULL, NULL, NULL, NULL, NULL); + return -ENOENT; + } + } + + *entry = h->list.front().oid.c_str(); + + if (key) { + if (h->list.front().locator.size()) + *key = h->list.front().locator.c_str(); + else + *key = NULL; + } + if (nspace) + *nspace = h->list.front().nspace.c_str(); + + if (entry_size) + *entry_size = h->list.front().oid.size(); + if (key_size) + *key_size = h->list.front().locator.size(); + if (nspace_size) + *nspace_size = h->list.front().nspace.size(); + + tracepoint(librados, rados_nobjects_list_next2_exit, 0, entry, key, nspace, + entry_size, key_size, nspace_size); + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_nobjects_list_next2); + + +/* + * removed legacy v2 list objects stubs + * + * thse return -ENOTSUP where possible. + */ +extern "C" int _rados_objects_list_open( + rados_ioctx_t io, + rados_list_ctx_t *ctx) +{ + return -ENOTSUP; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_objects_list_open); + +extern "C" uint32_t _rados_objects_list_get_pg_hash_position( + rados_list_ctx_t ctx) +{ + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_objects_list_get_pg_hash_position); + +extern "C" uint32_t _rados_objects_list_seek( + rados_list_ctx_t ctx, + uint32_t pos) +{ + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_objects_list_seek); + +extern "C" int _rados_objects_list_next( + rados_list_ctx_t ctx, + const char **entry, + const char **key) +{ + return -ENOTSUP; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_objects_list_next); + +extern "C" void _rados_objects_list_close( + rados_list_ctx_t ctx) +{ +} +LIBRADOS_C_API_BASE_DEFAULT(rados_objects_list_close); + + +// ------------------------- +// aio + +extern "C" int _rados_aio_create_completion(void *cb_arg, + rados_callback_t cb_complete, + rados_callback_t cb_safe, + rados_completion_t *pc) +{ + tracepoint(librados, rados_aio_create_completion_enter, cb_arg, cb_complete, cb_safe); + librados::AioCompletionImpl *c = new librados::AioCompletionImpl; + if (cb_complete) + c->set_complete_callback(cb_arg, cb_complete); + if (cb_safe) + c->set_safe_callback(cb_arg, cb_safe); + *pc = c; + tracepoint(librados, rados_aio_create_completion_exit, 0, *pc); + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_create_completion); + +extern "C" int _rados_aio_wait_for_complete(rados_completion_t c) +{ + tracepoint(librados, rados_aio_wait_for_complete_enter, c); + int retval = ((librados::AioCompletionImpl*)c)->wait_for_complete(); + tracepoint(librados, rados_aio_wait_for_complete_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_wait_for_complete); + +extern "C" int _rados_aio_wait_for_safe(rados_completion_t c) +{ + tracepoint(librados, rados_aio_wait_for_safe_enter, c); + int retval = ((librados::AioCompletionImpl*)c)->wait_for_safe(); + tracepoint(librados, rados_aio_wait_for_safe_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_wait_for_safe); + +extern "C" int _rados_aio_is_complete(rados_completion_t c) +{ + tracepoint(librados, rados_aio_is_complete_enter, c); + int retval = ((librados::AioCompletionImpl*)c)->is_complete(); + tracepoint(librados, rados_aio_is_complete_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_is_complete); + +extern "C" int _rados_aio_is_safe(rados_completion_t c) +{ + tracepoint(librados, rados_aio_is_safe_enter, c); + int retval = ((librados::AioCompletionImpl*)c)->is_safe(); + tracepoint(librados, rados_aio_is_safe_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_is_safe); + +extern "C" int _rados_aio_wait_for_complete_and_cb(rados_completion_t c) +{ + tracepoint(librados, rados_aio_wait_for_complete_and_cb_enter, c); + int retval = ((librados::AioCompletionImpl*)c)->wait_for_complete_and_cb(); + tracepoint(librados, rados_aio_wait_for_complete_and_cb_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_wait_for_complete_and_cb); + +extern "C" int _rados_aio_wait_for_safe_and_cb(rados_completion_t c) +{ + tracepoint(librados, rados_aio_wait_for_safe_and_cb_enter, c); + int retval = ((librados::AioCompletionImpl*)c)->wait_for_safe_and_cb(); + tracepoint(librados, rados_aio_wait_for_safe_and_cb_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_wait_for_safe_and_cb); + +extern "C" int _rados_aio_is_complete_and_cb(rados_completion_t c) +{ + tracepoint(librados, rados_aio_is_complete_and_cb_enter, c); + int retval = ((librados::AioCompletionImpl*)c)->is_complete_and_cb(); + tracepoint(librados, rados_aio_is_complete_and_cb_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_is_complete_and_cb); + +extern "C" int _rados_aio_is_safe_and_cb(rados_completion_t c) +{ + tracepoint(librados, rados_aio_is_safe_and_cb_enter, c); + int retval = ((librados::AioCompletionImpl*)c)->is_safe_and_cb(); + tracepoint(librados, rados_aio_is_safe_and_cb_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_is_safe_and_cb); + +extern "C" int _rados_aio_get_return_value(rados_completion_t c) +{ + tracepoint(librados, rados_aio_get_return_value_enter, c); + int retval = ((librados::AioCompletionImpl*)c)->get_return_value(); + tracepoint(librados, rados_aio_get_return_value_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_get_return_value); + +extern "C" uint64_t _rados_aio_get_version(rados_completion_t c) +{ + tracepoint(librados, rados_aio_get_version_enter, c); + uint64_t retval = ((librados::AioCompletionImpl*)c)->get_version(); + tracepoint(librados, rados_aio_get_version_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_get_version); + +extern "C" void _rados_aio_release(rados_completion_t c) +{ + tracepoint(librados, rados_aio_release_enter, c); + ((librados::AioCompletionImpl*)c)->put(); + tracepoint(librados, rados_aio_release_exit); +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_release); +} + +extern "C" int _rados_aio_read(rados_ioctx_t io, const char *o, + rados_completion_t completion, + char *buf, size_t len, uint64_t off) +{ + tracepoint(librados, rados_aio_read_enter, io, o, completion, len, off); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + int retval = ctx->aio_read(oid, (librados::AioCompletionImpl*)completion, + buf, len, off, ctx->snap_seq); + tracepoint(librados, rados_aio_read_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_read); + +#ifdef WITH_BLKIN +extern "C" int _rados_aio_read_traced(rados_ioctx_t io, const char *o, + rados_completion_t completion, + char *buf, size_t len, uint64_t off, + struct blkin_trace_info *info) +{ + tracepoint(librados, rados_aio_read_enter, io, o, completion, len, off); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + int retval = ctx->aio_read(oid, (librados::AioCompletionImpl*)completion, + buf, len, off, ctx->snap_seq, info); + tracepoint(librados, rados_aio_read_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_read_traced); +#endif + +extern "C" int _rados_aio_write(rados_ioctx_t io, const char *o, + rados_completion_t completion, + const char *buf, size_t len, uint64_t off) +{ + tracepoint(librados, rados_aio_write_enter, io, o, completion, buf, len, off); + if (len > UINT_MAX/2) + return -E2BIG; + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + bufferlist bl; + bl.append(buf, len); + int retval = ctx->aio_write(oid, (librados::AioCompletionImpl*)completion, + bl, len, off); + tracepoint(librados, rados_aio_write_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_write); + +#ifdef WITH_BLKIN +extern "C" int _rados_aio_write_traced(rados_ioctx_t io, const char *o, + rados_completion_t completion, + const char *buf, size_t len, uint64_t off, + struct blkin_trace_info *info) +{ + tracepoint(librados, rados_aio_write_enter, io, o, completion, buf, len, off); + if (len > UINT_MAX/2) + return -E2BIG; + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + bufferlist bl; + bl.append(buf, len); + int retval = ctx->aio_write(oid, (librados::AioCompletionImpl*)completion, + bl, len, off, info); + tracepoint(librados, rados_aio_write_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_write_traced); +#endif + +extern "C" int _rados_aio_append(rados_ioctx_t io, const char *o, + rados_completion_t completion, + const char *buf, size_t len) +{ + tracepoint(librados, rados_aio_append_enter, io, o, completion, buf, len); + if (len > UINT_MAX/2) + return -E2BIG; + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + bufferlist bl; + bl.append(buf, len); + int retval = ctx->aio_append(oid, (librados::AioCompletionImpl*)completion, + bl, len); + tracepoint(librados, rados_aio_append_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_append); + +extern "C" int _rados_aio_write_full(rados_ioctx_t io, const char *o, + rados_completion_t completion, + const char *buf, size_t len) +{ + tracepoint(librados, rados_aio_write_full_enter, io, o, completion, buf, len); + if (len > UINT_MAX/2) + return -E2BIG; + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + bufferlist bl; + bl.append(buf, len); + int retval = ctx->aio_write_full(oid, (librados::AioCompletionImpl*)completion, bl); + tracepoint(librados, rados_aio_write_full_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_write_full); + +extern "C" int _rados_aio_writesame(rados_ioctx_t io, const char *o, + rados_completion_t completion, + const char *buf, size_t data_len, + size_t write_len, uint64_t off) +{ + tracepoint(librados, rados_aio_writesame_enter, io, o, completion, buf, + data_len, write_len, off); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + bufferlist bl; + bl.append(buf, data_len); + int retval = ctx->aio_writesame(o, (librados::AioCompletionImpl*)completion, + bl, write_len, off); + tracepoint(librados, rados_aio_writesame_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_writesame); + +extern "C" int _rados_aio_remove(rados_ioctx_t io, const char *o, + rados_completion_t completion) +{ + tracepoint(librados, rados_aio_remove_enter, io, o, completion); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + int retval = ctx->aio_remove(oid, (librados::AioCompletionImpl*)completion); + tracepoint(librados, rados_aio_remove_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_remove); + +extern "C" int _rados_aio_flush_async(rados_ioctx_t io, + rados_completion_t completion) +{ + tracepoint(librados, rados_aio_flush_async_enter, io, completion); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + ctx->flush_aio_writes_async((librados::AioCompletionImpl*)completion); + tracepoint(librados, rados_aio_flush_async_exit, 0); + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_flush_async); + +extern "C" int _rados_aio_flush(rados_ioctx_t io) +{ + tracepoint(librados, rados_aio_flush_enter, io); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + ctx->flush_aio_writes(); + tracepoint(librados, rados_aio_flush_exit, 0); + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_flush); + +struct AioGetxattrData { + AioGetxattrData(char* buf, rados_completion_t c, size_t l) : + user_buf(buf), len(l), user_completion((librados::AioCompletionImpl*)c) {} + bufferlist bl; + char* user_buf; + size_t len; + struct librados::C_AioCompleteAndSafe user_completion; +}; + +static void rados_aio_getxattr_complete(rados_completion_t c, void *arg) { + AioGetxattrData *cdata = reinterpret_cast<AioGetxattrData*>(arg); + int rc = _rados_aio_get_return_value(c); + if (rc >= 0) { + if (cdata->bl.length() > cdata->len) { + rc = -ERANGE; + } else { + if (!cdata->bl.is_provided_buffer(cdata->user_buf)) + cdata->bl.copy(0, cdata->bl.length(), cdata->user_buf); + rc = cdata->bl.length(); + } + } + cdata->user_completion.finish(rc); + delete cdata; +} + +extern "C" int _rados_aio_getxattr(rados_ioctx_t io, const char *o, + rados_completion_t completion, + const char *name, char *buf, size_t len) +{ + tracepoint(librados, rados_aio_getxattr_enter, io, o, completion, name, len); + // create data object to be passed to async callback + AioGetxattrData *cdata = new AioGetxattrData(buf, completion, len); + if (!cdata) { + tracepoint(librados, rados_aio_getxattr_exit, -ENOMEM, NULL, 0); + return -ENOMEM; + } + cdata->bl.push_back(buffer::create_static(len, buf)); + // create completion callback + librados::AioCompletionImpl *c = new librados::AioCompletionImpl; + c->set_complete_callback(cdata, rados_aio_getxattr_complete); + // call async getxattr of IoCtx + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + int ret = ctx->aio_getxattr(oid, c, name, cdata->bl); + tracepoint(librados, rados_aio_getxattr_exit, ret, buf, ret); + return ret; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_getxattr); + +namespace { +struct AioGetxattrsData { + AioGetxattrsData(rados_completion_t c, rados_xattrs_iter_t *_iter) : + iter(_iter), user_completion((librados::AioCompletionImpl*)c) { + it = new librados::RadosXattrsIter(); + } + ~AioGetxattrsData() { + if (it) delete it; + } + librados::RadosXattrsIter *it; + rados_xattrs_iter_t *iter; + struct librados::C_AioCompleteAndSafe user_completion; +}; +} + +static void rados_aio_getxattrs_complete(rados_completion_t c, void *arg) { + AioGetxattrsData *cdata = reinterpret_cast<AioGetxattrsData*>(arg); + int rc = _rados_aio_get_return_value(c); + if (rc) { + cdata->user_completion.finish(rc); + } else { + cdata->it->i = cdata->it->attrset.begin(); + *cdata->iter = cdata->it; + cdata->it = 0; + cdata->user_completion.finish(0); + } + delete cdata; +} + +extern "C" int _rados_aio_getxattrs(rados_ioctx_t io, const char *oid, + rados_completion_t completion, + rados_xattrs_iter_t *iter) +{ + tracepoint(librados, rados_aio_getxattrs_enter, io, oid, completion); + // create data object to be passed to async callback + AioGetxattrsData *cdata = new AioGetxattrsData(completion, iter); + if (!cdata) { + tracepoint(librados, rados_getxattrs_exit, -ENOMEM, NULL); + return -ENOMEM; + } + // create completion callback + librados::AioCompletionImpl *c = new librados::AioCompletionImpl; + c->set_complete_callback(cdata, rados_aio_getxattrs_complete); + // call async getxattrs of IoCtx + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t obj(oid); + int ret = ctx->aio_getxattrs(obj, c, cdata->it->attrset); + tracepoint(librados, rados_aio_getxattrs_exit, ret, cdata->it); + return ret; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_getxattrs); + +extern "C" int _rados_aio_setxattr(rados_ioctx_t io, const char *o, + rados_completion_t completion, + const char *name, const char *buf, size_t len) +{ + tracepoint(librados, rados_aio_setxattr_enter, io, o, completion, name, buf, len); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + bufferlist bl; + bl.append(buf, len); + int retval = ctx->aio_setxattr(oid, (librados::AioCompletionImpl*)completion, name, bl); + tracepoint(librados, rados_aio_setxattr_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_setxattr); + +extern "C" int _rados_aio_rmxattr(rados_ioctx_t io, const char *o, + rados_completion_t completion, + const char *name) +{ + tracepoint(librados, rados_aio_rmxattr_enter, io, o, completion, name); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + int retval = ctx->aio_rmxattr(oid, (librados::AioCompletionImpl*)completion, name); + tracepoint(librados, rados_aio_rmxattr_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_rmxattr); + +extern "C" int _rados_aio_stat(rados_ioctx_t io, const char *o, + rados_completion_t completion, + uint64_t *psize, time_t *pmtime) +{ + tracepoint(librados, rados_aio_stat_enter, io, o, completion); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + int retval = ctx->aio_stat(oid, (librados::AioCompletionImpl*)completion, + psize, pmtime); + tracepoint(librados, rados_aio_stat_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_stat); + +extern "C" int _rados_aio_cmpext(rados_ioctx_t io, const char *o, + rados_completion_t completion, const char *cmp_buf, + size_t cmp_len, uint64_t off) +{ + tracepoint(librados, rados_aio_cmpext_enter, io, o, completion, cmp_buf, + cmp_len, off); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + int retval = ctx->aio_cmpext(oid, (librados::AioCompletionImpl*)completion, + cmp_buf, cmp_len, off); + tracepoint(librados, rados_aio_cmpext_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_cmpext); + +extern "C" int _rados_aio_cancel(rados_ioctx_t io, rados_completion_t completion) +{ + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + return ctx->aio_cancel((librados::AioCompletionImpl*)completion); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_cancel); + +extern "C" int _rados_aio_exec(rados_ioctx_t io, const char *o, + rados_completion_t completion, + const char *cls, const char *method, + const char *inbuf, size_t in_len, + char *buf, size_t out_len) +{ + tracepoint(librados, rados_aio_exec_enter, io, o, completion); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + bufferlist inbl; + inbl.append(inbuf, in_len); + int retval = ctx->aio_exec(oid, (librados::AioCompletionImpl*)completion, + cls, method, inbl, buf, out_len); + tracepoint(librados, rados_aio_exec_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_exec); + +struct C_WatchCB : public librados::WatchCtx { + rados_watchcb_t wcb; + void *arg; + C_WatchCB(rados_watchcb_t _wcb, void *_arg) : wcb(_wcb), arg(_arg) {} + void notify(uint8_t opcode, uint64_t ver, bufferlist& bl) override { + wcb(opcode, ver, arg); + } +}; + +extern "C" int _rados_watch(rados_ioctx_t io, const char *o, uint64_t ver, + uint64_t *handle, + rados_watchcb_t watchcb, void *arg) +{ + tracepoint(librados, rados_watch_enter, io, o, ver, watchcb, arg); + uint64_t *cookie = handle; + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + C_WatchCB *wc = new C_WatchCB(watchcb, arg); + int retval = ctx->watch(oid, cookie, wc, NULL, true); + tracepoint(librados, rados_watch_exit, retval, *handle); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_watch); + +struct C_WatchCB2 : public librados::WatchCtx2 { + rados_watchcb2_t wcb; + rados_watcherrcb_t errcb; + void *arg; + C_WatchCB2(rados_watchcb2_t _wcb, + rados_watcherrcb_t _errcb, + void *_arg) : wcb(_wcb), errcb(_errcb), arg(_arg) {} + void handle_notify(uint64_t notify_id, + uint64_t cookie, + uint64_t notifier_gid, + bufferlist& bl) override { + wcb(arg, notify_id, cookie, notifier_gid, bl.c_str(), bl.length()); + } + void handle_error(uint64_t cookie, int err) override { + if (errcb) + errcb(arg, cookie, err); + } +}; + +extern "C" int _rados_watch3(rados_ioctx_t io, const char *o, uint64_t *handle, + rados_watchcb2_t watchcb, + rados_watcherrcb_t watcherrcb, + uint32_t timeout, + void *arg) +{ + tracepoint(librados, rados_watch3_enter, io, o, handle, watchcb, timeout, arg); + int ret; + if (!watchcb || !o || !handle) { + ret = -EINVAL; + } else { + uint64_t *cookie = handle; + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + C_WatchCB2 *wc = new C_WatchCB2(watchcb, watcherrcb, arg); + ret = ctx->watch(oid, cookie, NULL, wc, timeout, true); + } + tracepoint(librados, rados_watch3_exit, ret, handle ? *handle : 0); + return ret; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_watch3); + +extern "C" int _rados_watch2(rados_ioctx_t io, const char *o, uint64_t *handle, + rados_watchcb2_t watchcb, + rados_watcherrcb_t watcherrcb, + void *arg) { + return _rados_watch3(io, o, handle, watchcb, watcherrcb, 0, arg); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_watch2); + +extern "C" int _rados_aio_watch2(rados_ioctx_t io, const char *o, + rados_completion_t completion, + uint64_t *handle, + rados_watchcb2_t watchcb, + rados_watcherrcb_t watcherrcb, + uint32_t timeout, void *arg) +{ + tracepoint(librados, rados_aio_watch2_enter, io, o, completion, handle, watchcb, timeout, arg); + int ret; + if (!completion || !watchcb || !o || !handle) { + ret = -EINVAL; + } else { + uint64_t *cookie = handle; + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + librados::AioCompletionImpl *c = + reinterpret_cast<librados::AioCompletionImpl*>(completion); + C_WatchCB2 *wc = new C_WatchCB2(watchcb, watcherrcb, arg); + ret = ctx->aio_watch(oid, c, cookie, NULL, wc, timeout, true); + } + tracepoint(librados, rados_aio_watch2_exit, ret, handle ? *handle : 0); + return ret; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_watch2); + +extern "C" int _rados_aio_watch(rados_ioctx_t io, const char *o, + rados_completion_t completion, + uint64_t *handle, + rados_watchcb2_t watchcb, + rados_watcherrcb_t watcherrcb, void *arg) { + return _rados_aio_watch2(io, o, completion, handle, watchcb, watcherrcb, 0, arg); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_watch); + +extern "C" int _rados_unwatch(rados_ioctx_t io, const char *o, uint64_t handle) +{ + tracepoint(librados, rados_unwatch_enter, io, o, handle); + uint64_t cookie = handle; + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + int retval = ctx->unwatch(cookie); + tracepoint(librados, rados_unwatch_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_unwatch); + +extern "C" int _rados_unwatch2(rados_ioctx_t io, uint64_t handle) +{ + tracepoint(librados, rados_unwatch2_enter, io, handle); + uint64_t cookie = handle; + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + int retval = ctx->unwatch(cookie); + tracepoint(librados, rados_unwatch2_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_unwatch2); + +extern "C" int _rados_aio_unwatch(rados_ioctx_t io, uint64_t handle, + rados_completion_t completion) +{ + tracepoint(librados, rados_aio_unwatch_enter, io, handle, completion); + uint64_t cookie = handle; + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + librados::AioCompletionImpl *c = + reinterpret_cast<librados::AioCompletionImpl*>(completion); + int retval = ctx->aio_unwatch(cookie, c); + tracepoint(librados, rados_aio_unwatch_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_unwatch); + +extern "C" int _rados_watch_check(rados_ioctx_t io, uint64_t handle) +{ + tracepoint(librados, rados_watch_check_enter, io, handle); + uint64_t cookie = handle; + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + int retval = ctx->watch_check(cookie); + tracepoint(librados, rados_watch_check_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_watch_check); + +extern "C" int _rados_notify(rados_ioctx_t io, const char *o, + uint64_t ver, const char *buf, int buf_len) +{ + tracepoint(librados, rados_notify_enter, io, o, ver, buf, buf_len); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + bufferlist bl; + if (buf) { + bufferptr p = buffer::create(buf_len); + memcpy(p.c_str(), buf, buf_len); + bl.push_back(p); + } + int retval = ctx->notify(oid, bl, 0, NULL, NULL, NULL); + tracepoint(librados, rados_notify_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_notify); + +extern "C" int _rados_notify2(rados_ioctx_t io, const char *o, + const char *buf, int buf_len, + uint64_t timeout_ms, + char **reply_buffer, + size_t *reply_buffer_len) +{ + tracepoint(librados, rados_notify2_enter, io, o, buf, buf_len, timeout_ms); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + bufferlist bl; + if (buf) { + bufferptr p = buffer::create(buf_len); + memcpy(p.c_str(), buf, buf_len); + bl.push_back(p); + } + int ret = ctx->notify(oid, bl, timeout_ms, NULL, reply_buffer, reply_buffer_len); + tracepoint(librados, rados_notify2_exit, ret); + return ret; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_notify2); + +extern "C" int _rados_aio_notify(rados_ioctx_t io, const char *o, + rados_completion_t completion, + const char *buf, int buf_len, + uint64_t timeout_ms, char **reply_buffer, + size_t *reply_buffer_len) +{ + tracepoint(librados, rados_aio_notify_enter, io, o, completion, buf, buf_len, + timeout_ms); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + bufferlist bl; + if (buf) { + bl.push_back(buffer::copy(buf, buf_len)); + } + librados::AioCompletionImpl *c = + reinterpret_cast<librados::AioCompletionImpl*>(completion); + int ret = ctx->aio_notify(oid, c, bl, timeout_ms, NULL, reply_buffer, + reply_buffer_len); + tracepoint(librados, rados_aio_notify_exit, ret); + return ret; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_notify); + +extern "C" int _rados_notify_ack(rados_ioctx_t io, const char *o, + uint64_t notify_id, uint64_t handle, + const char *buf, int buf_len) +{ + tracepoint(librados, rados_notify_ack_enter, io, o, notify_id, handle, buf, buf_len); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + bufferlist bl; + if (buf) { + bufferptr p = buffer::create(buf_len); + memcpy(p.c_str(), buf, buf_len); + bl.push_back(p); + } + ctx->notify_ack(oid, notify_id, handle, bl); + tracepoint(librados, rados_notify_ack_exit, 0); + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_notify_ack); + +extern "C" int _rados_watch_flush(rados_t cluster) +{ + tracepoint(librados, rados_watch_flush_enter, cluster); + librados::RadosClient *client = (librados::RadosClient *)cluster; + int retval = client->watch_flush(); + tracepoint(librados, rados_watch_flush_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_watch_flush); + +extern "C" int _rados_aio_watch_flush(rados_t cluster, rados_completion_t completion) +{ + tracepoint(librados, rados_aio_watch_flush_enter, cluster, completion); + librados::RadosClient *client = (librados::RadosClient *)cluster; + librados::AioCompletionImpl *c = (librados::AioCompletionImpl*)completion; + int retval = client->async_watch_flush(c); + tracepoint(librados, rados_aio_watch_flush_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_watch_flush); + +extern "C" int _rados_set_alloc_hint(rados_ioctx_t io, const char *o, + uint64_t expected_object_size, + uint64_t expected_write_size) +{ + tracepoint(librados, rados_set_alloc_hint_enter, io, o, expected_object_size, expected_write_size); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + int retval = ctx->set_alloc_hint(oid, expected_object_size, + expected_write_size, 0); + tracepoint(librados, rados_set_alloc_hint_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_set_alloc_hint); + +extern "C" int _rados_set_alloc_hint2(rados_ioctx_t io, const char *o, + uint64_t expected_object_size, + uint64_t expected_write_size, + uint32_t flags) +{ + tracepoint(librados, rados_set_alloc_hint2_enter, io, o, expected_object_size, expected_write_size, flags); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + int retval = ctx->set_alloc_hint(oid, expected_object_size, + expected_write_size, flags); + tracepoint(librados, rados_set_alloc_hint2_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_set_alloc_hint2); + +extern "C" int _rados_lock_exclusive(rados_ioctx_t io, const char * o, + const char * name, const char * cookie, + const char * desc, + struct timeval * duration, uint8_t flags) +{ + tracepoint(librados, rados_lock_exclusive_enter, io, o, name, cookie, desc, duration, flags); + librados::IoCtx ctx; + librados::IoCtx::from_rados_ioctx_t(io, ctx); + + int retval = ctx.lock_exclusive(o, name, cookie, desc, duration, flags); + tracepoint(librados, rados_lock_exclusive_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_lock_exclusive); + +extern "C" int _rados_lock_shared(rados_ioctx_t io, const char * o, + const char * name, const char * cookie, + const char * tag, const char * desc, + struct timeval * duration, uint8_t flags) +{ + tracepoint(librados, rados_lock_shared_enter, io, o, name, cookie, tag, desc, duration, flags); + librados::IoCtx ctx; + librados::IoCtx::from_rados_ioctx_t(io, ctx); + + int retval = ctx.lock_shared(o, name, cookie, tag, desc, duration, flags); + tracepoint(librados, rados_lock_shared_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_lock_shared); + +extern "C" int _rados_unlock(rados_ioctx_t io, const char *o, const char *name, + const char *cookie) +{ + tracepoint(librados, rados_unlock_enter, io, o, name, cookie); + librados::IoCtx ctx; + librados::IoCtx::from_rados_ioctx_t(io, ctx); + + int retval = ctx.unlock(o, name, cookie); + tracepoint(librados, rados_unlock_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_unlock); + +extern "C" int _rados_aio_unlock(rados_ioctx_t io, const char *o, const char *name, + const char *cookie, rados_completion_t completion) +{ + tracepoint(librados, rados_aio_unlock_enter, io, o, name, cookie, completion); + librados::IoCtx ctx; + librados::IoCtx::from_rados_ioctx_t(io, ctx); + librados::AioCompletionImpl *comp = (librados::AioCompletionImpl*)completion; + librados::AioCompletion c(comp); + int retval = ctx.aio_unlock(o, name, cookie, &c); + tracepoint(librados, rados_aio_unlock_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_unlock); + +extern "C" ssize_t _rados_list_lockers(rados_ioctx_t io, const char *o, + const char *name, int *exclusive, + char *tag, size_t *tag_len, + char *clients, size_t *clients_len, + char *cookies, size_t *cookies_len, + char *addrs, size_t *addrs_len) +{ + tracepoint(librados, rados_list_lockers_enter, io, o, name, *tag_len, *clients_len, *cookies_len, *addrs_len); + librados::IoCtx ctx; + librados::IoCtx::from_rados_ioctx_t(io, ctx); + std::string name_str = name; + std::string oid = o; + std::string tag_str; + int tmp_exclusive; + std::list<librados::locker_t> lockers; + int r = ctx.list_lockers(oid, name_str, &tmp_exclusive, &tag_str, &lockers); + if (r < 0) { + tracepoint(librados, rados_list_lockers_exit, r, *exclusive, "", *tag_len, *clients_len, *cookies_len, *addrs_len); + return r; + } + + size_t clients_total = 0; + size_t cookies_total = 0; + size_t addrs_total = 0; + list<librados::locker_t>::const_iterator it; + for (it = lockers.begin(); it != lockers.end(); ++it) { + clients_total += it->client.length() + 1; + cookies_total += it->cookie.length() + 1; + addrs_total += it->address.length() + 1; + } + + bool too_short = ((clients_total > *clients_len) || + (cookies_total > *cookies_len) || + (addrs_total > *addrs_len) || + (tag_str.length() + 1 > *tag_len)); + *clients_len = clients_total; + *cookies_len = cookies_total; + *addrs_len = addrs_total; + *tag_len = tag_str.length() + 1; + if (too_short) { + tracepoint(librados, rados_list_lockers_exit, -ERANGE, *exclusive, "", *tag_len, *clients_len, *cookies_len, *addrs_len); + return -ERANGE; + } + + strcpy(tag, tag_str.c_str()); + char *clients_p = clients; + char *cookies_p = cookies; + char *addrs_p = addrs; + for (it = lockers.begin(); it != lockers.end(); ++it) { + strcpy(clients_p, it->client.c_str()); + strcpy(cookies_p, it->cookie.c_str()); + strcpy(addrs_p, it->address.c_str()); + tracepoint(librados, rados_list_lockers_locker, clients_p, cookies_p, addrs_p); + clients_p += it->client.length() + 1; + cookies_p += it->cookie.length() + 1; + addrs_p += it->address.length() + 1; + } + if (tmp_exclusive) + *exclusive = 1; + else + *exclusive = 0; + + int retval = lockers.size(); + tracepoint(librados, rados_list_lockers_exit, retval, *exclusive, tag, *tag_len, *clients_len, *cookies_len, *addrs_len); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_list_lockers); + +extern "C" int _rados_break_lock(rados_ioctx_t io, const char *o, + const char *name, const char *client, + const char *cookie) +{ + tracepoint(librados, rados_break_lock_enter, io, o, name, client, cookie); + librados::IoCtx ctx; + librados::IoCtx::from_rados_ioctx_t(io, ctx); + + int retval = ctx.break_lock(o, name, client, cookie); + tracepoint(librados, rados_break_lock_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_break_lock); + +extern "C" rados_write_op_t _rados_create_write_op() +{ + tracepoint(librados, rados_create_write_op_enter); + rados_write_op_t retval = new (std::nothrow)::ObjectOperation; + tracepoint(librados, rados_create_write_op_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_create_write_op); + +extern "C" void _rados_release_write_op(rados_write_op_t write_op) +{ + tracepoint(librados, rados_release_write_op_enter, write_op); + delete (::ObjectOperation*)write_op; + tracepoint(librados, rados_release_write_op_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_release_write_op); + +extern "C" void _rados_write_op_set_flags(rados_write_op_t write_op, int flags) +{ + tracepoint(librados, rados_write_op_set_flags_enter, write_op, flags); + ((::ObjectOperation *)write_op)->set_last_op_flags(get_op_flags(flags)); + tracepoint(librados, rados_write_op_set_flags_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_set_flags); + +extern "C" void _rados_write_op_assert_version(rados_write_op_t write_op, uint64_t ver) +{ + tracepoint(librados, rados_write_op_assert_version_enter, write_op, ver); + ((::ObjectOperation *)write_op)->assert_version(ver); + tracepoint(librados, rados_write_op_assert_version_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_assert_version); + +extern "C" void _rados_write_op_assert_exists(rados_write_op_t write_op) +{ + tracepoint(librados, rados_write_op_assert_exists_enter, write_op); + ((::ObjectOperation *)write_op)->stat(NULL, (ceph::real_time *)NULL, NULL); + tracepoint(librados, rados_write_op_assert_exists_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_assert_exists); + +extern "C" void _rados_write_op_cmpext(rados_write_op_t write_op, + const char *cmp_buf, + size_t cmp_len, + uint64_t off, + int *prval) +{ + tracepoint(librados, rados_write_op_cmpext_enter, write_op, cmp_buf, + cmp_len, off, prval); + ((::ObjectOperation *)write_op)->cmpext(off, cmp_len, cmp_buf, prval); + tracepoint(librados, rados_write_op_cmpext_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_cmpext); + +extern "C" void _rados_write_op_cmpxattr(rados_write_op_t write_op, + const char *name, + uint8_t comparison_operator, + const char *value, + size_t value_len) +{ + tracepoint(librados, rados_write_op_cmpxattr_enter, write_op, name, comparison_operator, value, value_len); + bufferlist bl; + bl.append(value, value_len); + ((::ObjectOperation *)write_op)->cmpxattr(name, + comparison_operator, + CEPH_OSD_CMPXATTR_MODE_STRING, + bl); + tracepoint(librados, rados_write_op_cmpxattr_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_cmpxattr); + +static void rados_c_omap_cmp(ObjectOperation *op, + const char *key, + uint8_t comparison_operator, + const char *val, + size_t key_len, + size_t val_len, + int *prval) +{ + bufferlist bl; + bl.append(val, val_len); + std::map<std::string, pair<bufferlist, int> > assertions; + string lkey = string(key, key_len); + + assertions[lkey] = std::make_pair(bl, comparison_operator); + op->omap_cmp(assertions, prval); +} + +extern "C" void _rados_write_op_omap_cmp(rados_write_op_t write_op, + const char *key, + uint8_t comparison_operator, + const char *val, + size_t val_len, + int *prval) +{ + tracepoint(librados, rados_write_op_omap_cmp_enter, write_op, key, comparison_operator, val, val_len, prval); + rados_c_omap_cmp((::ObjectOperation *)write_op, key, comparison_operator, + val, strlen(key), val_len, prval); + tracepoint(librados, rados_write_op_omap_cmp_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_omap_cmp); + +extern "C" void _rados_write_op_omap_cmp2(rados_write_op_t write_op, + const char *key, + uint8_t comparison_operator, + const char *val, + size_t key_len, + size_t val_len, + int *prval) +{ + tracepoint(librados, rados_write_op_omap_cmp_enter, write_op, key, comparison_operator, val, val_len, prval); + rados_c_omap_cmp((::ObjectOperation *)write_op, key, comparison_operator, + val, key_len, val_len, prval); + tracepoint(librados, rados_write_op_omap_cmp_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_omap_cmp2); + +extern "C" void _rados_write_op_setxattr(rados_write_op_t write_op, + const char *name, + const char *value, + size_t value_len) +{ + tracepoint(librados, rados_write_op_setxattr_enter, write_op, name, value, value_len); + bufferlist bl; + bl.append(value, value_len); + ((::ObjectOperation *)write_op)->setxattr(name, bl); + tracepoint(librados, rados_write_op_setxattr_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_setxattr); + +extern "C" void _rados_write_op_rmxattr(rados_write_op_t write_op, + const char *name) +{ + tracepoint(librados, rados_write_op_rmxattr_enter, write_op, name); + ((::ObjectOperation *)write_op)->rmxattr(name); + tracepoint(librados, rados_write_op_rmxattr_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_rmxattr); + +extern "C" void _rados_write_op_create(rados_write_op_t write_op, + int exclusive, + const char* category) // unused +{ + tracepoint(librados, rados_write_op_create_enter, write_op, exclusive); + ::ObjectOperation *oo = (::ObjectOperation *) write_op; + oo->create(!!exclusive); + tracepoint(librados, rados_write_op_create_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_create); + +extern "C" void _rados_write_op_write(rados_write_op_t write_op, + const char *buffer, + size_t len, + uint64_t offset) +{ + tracepoint(librados, rados_write_op_write_enter, write_op, buffer, len, offset); + bufferlist bl; + bl.append(buffer,len); + ((::ObjectOperation *)write_op)->write(offset, bl); + tracepoint(librados, rados_write_op_write_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_write); + +extern "C" void _rados_write_op_write_full(rados_write_op_t write_op, + const char *buffer, + size_t len) +{ + tracepoint(librados, rados_write_op_write_full_enter, write_op, buffer, len); + bufferlist bl; + bl.append(buffer,len); + ((::ObjectOperation *)write_op)->write_full(bl); + tracepoint(librados, rados_write_op_write_full_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_write_full); + +extern "C" void _rados_write_op_writesame(rados_write_op_t write_op, + const char *buffer, + size_t data_len, + size_t write_len, + uint64_t offset) +{ + tracepoint(librados, rados_write_op_writesame_enter, write_op, buffer, data_len, write_len, offset); + bufferlist bl; + bl.append(buffer, data_len); + ((::ObjectOperation *)write_op)->writesame(offset, write_len, bl); + tracepoint(librados, rados_write_op_writesame_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_writesame); + +extern "C" void _rados_write_op_append(rados_write_op_t write_op, + const char *buffer, + size_t len) +{ + tracepoint(librados, rados_write_op_append_enter, write_op, buffer, len); + bufferlist bl; + bl.append(buffer,len); + ((::ObjectOperation *)write_op)->append(bl); + tracepoint(librados, rados_write_op_append_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_append); + +extern "C" void _rados_write_op_remove(rados_write_op_t write_op) +{ + tracepoint(librados, rados_write_op_remove_enter, write_op); + ((::ObjectOperation *)write_op)->remove(); + tracepoint(librados, rados_write_op_remove_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_remove); + +extern "C" void _rados_write_op_truncate(rados_write_op_t write_op, + uint64_t offset) +{ + tracepoint(librados, rados_write_op_truncate_enter, write_op, offset); + ((::ObjectOperation *)write_op)->truncate(offset); + tracepoint(librados, rados_write_op_truncate_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_truncate); + +extern "C" void _rados_write_op_zero(rados_write_op_t write_op, + uint64_t offset, + uint64_t len) +{ + tracepoint(librados, rados_write_op_zero_enter, write_op, offset, len); + ((::ObjectOperation *)write_op)->zero(offset, len); + tracepoint(librados, rados_write_op_zero_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_zero); + +extern "C" void _rados_write_op_exec(rados_write_op_t write_op, + const char *cls, + const char *method, + const char *in_buf, + size_t in_len, + int *prval) +{ + tracepoint(librados, rados_write_op_exec_enter, write_op, cls, method, in_buf, in_len, prval); + bufferlist inbl; + inbl.append(in_buf, in_len); + ((::ObjectOperation *)write_op)->call(cls, method, inbl, NULL, NULL, prval); + tracepoint(librados, rados_write_op_exec_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_exec); + +extern "C" void _rados_write_op_omap_set(rados_write_op_t write_op, + char const* const* keys, + char const* const* vals, + const size_t *lens, + size_t num) +{ + tracepoint(librados, rados_write_op_omap_set_enter, write_op, num); + std::map<std::string, bufferlist> entries; + for (size_t i = 0; i < num; ++i) { + tracepoint(librados, rados_write_op_omap_set_entry, keys[i], vals[i], lens[i]); + bufferlist bl(lens[i]); + bl.append(vals[i], lens[i]); + entries[keys[i]] = bl; + } + ((::ObjectOperation *)write_op)->omap_set(entries); + tracepoint(librados, rados_write_op_omap_set_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_omap_set); + +extern "C" void _rados_write_op_omap_set2(rados_write_op_t write_op, + char const* const* keys, + char const* const* vals, + const size_t *key_lens, + const size_t *val_lens, + size_t num) +{ + tracepoint(librados, rados_write_op_omap_set_enter, write_op, num); + std::map<std::string, bufferlist> entries; + for (size_t i = 0; i < num; ++i) { + bufferlist bl(val_lens[i]); + bl.append(vals[i], val_lens[i]); + string key(keys[i], key_lens[i]); + entries[key] = bl; + } + ((::ObjectOperation *)write_op)->omap_set(entries); + tracepoint(librados, rados_write_op_omap_set_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_omap_set2); + +extern "C" void _rados_write_op_omap_rm_keys(rados_write_op_t write_op, + char const* const* keys, + size_t keys_len) +{ + tracepoint(librados, rados_write_op_omap_rm_keys_enter, write_op, keys_len); + for(size_t i = 0; i < keys_len; i++) { + tracepoint(librados, rados_write_op_omap_rm_keys_entry, keys[i]); + } + std::set<std::string> to_remove(keys, keys + keys_len); + ((::ObjectOperation *)write_op)->omap_rm_keys(to_remove); + tracepoint(librados, rados_write_op_omap_rm_keys_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_omap_rm_keys); + +extern "C" void _rados_write_op_omap_rm_keys2(rados_write_op_t write_op, + char const* const* keys, + const size_t* key_lens, + size_t keys_len) +{ + tracepoint(librados, rados_write_op_omap_rm_keys_enter, write_op, keys_len); + std::set<std::string> to_remove; + for(size_t i = 0; i < keys_len; i++) { + to_remove.emplace(keys[i], key_lens[i]); + } + ((::ObjectOperation *)write_op)->omap_rm_keys(to_remove); + tracepoint(librados, rados_write_op_omap_rm_keys_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_omap_rm_keys2); + +extern "C" void _rados_write_op_omap_clear(rados_write_op_t write_op) +{ + tracepoint(librados, rados_write_op_omap_clear_enter, write_op); + ((::ObjectOperation *)write_op)->omap_clear(); + tracepoint(librados, rados_write_op_omap_clear_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_omap_clear); + +extern "C" void _rados_write_op_set_alloc_hint(rados_write_op_t write_op, + uint64_t expected_object_size, + uint64_t expected_write_size) +{ + tracepoint(librados, rados_write_op_set_alloc_hint_enter, write_op, expected_object_size, expected_write_size); + ((::ObjectOperation *)write_op)->set_alloc_hint(expected_object_size, + expected_write_size, 0); + tracepoint(librados, rados_write_op_set_alloc_hint_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_set_alloc_hint); + +extern "C" void _rados_write_op_set_alloc_hint2(rados_write_op_t write_op, + uint64_t expected_object_size, + uint64_t expected_write_size, + uint32_t flags) +{ + tracepoint(librados, rados_write_op_set_alloc_hint2_enter, write_op, expected_object_size, expected_write_size, flags); + ((::ObjectOperation *)write_op)->set_alloc_hint(expected_object_size, + expected_write_size, + flags); + tracepoint(librados, rados_write_op_set_alloc_hint2_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_set_alloc_hint2); + +extern "C" int _rados_write_op_operate(rados_write_op_t write_op, + rados_ioctx_t io, + const char *oid, + time_t *mtime, + int flags) +{ + tracepoint(librados, rados_write_op_operate_enter, write_op, io, oid, mtime, flags); + object_t obj(oid); + ::ObjectOperation *oo = (::ObjectOperation *) write_op; + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + + ceph::real_time *prt = NULL; + ceph::real_time rt; + + if (mtime) { + rt = ceph::real_clock::from_time_t(*mtime); + prt = &rt; + } + + int retval = ctx->operate(obj, oo, prt, translate_flags(flags)); + tracepoint(librados, rados_write_op_operate_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_operate); + +extern "C" int _rados_write_op_operate2(rados_write_op_t write_op, + rados_ioctx_t io, + const char *oid, + struct timespec *ts, + int flags) +{ + tracepoint(librados, rados_write_op_operate2_enter, write_op, io, oid, ts, flags); + object_t obj(oid); + ::ObjectOperation *oo = (::ObjectOperation *) write_op; + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + + ceph::real_time *prt = NULL; + ceph::real_time rt; + + if (ts) { + rt = ceph::real_clock::from_timespec(*ts); + prt = &rt; + } + + int retval = ctx->operate(obj, oo, prt, translate_flags(flags)); + tracepoint(librados, rados_write_op_operate_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_write_op_operate2); + +extern "C" int _rados_aio_write_op_operate(rados_write_op_t write_op, + rados_ioctx_t io, + rados_completion_t completion, + const char *oid, + time_t *mtime, + int flags) +{ + tracepoint(librados, rados_aio_write_op_operate_enter, write_op, io, completion, oid, mtime, flags); + object_t obj(oid); + ::ObjectOperation *oo = (::ObjectOperation *) write_op; + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + librados::AioCompletionImpl *c = (librados::AioCompletionImpl*)completion; + int retval = ctx->aio_operate(obj, oo, c, ctx->snapc, translate_flags(flags)); + tracepoint(librados, rados_aio_write_op_operate_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_write_op_operate); + +extern "C" rados_read_op_t _rados_create_read_op() +{ + tracepoint(librados, rados_create_read_op_enter); + rados_read_op_t retval = new (std::nothrow)::ObjectOperation; + tracepoint(librados, rados_create_read_op_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_create_read_op); + +extern "C" void _rados_release_read_op(rados_read_op_t read_op) +{ + tracepoint(librados, rados_release_read_op_enter, read_op); + delete (::ObjectOperation *)read_op; + tracepoint(librados, rados_release_read_op_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_release_read_op); + +extern "C" void _rados_read_op_set_flags(rados_read_op_t read_op, int flags) +{ + tracepoint(librados, rados_read_op_set_flags_enter, read_op, flags); + ((::ObjectOperation *)read_op)->set_last_op_flags(get_op_flags(flags)); + tracepoint(librados, rados_read_op_set_flags_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_read_op_set_flags); + +extern "C" void _rados_read_op_assert_version(rados_read_op_t read_op, uint64_t ver) +{ + tracepoint(librados, rados_read_op_assert_version_enter, read_op, ver); + ((::ObjectOperation *)read_op)->assert_version(ver); + tracepoint(librados, rados_read_op_assert_version_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_read_op_assert_version); + +extern "C" void _rados_read_op_assert_exists(rados_read_op_t read_op) +{ + tracepoint(librados, rados_read_op_assert_exists_enter, read_op); + ((::ObjectOperation *)read_op)->stat(NULL, (ceph::real_time *)NULL, NULL); + tracepoint(librados, rados_read_op_assert_exists_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_read_op_assert_exists); + +extern "C" void _rados_read_op_cmpext(rados_read_op_t read_op, + const char *cmp_buf, + size_t cmp_len, + uint64_t off, + int *prval) +{ + tracepoint(librados, rados_read_op_cmpext_enter, read_op, cmp_buf, + cmp_len, off, prval); + ((::ObjectOperation *)read_op)->cmpext(off, cmp_len, cmp_buf, prval); + tracepoint(librados, rados_read_op_cmpext_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_read_op_cmpext); + +extern "C" void _rados_read_op_cmpxattr(rados_read_op_t read_op, + const char *name, + uint8_t comparison_operator, + const char *value, + size_t value_len) +{ + tracepoint(librados, rados_read_op_cmpxattr_enter, read_op, name, comparison_operator, value, value_len); + bufferlist bl; + bl.append(value, value_len); + ((::ObjectOperation *)read_op)->cmpxattr(name, + comparison_operator, + CEPH_OSD_CMPXATTR_MODE_STRING, + bl); + tracepoint(librados, rados_read_op_cmpxattr_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_read_op_cmpxattr); + +extern "C" void _rados_read_op_omap_cmp(rados_read_op_t read_op, + const char *key, + uint8_t comparison_operator, + const char *val, + size_t val_len, + int *prval) +{ + tracepoint(librados, rados_read_op_omap_cmp_enter, read_op, key, comparison_operator, val, val_len, prval); + rados_c_omap_cmp((::ObjectOperation *)read_op, key, comparison_operator, + val, strlen(key), val_len, prval); + tracepoint(librados, rados_read_op_omap_cmp_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_read_op_omap_cmp); + +extern "C" void _rados_read_op_omap_cmp2(rados_read_op_t read_op, + const char *key, + uint8_t comparison_operator, + const char *val, + size_t key_len, + size_t val_len, + int *prval) +{ + tracepoint(librados, rados_read_op_omap_cmp_enter, read_op, key, comparison_operator, val, val_len, prval); + rados_c_omap_cmp((::ObjectOperation *)read_op, key, comparison_operator, + val, key_len, val_len, prval); + tracepoint(librados, rados_read_op_omap_cmp_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_read_op_omap_cmp2); + +extern "C" void _rados_read_op_stat(rados_read_op_t read_op, + uint64_t *psize, + time_t *pmtime, + int *prval) +{ + tracepoint(librados, rados_read_op_stat_enter, read_op, psize, pmtime, prval); + ((::ObjectOperation *)read_op)->stat(psize, pmtime, prval); + tracepoint(librados, rados_read_op_stat_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_read_op_stat); + +class C_bl_to_buf : public Context { + char *out_buf; + size_t out_len; + size_t *bytes_read; + int *prval; +public: + bufferlist out_bl; + C_bl_to_buf(char *out_buf, + size_t out_len, + size_t *bytes_read, + int *prval) : out_buf(out_buf), out_len(out_len), + bytes_read(bytes_read), prval(prval) {} + void finish(int r) override { + if (out_bl.length() > out_len) { + if (prval) + *prval = -ERANGE; + if (bytes_read) + *bytes_read = 0; + return; + } + if (bytes_read) + *bytes_read = out_bl.length(); + if (out_buf && !out_bl.is_provided_buffer(out_buf)) + out_bl.copy(0, out_bl.length(), out_buf); + } +}; + +extern "C" void _rados_read_op_read(rados_read_op_t read_op, + uint64_t offset, + size_t len, + char *buf, + size_t *bytes_read, + int *prval) +{ + tracepoint(librados, rados_read_op_read_enter, read_op, offset, len, buf, bytes_read, prval); + C_bl_to_buf *ctx = new C_bl_to_buf(buf, len, bytes_read, prval); + ctx->out_bl.push_back(buffer::create_static(len, buf)); + ((::ObjectOperation *)read_op)->read(offset, len, &ctx->out_bl, prval, ctx); + tracepoint(librados, rados_read_op_read_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_read_op_read); + +extern "C" void _rados_read_op_checksum(rados_read_op_t read_op, + rados_checksum_type_t type, + const char *init_value, + size_t init_value_len, + uint64_t offset, size_t len, + size_t chunk_size, char *pchecksum, + size_t checksum_len, int *prval) +{ + tracepoint(librados, rados_read_op_checksum_enter, read_op, type, init_value, + init_value_len, offset, len, chunk_size); + bufferlist init_value_bl; + init_value_bl.append(init_value, init_value_len); + + C_bl_to_buf *ctx = nullptr; + if (pchecksum != nullptr) { + ctx = new C_bl_to_buf(pchecksum, checksum_len, nullptr, prval); + } + ((::ObjectOperation *)read_op)->checksum(get_checksum_op_type(type), + init_value_bl, offset, len, + chunk_size, + (ctx ? &ctx->out_bl : nullptr), + prval, ctx); + tracepoint(librados, rados_read_op_checksum_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_read_op_checksum); + +class C_out_buffer : public Context { + char **out_buf; + size_t *out_len; +public: + bufferlist out_bl; + C_out_buffer(char **out_buf, size_t *out_len) : out_buf(out_buf), + out_len(out_len) {} + void finish(int r) override { + // ignore r since we don't know the meaning of return values + // from custom class methods + do_out_buffer(out_bl, out_buf, out_len); + } +}; + +extern "C" void _rados_read_op_exec(rados_read_op_t read_op, + const char *cls, + const char *method, + const char *in_buf, + size_t in_len, + char **out_buf, + size_t *out_len, + int *prval) +{ + tracepoint(librados, rados_read_op_exec_enter, read_op, cls, method, in_buf, in_len, out_buf, out_len, prval); + bufferlist inbl; + inbl.append(in_buf, in_len); + C_out_buffer *ctx = new C_out_buffer(out_buf, out_len); + ((::ObjectOperation *)read_op)->call(cls, method, inbl, &ctx->out_bl, ctx, + prval); + tracepoint(librados, rados_read_op_exec_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_read_op_exec); + +extern "C" void _rados_read_op_exec_user_buf(rados_read_op_t read_op, + const char *cls, + const char *method, + const char *in_buf, + size_t in_len, + char *out_buf, + size_t out_len, + size_t *used_len, + int *prval) +{ + tracepoint(librados, rados_read_op_exec_user_buf_enter, read_op, cls, method, in_buf, in_len, out_buf, out_len, used_len, prval); + C_bl_to_buf *ctx = new C_bl_to_buf(out_buf, out_len, used_len, prval); + bufferlist inbl; + inbl.append(in_buf, in_len); + ((::ObjectOperation *)read_op)->call(cls, method, inbl, &ctx->out_bl, ctx, + prval); + tracepoint(librados, rados_read_op_exec_user_buf_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_read_op_exec_user_buf); + +struct RadosOmapIter { + std::map<std::string, bufferlist> values; + std::map<std::string, bufferlist>::iterator i; +}; + +class C_OmapIter : public Context { + RadosOmapIter *iter; +public: + explicit C_OmapIter(RadosOmapIter *iter) : iter(iter) {} + void finish(int r) override { + iter->i = iter->values.begin(); + } +}; + +class C_XattrsIter : public Context { + librados::RadosXattrsIter *iter; +public: + explicit C_XattrsIter(librados::RadosXattrsIter *iter) : iter(iter) {} + void finish(int r) override { + iter->i = iter->attrset.begin(); + } +}; + +extern "C" void _rados_read_op_getxattrs(rados_read_op_t read_op, + rados_xattrs_iter_t *iter, + int *prval) +{ + tracepoint(librados, rados_read_op_getxattrs_enter, read_op, prval); + librados::RadosXattrsIter *xattrs_iter = new librados::RadosXattrsIter; + ((::ObjectOperation *)read_op)->getxattrs(&xattrs_iter->attrset, prval); + ((::ObjectOperation *)read_op)->add_handler(new C_XattrsIter(xattrs_iter)); + *iter = xattrs_iter; + tracepoint(librados, rados_read_op_getxattrs_exit, *iter); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_read_op_getxattrs); + +extern "C" void _rados_read_op_omap_get_vals(rados_read_op_t read_op, + const char *start_after, + const char *filter_prefix, + uint64_t max_return, + rados_omap_iter_t *iter, + int *prval) +{ + tracepoint(librados, rados_read_op_omap_get_vals_enter, read_op, start_after, filter_prefix, max_return, prval); + RadosOmapIter *omap_iter = new RadosOmapIter; + const char *start = start_after ? start_after : ""; + const char *filter = filter_prefix ? filter_prefix : ""; + ((::ObjectOperation *)read_op)->omap_get_vals( + start, + filter, + max_return, + &omap_iter->values, + nullptr, + prval); + ((::ObjectOperation *)read_op)->add_handler(new C_OmapIter(omap_iter)); + *iter = omap_iter; + tracepoint(librados, rados_read_op_omap_get_vals_exit, *iter); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_read_op_omap_get_vals); + +extern "C" void _rados_read_op_omap_get_vals2(rados_read_op_t read_op, + const char *start_after, + const char *filter_prefix, + uint64_t max_return, + rados_omap_iter_t *iter, + unsigned char *pmore, + int *prval) +{ + tracepoint(librados, rados_read_op_omap_get_vals_enter, read_op, start_after, filter_prefix, max_return, prval); + RadosOmapIter *omap_iter = new RadosOmapIter; + const char *start = start_after ? start_after : ""; + const char *filter = filter_prefix ? filter_prefix : ""; + ((::ObjectOperation *)read_op)->omap_get_vals( + start, + filter, + max_return, + &omap_iter->values, + (bool*)pmore, + prval); + ((::ObjectOperation *)read_op)->add_handler(new C_OmapIter(omap_iter)); + *iter = omap_iter; + tracepoint(librados, rados_read_op_omap_get_vals_exit, *iter); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_read_op_omap_get_vals2); + +struct C_OmapKeysIter : public Context { + RadosOmapIter *iter; + std::set<std::string> keys; + explicit C_OmapKeysIter(RadosOmapIter *iter) : iter(iter) {} + void finish(int r) override { + // map each key to an empty bl + for (std::set<std::string>::const_iterator i = keys.begin(); + i != keys.end(); ++i) { + iter->values[*i]; + } + iter->i = iter->values.begin(); + } +}; + +extern "C" void _rados_read_op_omap_get_keys(rados_read_op_t read_op, + const char *start_after, + uint64_t max_return, + rados_omap_iter_t *iter, + int *prval) +{ + tracepoint(librados, rados_read_op_omap_get_keys_enter, read_op, start_after, max_return, prval); + RadosOmapIter *omap_iter = new RadosOmapIter; + C_OmapKeysIter *ctx = new C_OmapKeysIter(omap_iter); + ((::ObjectOperation *)read_op)->omap_get_keys( + start_after ? start_after : "", + max_return, &ctx->keys, nullptr, prval); + ((::ObjectOperation *)read_op)->add_handler(ctx); + *iter = omap_iter; + tracepoint(librados, rados_read_op_omap_get_keys_exit, *iter); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_read_op_omap_get_keys); + +extern "C" void _rados_read_op_omap_get_keys2(rados_read_op_t read_op, + const char *start_after, + uint64_t max_return, + rados_omap_iter_t *iter, + unsigned char *pmore, + int *prval) +{ + tracepoint(librados, rados_read_op_omap_get_keys_enter, read_op, start_after, max_return, prval); + RadosOmapIter *omap_iter = new RadosOmapIter; + C_OmapKeysIter *ctx = new C_OmapKeysIter(omap_iter); + ((::ObjectOperation *)read_op)->omap_get_keys( + start_after ? start_after : "", + max_return, &ctx->keys, + (bool*)pmore, prval); + ((::ObjectOperation *)read_op)->add_handler(ctx); + *iter = omap_iter; + tracepoint(librados, rados_read_op_omap_get_keys_exit, *iter); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_read_op_omap_get_keys2); + +static void internal_rados_read_op_omap_get_vals_by_keys(rados_read_op_t read_op, + set<string>& to_get, + rados_omap_iter_t *iter, + int *prval) +{ + RadosOmapIter *omap_iter = new RadosOmapIter; + ((::ObjectOperation *)read_op)->omap_get_vals_by_keys(to_get, + &omap_iter->values, + prval); + ((::ObjectOperation *)read_op)->add_handler(new C_OmapIter(omap_iter)); + *iter = omap_iter; +} + +extern "C" void _rados_read_op_omap_get_vals_by_keys(rados_read_op_t read_op, + char const* const* keys, + size_t keys_len, + rados_omap_iter_t *iter, + int *prval) +{ + tracepoint(librados, rados_read_op_omap_get_vals_by_keys_enter, read_op, keys, keys_len, iter, prval); + std::set<std::string> to_get(keys, keys + keys_len); + internal_rados_read_op_omap_get_vals_by_keys(read_op, to_get, iter, prval); + tracepoint(librados, rados_read_op_omap_get_vals_by_keys_exit, *iter); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_read_op_omap_get_vals_by_keys); + +extern "C" void _rados_read_op_omap_get_vals_by_keys2(rados_read_op_t read_op, + char const* const* keys, + size_t num_keys, + const size_t* key_lens, + rados_omap_iter_t *iter, + int *prval) +{ + tracepoint(librados, rados_read_op_omap_get_vals_by_keys_enter, read_op, keys, num_keys, iter, prval); + std::set<std::string> to_get; + for (size_t i = 0; i < num_keys; i++) { + to_get.emplace(keys[i], key_lens[i]); + } + internal_rados_read_op_omap_get_vals_by_keys(read_op, to_get, iter, prval); + tracepoint(librados, rados_read_op_omap_get_vals_by_keys_exit, *iter); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_read_op_omap_get_vals_by_keys2); + +extern "C" int _rados_omap_get_next2(rados_omap_iter_t iter, + char **key, + char **val, + size_t *key_len, + size_t *val_len) +{ + tracepoint(librados, rados_omap_get_next_enter, iter); + RadosOmapIter *it = static_cast<RadosOmapIter *>(iter); + if (it->i == it->values.end()) { + if (key) + *key = NULL; + if (val) + *val = NULL; + if (key_len) + *key_len = 0; + if (val_len) + *val_len = 0; + tracepoint(librados, rados_omap_get_next_exit, 0, key, val, val_len); + return 0; + } + if (key) + *key = (char*)it->i->first.c_str(); + if (val) + *val = it->i->second.c_str(); + if (key_len) + *key_len = it->i->first.length(); + if (val_len) + *val_len = it->i->second.length(); + ++it->i; + tracepoint(librados, rados_omap_get_next_exit, 0, key, val, val_len); + return 0; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_omap_get_next2); + +extern "C" int _rados_omap_get_next(rados_omap_iter_t iter, + char **key, + char **val, + size_t *len) +{ + return _rados_omap_get_next2(iter, key, val, nullptr, len); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_omap_get_next); + +extern "C" unsigned int _rados_omap_iter_size(rados_omap_iter_t iter) +{ + RadosOmapIter *it = static_cast<RadosOmapIter *>(iter); + return it->values.size(); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_omap_iter_size); + +extern "C" void _rados_omap_get_end(rados_omap_iter_t iter) +{ + tracepoint(librados, rados_omap_get_end_enter, iter); + RadosOmapIter *it = static_cast<RadosOmapIter *>(iter); + delete it; + tracepoint(librados, rados_omap_get_end_exit); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_omap_get_end); + +extern "C" int _rados_read_op_operate(rados_read_op_t read_op, + rados_ioctx_t io, + const char *oid, + int flags) +{ + tracepoint(librados, rados_read_op_operate_enter, read_op, io, oid, flags); + object_t obj(oid); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + int retval = ctx->operate_read(obj, (::ObjectOperation *)read_op, NULL, + translate_flags(flags)); + tracepoint(librados, rados_read_op_operate_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_read_op_operate); + +extern "C" int _rados_aio_read_op_operate(rados_read_op_t read_op, + rados_ioctx_t io, + rados_completion_t completion, + const char *oid, + int flags) +{ + tracepoint(librados, rados_aio_read_op_operate_enter, read_op, io, completion, oid, flags); + object_t obj(oid); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + librados::AioCompletionImpl *c = (librados::AioCompletionImpl*)completion; + int retval = ctx->aio_operate_read(obj, (::ObjectOperation *)read_op, + c, translate_flags(flags), NULL); + tracepoint(librados, rados_aio_read_op_operate_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_aio_read_op_operate); + +extern "C" int _rados_cache_pin(rados_ioctx_t io, const char *o) +{ + tracepoint(librados, rados_cache_pin_enter, io, o); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + int retval = ctx->cache_pin(oid); + tracepoint(librados, rados_cache_pin_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_cache_pin); + +extern "C" int _rados_cache_unpin(rados_ioctx_t io, const char *o) +{ + tracepoint(librados, rados_cache_unpin_enter, io, o); + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + object_t oid(o); + int retval = ctx->cache_unpin(oid); + tracepoint(librados, rados_cache_unpin_exit, retval); + return retval; +} +LIBRADOS_C_API_BASE_DEFAULT(rados_cache_unpin); + +extern "C" void _rados_object_list_slice( + rados_ioctx_t io, + const rados_object_list_cursor start, + const rados_object_list_cursor finish, + const size_t n, + const size_t m, + rados_object_list_cursor *split_start, + rados_object_list_cursor *split_finish) +{ + librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; + + ceph_assert(split_start); + ceph_assert(split_finish); + hobject_t *split_start_hobj = (hobject_t*)(*split_start); + hobject_t *split_finish_hobj = (hobject_t*)(*split_finish); + ceph_assert(split_start_hobj); + ceph_assert(split_finish_hobj); + hobject_t *start_hobj = (hobject_t*)(start); + hobject_t *finish_hobj = (hobject_t*)(finish); + + ctx->object_list_slice( + *start_hobj, + *finish_hobj, + n, + m, + split_start_hobj, + split_finish_hobj); +} +LIBRADOS_C_API_BASE_DEFAULT(rados_object_list_slice); |