From: Adam Crume Date: Wed, 25 Jun 2014 20:59:08 +0000 (-0700) Subject: lttng: Trace librados C API X-Git-Tag: v0.86~231^2~70 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=16cd0744f54bb85a0bc2deaf4ff63adae614582c;p=ceph.git lttng: Trace librados C API Signed-off-by: Adam Crume --- diff --git a/src/librados/librados.cc b/src/librados/librados.cc index 60665dd024c9..4601684795db 100644 --- a/src/librados/librados.cc +++ b/src/librados/librados.cc @@ -12,6 +12,7 @@ * */ +#include "tracing/librados.h" #include #include "common/config.h" @@ -1827,11 +1828,14 @@ int rados_create_common(rados_t *pcluster, extern "C" int rados_create(rados_t *pcluster, const char * const id) { + tracepoint(librados, rados_create_enter, id); CephInitParameters iparams(CEPH_ENTITY_TYPE_CLIENT); if (id) { iparams.name.set(CEPH_ENTITY_TYPE_CLIENT, id); } - return rados_create_common(pcluster, "ceph", &iparams); + int retval = rados_create_common(pcluster, "ceph", &iparams); + tracepoint(librados, rados_create_exit, retval, *pcluster); + return retval; } // as above, but @@ -1843,12 +1847,17 @@ extern "C" int rados_create(rados_t *pcluster, const char * const id) extern "C" int rados_create2(rados_t *pcluster, const char *const clustername, const char * const name, uint64_t flags) { + tracepoint(librados, rados_create2_enter, clustername, name, flags); // client is assumed, but from_str will override CephInitParameters iparams(CEPH_ENTITY_TYPE_CLIENT); - if (!name || !iparams.name.from_str(name)) + if (!name || !iparams.name.from_str(name)) { + tracepoint(librados, rados_create2_exit, -EINVAL, *pcluster); return -EINVAL; + } - return rados_create_common(pcluster, clustername, &iparams); + int retval = rados_create_common(pcluster, clustername, &iparams); + tracepoint(librados, rados_create2_exit, retval, *pcluster); + return retval; } /* This function is intended for use by Ceph daemons. These daemons have @@ -1857,75 +1866,105 @@ extern "C" int rados_create2(rados_t *pcluster, const char *const clustername, */ extern "C" int rados_create_with_context(rados_t *pcluster, rados_config_t cct_) { + tracepoint(librados, rados_create_with_context_enter, cct_); CephContext *cct = (CephContext *)cct_; librados::RadosClient *radosp = new librados::RadosClient(cct); *pcluster = (void *)radosp; - return 0; + int retval = 0; + tracepoint(librados, rados_create_with_context_exit, retval, *pcluster); + return retval; } extern "C" rados_config_t rados_cct(rados_t cluster) { + tracepoint(librados, rados_cct_enter, cluster); librados::RadosClient *client = (librados::RadosClient *)cluster; - return (rados_config_t)client->cct; + rados_config_t retval = (rados_config_t)client->cct; + tracepoint(librados, rados_cct_exit, retval); + return retval; } extern "C" int rados_connect(rados_t cluster) { + tracepoint(librados, rados_connect_enter, cluster); librados::RadosClient *client = (librados::RadosClient *)cluster; - return client->connect(); + int retval = client->connect(); + tracepoint(librados, rados_connect_exit, retval); + return retval; } 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); } 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; - return client->get_instance_id(); + uint64_t retval = client->get_instance_id(); + tracepoint(librados, rados_get_instance_id_exit, retval); + return retval; } 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); } // -- 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; md_config_t *conf = client->cct->_conf; std::deque parse_errors; int ret = conf->parse_config_files(path_list, &parse_errors, NULL, 0); - if (ret) + if (ret) { + tracepoint(librados, rados_conf_read_file_exit, ret); return ret; + } conf->parse_env(); // environment variables override conf->apply_changes(NULL); complain_about_parse_errors(client->cct, &parse_errors); - return 0; + int retval = 0; + tracepoint(librados, rados_conf_read_file_exit, retval); + return retval; } 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; md_config_t *conf = client->cct->_conf; vector args; argv_to_vec(argc, argv, args); int ret = conf->parse_argv(args); - if (ret) + if (ret) { + tracepoint(librados, rados_conf_parse_argv_exit, ret); return ret; + } conf->apply_changes(NULL); - return 0; + int retval = 0; + tracepoint(librados, rados_conf_parse_argv_exit, retval); + return retval; } // like above, but return the remainder of argv to contain remaining @@ -1937,53 +1976,73 @@ 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; md_config_t *conf = client->cct->_conf; vector args; for (int i=0; iparse_argv(args); - if (ret) + if (ret) { + tracepoint(librados, rados_conf_parse_argv_remainder_exit, ret); return ret; + } conf->apply_changes(NULL); assert(args.size() <= (unsigned int)argc); - unsigned int i; 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]); } - return 0; + int retval = 0; + tracepoint(librados, rados_conf_parse_argv_remainder_exit, retval); + return retval; } 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; md_config_t *conf = client->cct->_conf; vector args; env_to_vec(args, env); int ret = conf->parse_argv(args); - if (ret) + if (ret) { + tracepoint(librados, rados_conf_parse_env_exit, ret); return ret; + } conf->apply_changes(NULL); - return 0; + int retval = 0; + tracepoint(librados, rados_conf_parse_env_exit, retval); + return retval; } 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; md_config_t *conf = client->cct->_conf; int ret = conf->set_val(option, value); - if (ret) + if (ret) { + tracepoint(librados, rados_conf_set_exit, ret); return ret; + } conf->apply_changes(NULL); - return 0; + int retval = 0; + tracepoint(librados, rados_conf_set_exit, retval); + return retval; } /* 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; @@ -1992,65 +2051,92 @@ extern "C" int rados_cluster_stat(rados_t cluster, rados_cluster_stat_t *result) 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; } 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; md_config_t *conf = client->cct->_conf; - return conf->get_val(option, &tmp, len); + int retval = conf->get_val(option, &tmp, len); + tracepoint(librados, rados_conf_get_exit, retval, retval ? "" : option); + return retval; } 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; - return radosp->lookup_pool(name); + int64_t retval = radosp->lookup_pool(name); + tracepoint(librados, rados_pool_lookup_exit, retval); + return retval; } 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) + if (r < 0) { + tracepoint(librados, rados_pool_reverse_lookup_exit, r, ""); return r; - if (name.length() >= maxlen) + } + if (name.length() >= maxlen) { + tracepoint(librados, rados_pool_reverse_lookup_exit, -ERANGE, ""); return -ERANGE; + } strcpy(buf, name.c_str()); - return name.length(); + int retval = name.length(); + tracepoint(librados, rados_pool_reverse_lookup_exit, retval, buf); + return retval; } 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) + if (fsid.length() >= maxlen) { + tracepoint(librados, rados_cluster_fsid_exit, -ERANGE, ""); return -ERANGE; + } strcpy(buf, fsid.c_str()); - return fsid.length(); + int retval = fsid.length(); + tracepoint(librados, rados_cluster_fsid_exit, retval, buf); + return retval; } 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; - return radosp->wait_for_latest_osdmap(); + int retval = radosp->wait_for_latest_osdmap(); + tracepoint(librados, rados_wait_for_latest_osdmap_exit, retval); + return retval; } 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 pools; int r = client->pool_list(pools); - if (r < 0) + if (r < 0) { + tracepoint(librados, rados_pool_list_exit, r); return r; + } - if (len > 0 && !buf) + if (len > 0 && !buf) { + tracepoint(librados, rados_pool_list_exit, -EINVAL); return -EINVAL; + } char *b = buf; if (b) @@ -2062,7 +2148,9 @@ extern "C" int rados_pool_list(rados_t cluster, char *buf, size_t len) int rl = i->length() + 1; if (len < (unsigned)rl) break; - strncat(b, i->c_str(), rl); + const char* pool = i->c_str(); + tracepoint(librados, rados_pool_list_pool, pool); + strncat(b, pool, rl); needed += rl; len -= rl; b += rl; @@ -2071,7 +2159,9 @@ extern "C" int rados_pool_list(rados_t cluster, char *buf, size_t len) int rl = i->length() + 1; needed += rl; } - return needed + 1; + int retval = needed + 1; + tracepoint(librados, rados_pool_list_exit, retval); + return retval; } static void do_out_buffer(bufferlist& outbl, char **outbuf, size_t *outbuflen) @@ -2105,16 +2195,20 @@ static void do_out_buffer(string& outbl, char **outbuf, size_t *outbuflen) 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) + 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 && !str.empty() && outstr && outstrlen) { do_out_buffer(str, outstr, outstrlen); } + tracepoint(librados, rados_ping_monitor_exit, ret, ret < 0 ? NULL : outstr, ret < 0 ? NULL : outstrlen); return ret; } @@ -2124,20 +2218,24 @@ extern "C" int rados_mon_command(rados_t cluster, const char **cmd, 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 cmdvec; - for (size_t i = 0; i < cmdlen; i++) + 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; } @@ -2148,6 +2246,7 @@ extern "C" int rados_mon_command_target(rados_t cluster, const char *name, 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; @@ -2165,8 +2264,10 @@ extern "C" int rados_mon_command_target(rados_t cluster, const char *name, rank = -1; } - for (size_t i = 0; i < cmdlen; i++) + 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; @@ -2177,6 +2278,7 @@ extern "C" int rados_mon_command_target(rados_t cluster, const char *name, 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; } @@ -2186,20 +2288,24 @@ extern "C" int rados_osd_command(rados_t cluster, int osdid, const char **cmd, 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 cmdvec; - for (size_t i = 0; i < cmdlen; i++) + 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; } @@ -2211,6 +2317,7 @@ extern "C" int rados_pg_command(rados_t cluster, const char *pgstr, 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; @@ -2218,8 +2325,10 @@ extern "C" int rados_pg_command(rados_t cluster, const char *pgstr, pg_t pgid; vector cmdvec; - for (size_t i = 0; i < cmdlen; i++) + 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)) @@ -2229,52 +2338,68 @@ extern "C" int rados_pg_command(rados_t cluster, const char *pgstr, 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; } 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); } 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; - return client->monitor_log(level, cb, arg); + int retval = client->monitor_log(level, cb, arg); + tracepoint(librados, rados_monitor_log_exit, retval); + return retval; } 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) + if (r < 0) { + tracepoint(librados, rados_ioctx_create_exit, r, NULL); return r; + } *io = ctx; ctx->get(); - return 0; + int retval = 0; + tracepoint(librados, rados_ioctx_create_exit, retval, ctx); + return retval; } 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); } 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 ls; ls.push_back(io_ctx_impl->pool_name); map rawresult; int err = io_ctx_impl->client->get_pool_stats(ls, rawresult); - if (err) + if (err) { + tracepoint(librados, rados_ioctx_pool_stat_exit, err, stats); return err; + } ::pool_stat_t& r = rawresult[io_ctx_impl->pool_name]; stats->num_kb = SHIFT_ROUND_UP(r.stats.sum.num_bytes, 10); @@ -2291,83 +2416,113 @@ extern "C" int rados_ioctx_pool_stat(rados_ioctx_t io, struct rados_pool_stat_t 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; - return 0; + int retval = 0; + tracepoint(librados, rados_ioctx_pool_stat_exit, retval, stats); + return retval; } 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; - return (rados_config_t)ctx->client->cct; + rados_config_t retval = (rados_config_t)ctx->client->cct; + tracepoint(librados, rados_ioctx_cct_exit, retval); + return retval; } 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); } 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 snv; snv.resize(num_snaps); - for (int i=0; iset_snap_write_context((snapid_t)seq, snv); + } + int retval = ctx->set_snap_write_context((snapid_t)seq, snv); + tracepoint(librados, rados_ioctx_selfmanaged_snap_set_write_ctx_exit, retval); + return retval; } 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); librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; object_t oid(o); bufferlist bl; bl.append(buf, len); - return ctx->write(oid, bl, len, off); + int retval = ctx->write(oid, bl, len, off); + tracepoint(librados, rados_write_exit, retval); + return retval; } 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); librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; object_t oid(o); bufferlist bl; bl.append(buf, len); - return ctx->append(oid, bl, len); + int retval = ctx->append(oid, bl, len); + tracepoint(librados, rados_append_exit, retval); + return retval; } 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); librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; object_t oid(o); bufferlist bl; bl.append(buf, len); - return ctx->write_full(oid, bl); + int retval = ctx->write_full(oid, bl); + tracepoint(librados, rados_write_full_exit, retval); + return retval; } extern "C" int rados_clone_range(rados_ioctx_t io, const char *dst, uint64_t dst_off, const char *src, uint64_t src_off, size_t len) { + tracepoint(librados, rados_clone_range_enter, io, dst, dst_off, src, src_off, len); librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; object_t dst_oid(dst), src_oid(src); - return ctx->clone_range(dst_oid, dst_off, src_oid, src_off, len); + int retval = ctx->clone_range(dst_oid, dst_off, src_oid, src_off, len); + tracepoint(librados, rados_clone_range_exit, retval); + return retval; } 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); - return ctx->trunc(oid, size); + int retval = ctx->trunc(oid, size); + tracepoint(librados, rados_trunc_exit, retval); + return retval; } 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); - return ctx->remove(oid); + int retval = ctx->remove(oid); + tracepoint(librados, rados_remove_exit, retval); + return retval; } 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); @@ -2378,141 +2533,198 @@ extern "C" int rados_read(rados_ioctx_t io, const char *o, char *buf, size_t len ret = ctx->read(oid, bl, len, off); if (ret >= 0) { - if (bl.length() > len) + if (bl.length() > len) { + tracepoint(librados, rados_read_exit, -ERANGE, NULL); return -ERANGE; + } if (bl.c_str() != buf) bl.copy(0, bl.length(), buf); ret = bl.length(); // hrm :/ } + tracepoint(librados, rados_read_exit, ret, buf); return ret; } 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; - return ctx->last_version(); + uint64_t retval = ctx->last_version(); + tracepoint(librados, rados_get_last_version_exit, retval); + return retval; } 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); - return radosp->pool_create(sname); + int retval = radosp->pool_create(sname); + tracepoint(librados, rados_pool_create_exit, retval); + return retval; } 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); - return radosp->pool_create(sname, auid); + int retval = radosp->pool_create(sname, auid); + tracepoint(librados, rados_pool_create_with_auid_exit, retval); + return retval; } 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); - return radosp->pool_create(sname, 0, crush_rule_num); + int retval = radosp->pool_create(sname, 0, crush_rule_num); + tracepoint(librados, rados_pool_create_with_crush_rule_exit, retval); + return retval; } 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); - return radosp->pool_create(sname, auid, crush_rule_num); + int retval = radosp->pool_create(sname, auid, crush_rule_num); + tracepoint(librados, rados_pool_create_with_all_exit, retval); + return retval; } 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; - return client->pool_delete(pool_name); + int retval = client->pool_delete(pool_name); + tracepoint(librados, rados_pool_delete_exit, retval); + return retval; } 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); librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; - return ctx->pool_change_auid(auid); + int retval = ctx->pool_change_auid(auid); + tracepoint(librados, rados_ioctx_pool_set_auid_exit, retval); + return retval; } extern "C" int rados_ioctx_pool_get_auid(rados_ioctx_t io, uint64_t *auid) { + tracepoint(librados, rados_ioctx_pool_get_auid_enter, io); librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; - return ctx->client->pool_get_auid(ctx->get_id(), (unsigned long long *)auid); + int retval = ctx->client->pool_get_auid(ctx->get_id(), (unsigned long long *)auid); + tracepoint(librados, rados_ioctx_pool_get_auid_exit, retval, *auid); + return retval; } 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; - return ctx->client->pool_requires_alignment(ctx->get_id()); + int retval = ctx->client->pool_requires_alignment(ctx->get_id()); + tracepoint(librados, rados_ioctx_pool_requires_alignment_exit, retval); + return retval; } 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; - return ctx->client->pool_required_alignment(ctx->get_id()); + uint64_t retval = ctx->client->pool_required_alignment(ctx->get_id()); + tracepoint(librados, rados_ioctx_pool_required_alignment_exit, retval); + return retval; } 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); } 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); } 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; - return (rados_t)ctx->client; + rados_t retval = (rados_t)ctx->client; + tracepoint(librados, rados_ioctx_get_cluster_exit, retval); + return retval; } 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; - return ctx->get_id(); + int64_t retval = ctx->get_id(); + tracepoint(librados, rados_ioctx_get_id_exit, retval); + return retval; } 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; - if (ctx->pool_name.length() >= maxlen) + if (ctx->pool_name.length() >= maxlen) { + tracepoint(librados, rados_ioctx_get_pool_name_exit, -ERANGE, ""); return -ERANGE; + } strcpy(s, ctx->pool_name.c_str()); - return ctx->pool_name.length(); + int retval = ctx->pool_name.length(); + tracepoint(librados, rados_ioctx_get_pool_name_exit, retval, s); + return retval; } // 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; - return ctx->snap_create(snapname); + int retval = ctx->snap_create(snapname); + tracepoint(librados, rados_ioctx_snap_create_exit, retval); + return retval; } 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; - return ctx->snap_remove(snapname); + int retval = ctx->snap_remove(snapname); + tracepoint(librados, rados_ioctx_snap_remove_exit, retval); + return retval; } 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; - return ctx->rollback(oid, snapname); + int retval = ctx->rollback(oid, snapname); + tracepoint(librados, rados_ioctx_snap_rollback_exit, retval); + return retval; } // Deprecated name kept for backward compatibility @@ -2525,97 +2737,136 @@ extern "C" int rados_rollback(rados_ioctx_t io, const char *oid, 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; - return ctx->selfmanaged_snap_create(snapid); + int retval = ctx->selfmanaged_snap_create(snapid); + tracepoint(librados, rados_ioctx_selfmanaged_snap_create_exit, retval, *snapid); + return retval; } 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; - return ctx->selfmanaged_snap_remove(snapid); + int retval = ctx->selfmanaged_snap_remove(snapid); + tracepoint(librados, rados_ioctx_selfmanaged_snap_remove_exit, retval); + return retval; } 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; - return ctx->selfmanaged_snap_rollback_object(oid, ctx->snapc, snapid); + int retval = ctx->selfmanaged_snap_rollback_object(oid, ctx->snapc, snapid); + tracepoint(librados, rados_ioctx_selfmanaged_snap_rollback_exit, retval); + return retval; } 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 snapvec; int r = ctx->snap_list(&snapvec); - if (r < 0) + if (r < 0) { + tracepoint(librados, rados_ioctx_snap_list_exit, r, snaps, 0); return r; + } if ((int)snapvec.size() <= maxlen) { - for (unsigned i=0; isnap_lookup(name, (uint64_t *)id); + int retval = ctx->snap_lookup(name, (uint64_t *)id); + tracepoint(librados, rados_ioctx_snap_lookup_exit, retval, *id); + return retval; } 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) + if (r < 0) { + tracepoint(librados, rados_ioctx_snap_get_name_exit, r, ""); return r; - if ((int)sname.length() >= maxlen) - return -ERANGE; + } + 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); - return 0; + int retval = 0; + tracepoint(librados, rados_ioctx_snap_get_name_exit, retval, name); + return retval; } 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; - return ctx->snap_get_stamp(id, t); + int retval = ctx->snap_get_stamp(id, t); + tracepoint(librados, rados_ioctx_snap_get_stamp_exit, retval, *t); + return retval; } 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; ret = ctx->getxattr(oid, name, bl); if (ret >= 0) { - if (bl.length() > len) + if (bl.length() > len) { + tracepoint(librados, rados_getxattr_exit, -ERANGE, buf, 0); return -ERANGE; + } bl.copy(0, bl.length(), buf); ret = bl.length(); } + tracepoint(librados, rados_getxattr_exit, ret, buf, ret); return ret; } 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) + 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(); @@ -2623,17 +2874,20 @@ extern "C" int rados_getxattrs(rados_ioctx_t io, const char *oid, librados::RadosXattrsIter **iret = (librados::RadosXattrsIter**)iter; *iret = it; *iter = it; + tracepoint(librados, rados_getxattrs_exit, 0, *iter); return 0; } 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(iter); if (it->i == it->attrset.end()) { *name = NULL; *val = NULL; *len = 0; + tracepoint(librados, rados_getxattrs_next_exit, 0, NULL, NULL, 0); return 0; } free(it->val); @@ -2642,86 +2896,117 @@ extern "C" int rados_getxattrs_next(rados_xattrs_iter_t iter, bufferlist &bl(it->i->second); size_t bl_len = bl.length(); it->val = (char*)malloc(bl_len); - if (!it->val) + 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; } extern "C" void rados_getxattrs_end(rados_xattrs_iter_t iter) { + tracepoint(librados, rados_getxattrs_end_enter, iter); librados::RadosXattrsIter *it = static_cast(iter); delete it; + tracepoint(librados, rados_getxattrs_end_exit); } 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); - return ctx->setxattr(oid, name, bl); + int retval = ctx->setxattr(oid, name, bl); + tracepoint(librados, rados_setxattr_exit, retval); + return retval; } 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); - return ctx->rmxattr(oid, name); + int retval = ctx->rmxattr(oid, name); + tracepoint(librados, rados_rmxattr_exit, retval); + return retval; } 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); - return ctx->stat(oid, psize, pmtime); + int retval = ctx->stat(oid, psize, pmtime); + tracepoint(librados, rados_stat_exit, retval, psize, pmtime); + return retval; } extern "C" int rados_tmap_update(rados_ioctx_t io, const char *o, const char *cmdbuf, size_t cmdbuflen) { + tracepoint(librados, rados_tmap_update_enter, io, o, cmdbuf, cmdbuflen); librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; object_t oid(o); bufferlist cmdbl; cmdbl.append(cmdbuf, cmdbuflen); - return ctx->tmap_update(oid, cmdbl); + int retval = ctx->tmap_update(oid, cmdbl); + tracepoint(librados, rados_tmap_update_exit, retval); + return retval; } extern "C" int rados_tmap_put(rados_ioctx_t io, const char *o, const char *buf, size_t buflen) { + tracepoint(librados, rados_tmap_put_enter, io, o, buf, buflen); librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; object_t oid(o); bufferlist bl; bl.append(buf, buflen); - return ctx->tmap_put(oid, bl); + int retval = ctx->tmap_put(oid, bl); + tracepoint(librados, rados_tmap_put_exit, retval); + return retval; } extern "C" int rados_tmap_get(rados_ioctx_t io, const char *o, char *buf, size_t buflen) { + tracepoint(librados, rados_tmap_get_enter, io, o, buflen); librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; object_t oid(o); bufferlist bl; int r = ctx->tmap_get(oid, bl); - if (r < 0) + if (r < 0) { + tracepoint(librados, rados_tmap_get_exit, r, buf, 0); return r; - if (bl.length() > buflen) + } + if (bl.length() > buflen) { + tracepoint(librados, rados_tmap_get_exit, -ERANGE, buf, 0); return -ERANGE; + } bl.copy(0, bl.length(), buf); - return bl.length(); + int retval = bl.length(); + tracepoint(librados, rados_tmap_get_exit, retval, buf, retval); + return retval; } extern "C" int rados_tmap_to_omap(rados_ioctx_t io, const char *o, bool nullok) { + tracepoint(librados, rados_tmap_to_omap_enter, io, o, nullok); librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; object_t oid(o); - return ctx->tmap_to_omap(oid, nullok); + int retval = ctx->tmap_to_omap(oid, nullok); + tracepoint(librados, rados_tmap_to_omap_exit, retval); + return retval; } 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; @@ -2730,12 +3015,15 @@ extern "C" int rados_exec(rados_ioctx_t io, const char *o, const char *cls, cons ret = ctx->exec(oid, cls, method, inbl, outbl); if (ret >= 0) { if (outbl.length()) { - if (outbl.length() > out_len) + 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; } @@ -2743,38 +3031,49 @@ extern "C" int rados_exec(rados_ioctx_t io, const char *o, const char *cls, cons extern "C" int rados_objects_list_open(rados_ioctx_t io, rados_list_ctx_t *listh) { + tracepoint(librados, rados_objects_list_open_enter, io); librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; Objecter::ListContext *h = new Objecter::ListContext; h->pool_id = ctx->poolid; h->pool_snap_seq = ctx->snap_seq; h->nspace = ctx->oloc.nspace; *listh = (void *)new librados::ObjListCtx(ctx, h); - return 0; + int retval = 0; + tracepoint(librados, rados_objects_list_open_exit, retval, *listh); + return retval; } extern "C" void rados_objects_list_close(rados_list_ctx_t h) { + tracepoint(librados, rados_objects_list_close_enter, h); librados::ObjListCtx *lh = (librados::ObjListCtx *)h; delete lh; + tracepoint(librados, rados_objects_list_close_exit); } extern "C" uint32_t rados_objects_list_seek(rados_list_ctx_t listctx, uint32_t pos) { + tracepoint(librados, rados_objects_list_seek_enter, listctx, pos); librados::ObjListCtx *lh = (librados::ObjListCtx *)listctx; uint32_t r = lh->ctx->list_seek(lh->lc, pos); + tracepoint(librados, rados_objects_list_seek_exit, r); return r; } extern "C" uint32_t rados_objects_list_get_pg_hash_position( rados_list_ctx_t listctx) { + tracepoint(librados, rados_objects_list_get_pg_hash_position_enter, listctx); librados::ObjListCtx *lh = (librados::ObjListCtx *)listctx; - return lh->lc->get_pg_hash_position(); + uint32_t retval = lh->lc->get_pg_hash_position(); + tracepoint(librados, rados_objects_list_get_pg_hash_position_exit, retval); + return retval; } extern "C" int rados_objects_list_next(rados_list_ctx_t listctx, const char **entry, const char **key) { + tracepoint(librados, rados_objects_list_next_enter, listctx); librados::ObjListCtx *lh = (librados::ObjListCtx *)listctx; Objecter::ListContext *h = lh->lc; @@ -2785,10 +3084,14 @@ extern "C" int rados_objects_list_next(rados_list_ctx_t listctx, const char **en if (h->list.empty()) { int ret = lh->ctx->list(lh->lc, RADOS_LIST_MAX_ENTRIES); - if (ret < 0) + if (ret < 0) { + tracepoint(librados, rados_objects_list_next_exit, ret, NULL, NULL); return ret; - if (h->list.empty()) + } + if (h->list.empty()) { + tracepoint(librados, rados_objects_list_next_exit, -ENOENT, NULL, NULL); return -ENOENT; + } } *entry = h->list.front().first.name.c_str(); @@ -2799,7 +3102,9 @@ extern "C" int rados_objects_list_next(rados_list_ctx_t listctx, const char **en else *key = NULL; } - return 0; + int retval = 0; + tracepoint(librados, rados_objects_list_next_exit, 0, *entry, key); + return retval; } @@ -2812,146 +3117,205 @@ extern "C" int rados_aio_create_completion(void *cb_arg, 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; - return 0; + int retval = 0; + tracepoint(librados, rados_aio_create_completion_exit, retval, *pc); + return retval; } extern "C" int rados_aio_wait_for_complete(rados_completion_t c) { - return ((librados::AioCompletionImpl*)c)->wait_for_complete(); + 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; } extern "C" int rados_aio_wait_for_safe(rados_completion_t c) { - return ((librados::AioCompletionImpl*)c)->wait_for_safe(); + 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; } extern "C" int rados_aio_is_complete(rados_completion_t c) { - return ((librados::AioCompletionImpl*)c)->is_complete(); + 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; } extern "C" int rados_aio_is_safe(rados_completion_t c) { - return ((librados::AioCompletionImpl*)c)->is_safe(); + 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; } extern "C" int rados_aio_wait_for_complete_and_cb(rados_completion_t c) { - return ((librados::AioCompletionImpl*)c)->wait_for_complete_and_cb(); + 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; } extern "C" int rados_aio_wait_for_safe_and_cb(rados_completion_t c) { - return ((librados::AioCompletionImpl*)c)->wait_for_safe_and_cb(); + 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; } extern "C" int rados_aio_is_complete_and_cb(rados_completion_t c) { - return ((librados::AioCompletionImpl*)c)->is_complete_and_cb(); + 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; } extern "C" int rados_aio_is_safe_and_cb(rados_completion_t c) { - return ((librados::AioCompletionImpl*)c)->is_safe_and_cb(); + 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; } extern "C" int rados_aio_get_return_value(rados_completion_t c) { - return ((librados::AioCompletionImpl*)c)->get_return_value(); + 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; } extern "C" uint64_t rados_aio_get_version(rados_completion_t c) { - return ((librados::AioCompletionImpl*)c)->get_version(); + 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; } 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); } 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); - return ctx->aio_read(oid, (librados::AioCompletionImpl*)completion, + int retval = ctx->aio_read(oid, (librados::AioCompletionImpl*)completion, buf, len, off, ctx->snap_seq); + tracepoint(librados, rados_aio_read_exit, retval); + return retval; } 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); librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; object_t oid(o); bufferlist bl; bl.append(buf, len); - return ctx->aio_write(oid, (librados::AioCompletionImpl*)completion, + int retval = ctx->aio_write(oid, (librados::AioCompletionImpl*)completion, bl, len, off); + tracepoint(librados, rados_aio_write_exit, retval); + return retval; } 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); librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; object_t oid(o); bufferlist bl; bl.append(buf, len); - return ctx->aio_append(oid, (librados::AioCompletionImpl*)completion, + int retval = ctx->aio_append(oid, (librados::AioCompletionImpl*)completion, bl, len); + tracepoint(librados, rados_aio_append_exit, retval); + return retval; } 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); librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; object_t oid(o); bufferlist bl; bl.append(buf, len); - return ctx->aio_write_full(oid, (librados::AioCompletionImpl*)completion, bl); + int retval = ctx->aio_write_full(oid, (librados::AioCompletionImpl*)completion, bl); + tracepoint(librados, rados_aio_write_full_exit, retval); + return retval; } 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); - return ctx->aio_remove(oid, (librados::AioCompletionImpl*)completion); + int retval = ctx->aio_remove(oid, (librados::AioCompletionImpl*)completion); + tracepoint(librados, rados_aio_remove_exit, retval); + return retval; } 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); - return 0; + int retval = 0; + tracepoint(librados, rados_aio_flush_async_exit, retval); + return retval; } 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(); - return 0; + int retval = 0; + tracepoint(librados, rados_aio_flush_exit, retval); + return retval; } 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); - return ctx->aio_stat(oid, (librados::AioCompletionImpl*)completion, + int retval = ctx->aio_stat(oid, (librados::AioCompletionImpl*)completion, psize, pmtime); + tracepoint(librados, rados_aio_stat_exit, retval); + return retval; } @@ -2967,23 +3331,30 @@ struct C_WatchCB : public librados::WatchCtx { 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); - return ctx->watch(oid, ver, cookie, wc); + int retval = ctx->watch(oid, ver, cookie, wc); + tracepoint(librados, rados_watch_exit, retval, *handle); + return retval; } 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; object_t oid(o); - return ctx->unwatch(oid, cookie); + int retval = ctx->unwatch(oid, cookie); + tracepoint(librados, rados_unwatch_exit, retval); + return retval; } 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; @@ -2992,16 +3363,21 @@ int rados_notify(rados_ioctx_t io, const char *o, uint64_t ver, const char *buf, memcpy(p.c_str(), buf, buf_len); bl.push_back(p); } - return ctx->notify(oid, ver, bl); + int retval = ctx->notify(oid, ver, bl); + tracepoint(librados, rados_notify_exit, retval); + return retval; } 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); - return ctx->set_alloc_hint(oid, expected_object_size, expected_write_size); + int retval = ctx->set_alloc_hint(oid, expected_object_size, expected_write_size); + tracepoint(librados, rados_set_alloc_hint_exit, retval); + return retval; } extern "C" int rados_lock_exclusive(rados_ioctx_t io, const char * o, @@ -3009,10 +3385,13 @@ extern "C" int rados_lock_exclusive(rados_ioctx_t io, const char * o, 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); - return ctx.lock_exclusive(o, name, cookie, desc, duration, flags); + int retval = ctx.lock_exclusive(o, name, cookie, desc, duration, flags); + tracepoint(librados, rados_lock_exclusive_exit, retval); + return retval; } extern "C" int rados_lock_shared(rados_ioctx_t io, const char * o, @@ -3020,19 +3399,24 @@ extern "C" int rados_lock_shared(rados_ioctx_t io, const char * o, 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); - return ctx.lock_shared(o, name, cookie, tag, desc, duration, flags); + int retval = ctx.lock_shared(o, name, cookie, tag, desc, duration, flags); + tracepoint(librados, rados_lock_shared_exit, retval); + return retval; } 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); - return ctx.unlock(o, name, cookie); - + int retval = ctx.unlock(o, name, cookie); + tracepoint(librados, rados_unlock_exit, retval); + return retval; } extern "C" ssize_t rados_list_lockers(rados_ioctx_t io, const char *o, @@ -3042,6 +3426,7 @@ extern "C" ssize_t rados_list_lockers(rados_ioctx_t io, const char *o, 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; @@ -3050,8 +3435,10 @@ extern "C" ssize_t rados_list_lockers(rados_ioctx_t io, const char *o, int tmp_exclusive; std::list lockers; int r = ctx.list_lockers(oid, name_str, &tmp_exclusive, &tag_str, &lockers); - if (r < 0) + 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; @@ -3071,8 +3458,10 @@ extern "C" ssize_t rados_list_lockers(rados_ioctx_t io, const char *o, *cookies_len = cookies_total; *addrs_len = addrs_total; *tag_len = tag_str.length() + 1; - if (too_short) + 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; @@ -3080,10 +3469,11 @@ extern "C" ssize_t rados_list_lockers(rados_ioctx_t io, const char *o, char *addrs_p = addrs; for (it = lockers.begin(); it != lockers.end(); ++it) { strcpy(clients_p, it->client.c_str()); - clients_p += it->client.length() + 1; strcpy(cookies_p, it->cookie.c_str()); - cookies_p += it->cookie.length() + 1; 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) @@ -3091,37 +3481,51 @@ extern "C" ssize_t rados_list_lockers(rados_ioctx_t io, const char *o, else *exclusive = 0; - return lockers.size(); + int retval = lockers.size(); + tracepoint(librados, rados_list_lockers_exit, retval, *exclusive, tag, *tag_len, *clients_len, *cookies_len, *addrs_len); + return retval; } 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); - return ctx.break_lock(o, name, client, cookie); + int retval = ctx.break_lock(o, name, client, cookie); + tracepoint(librados, rados_break_lock_exit, retval); + return retval; } extern "C" rados_write_op_t rados_create_write_op() { - return new (std::nothrow)::ObjectOperation; + 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; } 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); } 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); set_op_flags((::ObjectOperation *)write_op, flags); + tracepoint(librados, rados_write_op_set_flags_exit); } 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, (utime_t *)NULL, NULL); + tracepoint(librados, rados_write_op_assert_exists_exit); } extern "C" void rados_write_op_cmpxattr(rados_write_op_t write_op, @@ -3130,12 +3534,14 @@ extern "C" void rados_write_op_cmpxattr(rados_write_op_t write_op, 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); } static void rados_c_omap_cmp(ObjectOperation *op, @@ -3159,8 +3565,10 @@ extern "C" void rados_write_op_omap_cmp(rados_write_op_t write_op, 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, val_len, prval); + tracepoint(librados, rados_write_op_omap_cmp_exit); } extern "C" void rados_write_op_setxattr(rados_write_op_t write_op, @@ -3168,28 +3576,34 @@ extern "C" void rados_write_op_setxattr(rados_write_op_t write_op, 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); } 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); bufferlist bl; ((::ObjectOperation *)write_op)->rmxattr(name); + tracepoint(librados, rados_write_op_rmxattr_exit); } extern "C" void rados_write_op_create(rados_write_op_t write_op, int exclusive, const char* category) { + tracepoint(librados, rados_write_op_create_enter, write_op, exclusive, category); ::ObjectOperation *oo = (::ObjectOperation *) write_op; if(category) { oo->create(exclusive, category); } else { oo->create(!!exclusive); } + tracepoint(librados, rados_write_op_create_exit); } extern "C" void rados_write_op_write(rados_write_op_t write_op, @@ -3197,45 +3611,57 @@ extern "C" void rados_write_op_write(rados_write_op_t write_op, 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); } 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); } 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); } 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); } 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); } 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); } extern "C" void rados_write_op_exec(rados_write_op_t write_op, @@ -3245,9 +3671,11 @@ extern "C" void rados_write_op_exec(rados_write_op_t write_op, 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); } extern "C" void rados_write_op_omap_set(rados_write_op_t write_op, @@ -3256,34 +3684,46 @@ extern "C" void rados_write_op_omap_set(rados_write_op_t write_op, const size_t *lens, size_t num) { + tracepoint(librados, rados_write_op_omap_set_enter, write_op, num); std::map 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); } 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 to_remove(keys, keys + keys_len); ((::ObjectOperation *)write_op)->omap_rm_keys(to_remove); + tracepoint(librados, rados_write_op_omap_rm_keys_exit); } 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); } 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); + tracepoint(librados, rados_write_op_set_alloc_hint_exit); } extern "C" int rados_write_op_operate(rados_write_op_t write_op, @@ -3292,10 +3732,13 @@ extern "C" int rados_write_op_operate(rados_write_op_t write_op, 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; - return ctx->operate(obj, oo, mtime, flags); + int retval = ctx->operate(obj, oo, mtime, flags); + tracepoint(librados, rados_write_op_operate_exit, retval); + return retval; } extern "C" int rados_aio_write_op_operate(rados_write_op_t write_op, @@ -3305,31 +3748,43 @@ extern "C" int rados_aio_write_op_operate(rados_write_op_t write_op, 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; - return ctx->aio_operate(obj, oo, c, ctx->snapc, flags); + int retval = ctx->aio_operate(obj, oo, c, ctx->snapc, flags); + tracepoint(librados, rados_aio_write_op_operate_exit, retval); + return retval; } extern "C" rados_read_op_t rados_create_read_op() { - return new (std::nothrow)::ObjectOperation; + 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; } 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); } 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); set_op_flags((::ObjectOperation *)read_op, flags); + tracepoint(librados, rados_read_op_set_flags_exit); } 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, (utime_t *)NULL, NULL); + tracepoint(librados, rados_read_op_assert_exists_exit); } extern "C" void rados_read_op_cmpxattr(rados_read_op_t read_op, @@ -3338,12 +3793,14 @@ extern "C" void rados_read_op_cmpxattr(rados_read_op_t read_op, 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); } extern "C" void rados_read_op_omap_cmp(rados_read_op_t read_op, @@ -3353,8 +3810,10 @@ extern "C" void rados_read_op_omap_cmp(rados_read_op_t read_op, 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, val_len, prval); + tracepoint(librados, rados_read_op_omap_cmp_exit); } extern "C" void rados_read_op_stat(rados_read_op_t read_op, @@ -3362,7 +3821,9 @@ extern "C" void rados_read_op_stat(rados_read_op_t read_op, 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); } class C_bl_to_buf : public Context { @@ -3399,9 +3860,11 @@ extern "C" void rados_read_op_read(rados_read_op_t read_op, 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); } class C_out_buffer : public Context { @@ -3427,11 +3890,13 @@ extern "C" void rados_read_op_exec(rados_read_op_t read_op, 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); } extern "C" void rados_read_op_exec_user_buf(rados_read_op_t read_op, @@ -3444,11 +3909,13 @@ extern "C" void rados_read_op_exec_user_buf(rados_read_op_t read_op, 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); } struct RadosOmapIter { @@ -3478,10 +3945,12 @@ 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); } extern "C" void rados_read_op_omap_get_vals(rados_read_op_t read_op, @@ -3491,6 +3960,7 @@ extern "C" void rados_read_op_omap_get_vals(rados_read_op_t read_op, 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 : ""; @@ -3501,6 +3971,7 @@ extern "C" void rados_read_op_omap_get_vals(rados_read_op_t read_op, prval); ((::ObjectOperation *)read_op)->add_handler(new C_OmapIter(omap_iter)); *iter = omap_iter; + tracepoint(librados, rados_read_op_omap_get_vals_exit, *iter); } struct C_OmapKeysIter : public Context { @@ -3523,12 +3994,14 @@ extern "C" void rados_read_op_omap_get_keys(rados_read_op_t read_op, 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, prval); ((::ObjectOperation *)read_op)->add_handler(ctx); *iter = omap_iter; + tracepoint(librados, rados_read_op_omap_get_keys_exit, *iter); } extern "C" void rados_read_op_omap_get_vals_by_keys(rados_read_op_t read_op, @@ -3537,6 +4010,7 @@ extern "C" void rados_read_op_omap_get_vals_by_keys(rados_read_op_t read_op, 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 to_get(keys, keys + keys_len); RadosOmapIter *omap_iter = new RadosOmapIter; @@ -3545,6 +4019,7 @@ extern "C" void rados_read_op_omap_get_vals_by_keys(rados_read_op_t read_op, prval); ((::ObjectOperation *)read_op)->add_handler(new C_OmapIter(omap_iter)); *iter = omap_iter; + tracepoint(librados, rados_read_op_omap_get_vals_by_keys_exit, *iter); } extern "C" int rados_omap_get_next(rados_omap_iter_t iter, @@ -3552,12 +4027,15 @@ extern "C" int rados_omap_get_next(rados_omap_iter_t iter, char **val, size_t *len) { + tracepoint(librados, rados_omap_get_next_enter, iter); RadosOmapIter *it = (RadosOmapIter *)iter; if (it->i == it->values.end()) { *key = NULL; *val = NULL; *len = 0; - return 0; + int retval = 0; + tracepoint(librados, rados_omap_get_next_exit, retval, key, val, len); + return retval; } if (key) *key = (char*)it->i->first.c_str(); @@ -3566,13 +4044,17 @@ extern "C" int rados_omap_get_next(rados_omap_iter_t iter, if (len) *len = it->i->second.length(); ++it->i; - return 0; + int retval = 0; + tracepoint(librados, rados_omap_get_next_exit, retval, key, val, len); + return retval; } extern "C" void rados_omap_get_end(rados_omap_iter_t iter) { + tracepoint(librados, rados_omap_get_end_enter, iter); RadosOmapIter *it = (RadosOmapIter *)iter; delete it; + tracepoint(librados, rados_omap_get_end_exit); } extern "C" int rados_read_op_operate(rados_read_op_t read_op, @@ -3580,9 +4062,12 @@ extern "C" int rados_read_op_operate(rados_read_op_t read_op, 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; - return ctx->operate_read(obj, (::ObjectOperation *)read_op, NULL, flags); + int retval = ctx->operate_read(obj, (::ObjectOperation *)read_op, NULL, flags); + tracepoint(librados, rados_read_op_operate_exit, retval); + return retval; } extern "C" int rados_aio_read_op_operate(rados_read_op_t read_op, @@ -3591,9 +4076,12 @@ extern "C" int rados_aio_read_op_operate(rados_read_op_t read_op, 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; - return ctx->aio_operate_read(obj, (::ObjectOperation *)read_op, + int retval = ctx->aio_operate_read(obj, (::ObjectOperation *)read_op, c, flags, NULL); + tracepoint(librados, rados_aio_read_op_operate_exit, retval); + return retval; } diff --git a/src/tracing/Makefile.am b/src/tracing/Makefile.am index a02248f63e84..9cae3cf7a65b 100644 --- a/src/tracing/Makefile.am +++ b/src/tracing/Makefile.am @@ -2,9 +2,16 @@ $(LTTNG_GEN_TP_PROG) $< rm -f $<.o -dist_noinst_DATA = mutex.tp oprequest.tp osd.tp pg.tp +dist_noinst_DATA = \ + librados.tp \ + mutex.tp \ + oprequest.tp \ + osd.tp \ + pg.tp libtracepoints_la_SOURCES = \ + librados.c \ + librados.h \ mutex.c \ mutex.h \ oprequest.c \ @@ -20,6 +27,11 @@ libtracepoints_la_CPPFLAGS = -DTRACEPOINT_PROBE_DYNAMIC_LINKAGE libtracepoints_la_LDFLAGS = noinst_LTLIBRARIES = libtracepoints.la -BUILT_SOURCES = mutex.h oprequest.h osd.h pg.h +BUILT_SOURCES = \ + librados.h \ + mutex.h \ + oprequest.h \ + osd.h \ + pg.h CLEANFILES = $(libtracepoints_la_SOURCES) diff --git a/src/tracing/librados.tp b/src/tracing/librados.tp new file mode 100644 index 000000000000..9f3e54980f0d --- /dev/null +++ b/src/tracing/librados.tp @@ -0,0 +1,3057 @@ +#include "tracing/tracing-common.h" +#include "include/rados/librados.h" + +TRACEPOINT_EVENT(librados, rados_create_enter, + TP_ARGS( + const char*, id), + TP_FIELDS( + ceph_ctf_string(id, id) + ) +) + +TRACEPOINT_EVENT(librados, rados_create_exit, + TP_ARGS( + int, retval, + rados_t, cluster), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer_hex(rados_t, cluster, cluster) + ) +) + +TRACEPOINT_EVENT(librados, rados_create2_enter, + TP_ARGS( + const char*, clustername, + const char*, name, + uint64_t, flags), + TP_FIELDS( + ceph_ctf_string(clustername, clustername) + ceph_ctf_string(name, name) + ctf_integer_hex(uint64_t, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_create2_exit, + TP_ARGS( + int, retval, + rados_t, cluster), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer_hex(rados_t, cluster, cluster) + ) +) + +TRACEPOINT_EVENT(librados, rados_create_with_context_enter, + TP_ARGS( + rados_config_t, cct), + TP_FIELDS( + ctf_integer_hex(rados_config_t, cct, cct) + ) +) + +TRACEPOINT_EVENT(librados, rados_create_with_context_exit, + TP_ARGS( + int, retval, + rados_t, cluster), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer_hex(rados_t, cluster, cluster) + ) +) + +TRACEPOINT_EVENT(librados, rados_cct_enter, + TP_ARGS( + rados_t, cluster), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ) +) + +TRACEPOINT_EVENT(librados, rados_cct_exit, + TP_ARGS( + rados_config_t, retval), + TP_FIELDS( + ctf_integer_hex(rados_config_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_connect_enter, + TP_ARGS( + rados_t, cluster), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ) +) + +TRACEPOINT_EVENT(librados, rados_connect_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_shutdown_enter, + TP_ARGS( + rados_t, cluster), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ) +) + +TRACEPOINT_EVENT(librados, rados_shutdown_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_get_instance_id_enter, + TP_ARGS( + rados_t, cluster), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ) +) + +TRACEPOINT_EVENT(librados, rados_get_instance_id_exit, + TP_ARGS( + uint64_t, retval), + TP_FIELDS( + ctf_integer(uint64_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_version_enter, + TP_ARGS( + int*, pmajor, + int*, pminor, + int*, pextra), + TP_FIELDS( + ctf_integer_hex(int*, pmajor, pmajor) + ctf_integer_hex(int*, pminor, pminor) + ctf_integer_hex(int*, pextra, pextra) + ) +) + +TRACEPOINT_EVENT(librados, rados_version_exit, + TP_ARGS( + int, major, + int, minor, + int, extra), + TP_FIELDS( + ctf_integer(int, major, major) + ctf_integer(int, minor, minor) + ctf_integer(int, extra, extra) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_read_file_enter, + TP_ARGS( + rados_t, cluster, + const char*, path_list), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ceph_ctf_string(path_list, path_list) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_read_file_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_parse_argv_enter, + TP_ARGS( + rados_t, cluster, + int, argc), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_integer(int, argc, argc) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_parse_argv_arg, + TP_ARGS( + const char*, arg), + TP_FIELDS( + ceph_ctf_string(arg, arg) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_parse_argv_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_parse_argv_remainder_enter, + TP_ARGS( + rados_t, cluster, + int, argc), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_integer(int, argc, argc) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_parse_argv_remainder_arg, + TP_ARGS( + const char*, arg), + TP_FIELDS( + ceph_ctf_string(arg, arg) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_parse_argv_remainder_remarg, + TP_ARGS( + const char*, remarg), + TP_FIELDS( + ceph_ctf_string(remarg, remarg) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_parse_argv_remainder_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_parse_env_enter, + TP_ARGS( + rados_t, cluster, + const char*, env), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(env, env) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_parse_env_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_set_enter, + TP_ARGS( + rados_t, cluster, + const char*, option, + const char*, value), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ceph_ctf_string(option, option) + ceph_ctf_string(value, value) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_set_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_cluster_stat_enter, + TP_ARGS( + rados_t, cluster), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ) +) + +TRACEPOINT_EVENT(librados, rados_cluster_stat_exit, + TP_ARGS( + int, retval, + uint64_t, kb, + uint64_t, kb_used, + uint64_t, kb_avail, + uint64_t, num_objects), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, kb, kb) + ctf_integer(uint64_t, kb_used, kb_used) + ctf_integer(uint64_t, kb_avail, kb_avail) + ctf_integer(uint64_t, num_objects, num_objects) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_get_enter, + TP_ARGS( + rados_t, cluster, + const char*, option, + size_t, len), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(option, option) + ctf_integer(size_t, len, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_conf_get_exit, + TP_ARGS( + int, retval, + const char*, value), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_string(value, value) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_lookup_enter, + TP_ARGS( + rados_t, cluster, + const char*, name), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_lookup_exit, + TP_ARGS( + int64_t, retval), + TP_FIELDS( + ctf_integer(int64_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_reverse_lookup_enter, + TP_ARGS( + rados_t, cluster, + int64_t, id, + size_t, maxlen), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_integer(int64_t, id, id) + ctf_integer(size_t, maxlen, maxlen) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_reverse_lookup_exit, + TP_ARGS( + int, retval, + const char*, name), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librados, rados_cluster_fsid_enter, + TP_ARGS( + rados_t, cluster, + size_t, maxlen), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_integer(size_t, maxlen, maxlen) + ) +) + +TRACEPOINT_EVENT(librados, rados_cluster_fsid_exit, + TP_ARGS( + int, retval, + const char*, fsid), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_string(fsid, fsid) + ) +) + +TRACEPOINT_EVENT(librados, rados_wait_for_latest_osdmap_enter, + TP_ARGS( + rados_t, cluster), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ) +) + +TRACEPOINT_EVENT(librados, rados_wait_for_latest_osdmap_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_list_enter, + TP_ARGS( + rados_t, cluster, + size_t, maxlen), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_integer(size_t, maxlen, maxlen) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_list_pool, + TP_ARGS( + const char*, buf), + TP_FIELDS( + ctf_string(buf, buf) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_list_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ping_monitor_enter, + TP_ARGS( + rados_t, cluster, + const char*, mon_id), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(mon_id, mon_id) + ) +) + +TRACEPOINT_EVENT(librados, rados_ping_monitor_exit, + TP_ARGS( + int, retval, + char const* const*, buf, + size_t*, len), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_sequencep(unsigned char, buf, buf, size_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_mon_command_enter, + TP_ARGS( + rados_t, cluster, + size_t, cmdlen, + const char*, inbuf, + size_t, inbuflen), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_integer(size_t, cmdlen, cmdlen) + ceph_ctf_sequence(unsigned char, inbuf, inbuf, size_t, inbuflen) + ) +) + +TRACEPOINT_EVENT(librados, rados_mon_command_cmd, + TP_ARGS( + const char*, cmd), + TP_FIELDS( + ctf_string(cmd, cmd) + ) +) + +TRACEPOINT_EVENT(librados, rados_mon_command_exit, + TP_ARGS( + int, retval, + char**, outbuf, + size_t*, outbuflen, + char**, outs, + size_t*, outslen), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_stringp(outs, outs) + ceph_ctf_sequencep(unsigned char, outbuf, outbuf, size_t, outbuflen) + ceph_ctf_integerp(size_t, outslen, outslen) + ) +) + +TRACEPOINT_EVENT(librados, rados_mon_command_target_enter, + TP_ARGS( + rados_t, cluster, + const char*, name, + size_t, cmdlen, + const char*, inbuf, + size_t, inbuflen), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(name, name) + ctf_integer(size_t, cmdlen, cmdlen) + ceph_ctf_sequence(unsigned char, inbuf, inbuf, size_t, inbuflen) + ) +) + +TRACEPOINT_EVENT(librados, rados_mon_command_target_cmd, + TP_ARGS( + const char*, cmd), + TP_FIELDS( + ctf_string(cmd, cmd) + ) +) + +TRACEPOINT_EVENT(librados, rados_mon_command_target_exit, + TP_ARGS( + int, retval, + char**, outbuf, + size_t*, outbuflen, + char**, outs, + size_t*, outslen), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_stringp(outs, outs) + ceph_ctf_sequencep(unsigned char, outbuf, outbuf, size_t, outbuflen) + ceph_ctf_integerp(size_t, outslen, outslen) + ) +) + +TRACEPOINT_EVENT(librados, rados_osd_command_enter, + TP_ARGS( + rados_t, cluster, + int, osdid, + size_t, cmdlen, + const char*, inbuf, + size_t, inbuflen), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_integer(int, osdid, osdid) + ctf_integer(size_t, cmdlen, cmdlen) + ceph_ctf_sequence(unsigned char, inbuf, inbuf, size_t, inbuflen) + ) +) + +TRACEPOINT_EVENT(librados, rados_osd_command_cmd, + TP_ARGS( + const char*, cmd), + TP_FIELDS( + ctf_string(cmd, cmd) + ) +) + +TRACEPOINT_EVENT(librados, rados_osd_command_exit, + TP_ARGS( + int, retval, + char**, outbuf, + size_t*, outbuflen, + char**, outs, + size_t*, outslen), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_stringp(outs, outs) + ceph_ctf_sequencep(unsigned char, outbuf, outbuf, size_t, outbuflen) + ceph_ctf_integerp(size_t, outslen, outslen) + ) +) + +TRACEPOINT_EVENT(librados, rados_pg_command_enter, + TP_ARGS( + rados_t, cluster, + const char*, pg, + size_t, cmdlen, + const char*, inbuf, + size_t, inbuflen), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(pg, pg) + ctf_integer(size_t, cmdlen, cmdlen) + ceph_ctf_sequence(unsigned char, inbuf, inbuf, size_t, inbuflen) + ) +) + +TRACEPOINT_EVENT(librados, rados_pg_command_cmd, + TP_ARGS( + const char*, cmd), + TP_FIELDS( + ctf_string(cmd, cmd) + ) +) + +TRACEPOINT_EVENT(librados, rados_pg_command_exit, + TP_ARGS( + int, retval, + char**, outbuf, + size_t*, outbuflen, + char**, outs, + size_t*, outslen), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_stringp(outs, outs) + ceph_ctf_sequencep(unsigned char, outbuf, outbuf, size_t, outbuflen) + ceph_ctf_integerp(size_t, outslen, outslen) + ) +) + +TRACEPOINT_EVENT(librados, rados_buffer_free_enter, + TP_ARGS( + void*, buf), + TP_FIELDS( + ctf_integer_hex(void*, buf, buf) + ) +) + +TRACEPOINT_EVENT(librados, rados_buffer_free_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_monitor_log_enter, + TP_ARGS( + rados_t, cluster, + const char*, level, + rados_log_callback_t, callback, + void*, arg), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ceph_ctf_string(level, level) + ctf_integer_hex(rados_log_callback_t, callback, callback) + ctf_integer_hex(void*, arg, arg) + ) +) + +TRACEPOINT_EVENT(librados, rados_monitor_log_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_create_enter, + TP_ARGS( + rados_t, cluster, + const char*, name), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_create_exit, + TP_ARGS( + int, retval, + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_destroy_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_destroy_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_stat_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_stat_exit, + TP_ARGS( + int, retval, + struct rados_pool_stat_t*, stats), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, num_kb, stats->num_kb) + ctf_integer(uint64_t, num_bytes, stats->num_bytes) + ctf_integer(uint64_t, num_objects, stats->num_objects) + ctf_integer(uint64_t, num_object_clones, stats->num_object_clones) + ctf_integer(uint64_t, num_object_copies, stats->num_object_copies) + ctf_integer(uint64_t, num_objects_missing_on_primary, stats->num_objects_missing_on_primary) + ctf_integer(uint64_t, num_objects_unfound, stats->num_objects_unfound) + ctf_integer(uint64_t, num_objects_degraded, stats->num_objects_degraded) + ctf_integer(uint64_t, num_rd, stats->num_rd) + ctf_integer(uint64_t, num_rd_kb, stats->num_rd_kb) + ctf_integer(uint64_t, num_wr, stats->num_wr) + ctf_integer(uint64_t, num_wr_kb, stats->num_wr_kb) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_cct_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_cct_exit, + TP_ARGS( + rados_config_t, retval), + TP_FIELDS( + ctf_integer_hex(rados_config_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_set_read_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + uint64_t, snapid), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer(uint64_t, snapid, snapid) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_set_read_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_ioctx_selfmanaged_snap_set_write_ctx_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + uint64_t, seq, + uint64_t*, snaps, + int, num_snaps), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer(uint64_t, seq, seq) + ctf_sequence(uint64_t, snaps, snaps, + uint32_t, num_snaps) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_selfmanaged_snap_set_write_ctx_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const void*, buf, + size_t, len, + uint64_t, off), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_sequence(unsigned char, buf, buf, size_t, len) + ctf_integer(uint64_t, off, off) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_append_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const void*, buf, + size_t, len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_sequence(unsigned char, buf, buf, size_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_append_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_full_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const void*, buf, + size_t, len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_sequence(unsigned char, buf, buf, size_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_full_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_clone_range_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, dst, + uint64_t, dst_off, + const char*, src, + uint64_t, src_off, + size_t, len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(dst, dst) + ctf_integer(uint64_t, dst_off, dst_off) + ctf_string(src, src) + ctf_integer(uint64_t, src_off, src_off) + ctf_integer(size_t, len, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_clone_range_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_trunc_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + uint64_t, size), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer(uint64_t, size, size) + ) +) + +TRACEPOINT_EVENT(librados, rados_trunc_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_remove_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ) +) + +TRACEPOINT_EVENT(librados, rados_remove_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + void*, buf, + size_t, len, + uint64_t, off), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(void*, buf, buf) + ctf_integer(size_t, len, len) + ctf_integer(size_t, off, off) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_exit, + TP_ARGS( + int, retval, + void*, buf), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_sequence(unsigned char, buf, buf, uint64_t, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_get_last_version_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_get_last_version_exit, + TP_ARGS( + uint64_t, retval), + TP_FIELDS( + ctf_integer(uint64_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_create_enter, + TP_ARGS( + rados_t, cluster, + const char*, name), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_create_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_create_with_auid_enter, + TP_ARGS( + rados_t, cluster, + const char*, name, + uint64_t, auid), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(name, name) + ctf_integer(uint64_t, auid, auid) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_create_with_auid_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_create_with_crush_rule_enter, + TP_ARGS( + rados_t, cluster, + const char*, name, + uint8_t, crush_rule_num), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(name, name) + ctf_integer(uint8_t, crush_rule_num, crush_rule_num) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_create_with_crush_rule_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_create_with_all_enter, + TP_ARGS( + rados_t, cluster, + const char*, name, + uint64_t, auid, + uint8_t, crush_rule_num), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(name, name) + ctf_integer(uint64_t, auid, auid) + ctf_integer(uint8_t, crush_rule_num, crush_rule_num) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_create_with_all_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_delete_enter, + TP_ARGS( + rados_t, cluster, + const char*, name), + TP_FIELDS( + ctf_integer_hex(rados_t, cluster, cluster) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librados, rados_pool_delete_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_set_auid_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + uint64_t, auid), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer(uint64_t, auid, auid) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_set_auid_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_get_auid_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_get_auid_exit, + TP_ARGS( + int, retval, + uint64_t, auid), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, auid, auid) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_requires_alignment_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_requires_alignment_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_required_alignment_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_pool_required_alignment_exit, + TP_ARGS( + uint64_t, retval), + TP_FIELDS( + ctf_integer(uint64_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_locator_set_key_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, key), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ceph_ctf_string(key, key) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_locator_set_key_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_ioctx_set_namespace_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, nspace), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ceph_ctf_string(nspace, nspace) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_set_namespace_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_ioctx_get_cluster_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_get_cluster_exit, + TP_ARGS( + rados_t, retval), + TP_FIELDS( + ctf_integer_hex(rados_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_get_id_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_get_id_exit, + TP_ARGS( + int64_t, retval), + TP_FIELDS( + ctf_integer_hex(int64_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_get_pool_name_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + unsigned, maxlen), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer(unsigned, maxlen, maxlen) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_get_pool_name_exit, + TP_ARGS( + int, retval, + const char*, name), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_create_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, snapname), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(snapname, snapname) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_create_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_remove_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, snapname), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(snapname, snapname) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_remove_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_rollback_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, snapname), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_string(snapname, snapname) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_rollback_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_selfmanaged_snap_create_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_selfmanaged_snap_create_exit, + TP_ARGS( + int, retval, + uint64_t, snapid), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, snapid, snapid) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_selfmanaged_snap_remove_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + uint64_t, snapid), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer(uint64_t, snapid, snapid) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_selfmanaged_snap_remove_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_selfmanaged_snap_rollback_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + uint64_t, snapid), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer(uint64_t, snapid, snapid) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_selfmanaged_snap_rollback_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_list_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + int, maxlen), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer(int, maxlen, maxlen) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_list_exit, + TP_ARGS( + int, retval, + rados_snap_t*, snaps, + int, num_snaps), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_sequence(rados_snap_t, snaps, snaps, uint32_t, num_snaps) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_lookup_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, name), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_lookup_exit, + TP_ARGS( + int, retval, + uint64_t, snapid), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, snapid, snapid) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_get_name_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + uint64_t, snapid, + int, maxlen), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer(uint64_t, snapid, snapid) + ctf_integer(int, maxlen, maxlen) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_get_name_exit, + TP_ARGS( + int, retval, + const char*, name), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_get_stamp_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + uint64_t, snapid), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer(uint64_t, snapid, snapid) + ) +) + +TRACEPOINT_EVENT(librados, rados_ioctx_snap_get_stamp_exit, + TP_ARGS( + int, retval, + time_t, time), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_time_t(time, time) + ) +) + +TRACEPOINT_EVENT(librados, rados_getxattr_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, aname, + size_t, len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_string(aname, aname) + ctf_integer(size_t, len, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_getxattr_exit, + TP_ARGS( + int, retval, + const char*, value, + int, len), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_sequence(unsigned char, value, value, uint64_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_getxattrs_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ) +) + +TRACEPOINT_EVENT(librados, rados_getxattrs_exit, + TP_ARGS( + int, retval, + rados_xattrs_iter_t, iter), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer_hex(rados_xattrs_iter_t, iter, iter) + ) +) + +TRACEPOINT_EVENT(librados, rados_getxattrs_next_enter, + TP_ARGS( + rados_xattrs_iter_t, iter), + TP_FIELDS( + ctf_integer_hex(rados_xattrs_iter_t, iter, iter) + ) +) + +TRACEPOINT_EVENT(librados, rados_getxattrs_next_exit, + TP_ARGS( + int, retval, + const char*, aname, + const char*, value, + size_t, len), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_string(aname, aname) + ceph_ctf_sequence(unsigned char, value, value, size_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_getxattrs_end_enter, + TP_ARGS( + rados_xattrs_iter_t, iter), + TP_FIELDS( + ctf_integer_hex(rados_xattrs_iter_t, iter, iter) + ) +) + +TRACEPOINT_EVENT(librados, rados_getxattrs_end_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_setxattr_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, aname, + const char*, value, + size_t, len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_string(aname, aname) + ceph_ctf_sequence(unsigned char, value, value, size_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_setxattr_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_rmxattr_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, aname), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_string(aname, aname) + ) +) + +TRACEPOINT_EVENT(librados, rados_rmxattr_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_stat_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ) +) + +TRACEPOINT_EVENT(librados, rados_stat_exit, + TP_ARGS( + int, retval, + uint64_t*, size, + time_t*, mtime), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_integerp(uint64_t, size, size) + ceph_ctf_time_tp(mtime, mtime) + ) +) + +TRACEPOINT_EVENT(librados, rados_tmap_update_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, cmdbuf, + size_t, cmdbuflen), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_sequence(unsigned char, cmdbuf, cmdbuf, size_t, CEPH_MIN(cmdbuflen, CEPH_TRACE_BUF_TRUNC_LEN)) + ctf_integer(size_t, cmdbuflen, cmdbuflen) + ) +) + +TRACEPOINT_EVENT(librados, rados_tmap_update_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_tmap_put_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, buf, + size_t, buflen), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_sequence(unsigned char, buf, buf, size_t, CEPH_MIN(buflen, CEPH_TRACE_BUF_TRUNC_LEN)) + ctf_integer(size_t, buflen, buflen) + ) +) + +TRACEPOINT_EVENT(librados, rados_tmap_put_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_tmap_get_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + size_t, buflen), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer(size_t, buflen, buflen) + ) +) + +TRACEPOINT_EVENT(librados, rados_tmap_get_exit, + TP_ARGS( + int, retval, + char*, buf, + int, len), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_sequence(unsigned char, buf, buf, uint32_t, CEPH_MIN(len, CEPH_TRACE_BUF_TRUNC_LEN)) + ctf_integer(int, len, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_tmap_to_omap_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + char, nullok), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer(char, nullok, nullok) + ) +) + +TRACEPOINT_EVENT(librados, rados_tmap_to_omap_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_exec_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, cls, + const char*, method, + const char*, inbuf, + size_t, in_len, + size_t, out_len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_string(cls, cls) + ctf_string(method, method) + ceph_ctf_sequence(unsigned char, inbuf, inbuf, size_t, in_len) + ctf_integer(size_t, out_len, out_len) + ) +) + +TRACEPOINT_EVENT(librados, rados_exec_exit, + TP_ARGS( + int, retval, + char*, outbuf, + size_t, len), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_sequence(unsigned char, outbuf, outbuf, size_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_objects_list_open_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_objects_list_open_exit, + TP_ARGS( + int, retval, + rados_list_ctx_t, listctx), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer_hex(rados_list_ctx_t, listctx, listctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_objects_list_close_enter, + TP_ARGS( + rados_list_ctx_t, listctx), + TP_FIELDS( + ctf_integer_hex(rados_list_ctx_t, listctx, listctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_objects_list_close_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_objects_list_seek_enter, + TP_ARGS( + rados_list_ctx_t, listctx, + uint32_t, pos), + TP_FIELDS( + ctf_integer_hex(rados_list_ctx_t, listctx, listctx) + ctf_integer(uint32_t, pos, pos) + ) +) + +TRACEPOINT_EVENT(librados, rados_objects_list_seek_exit, + TP_ARGS( + uint32_t, retval), + TP_FIELDS( + ctf_integer(uint32_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_objects_list_get_pg_hash_position_enter, + TP_ARGS( + rados_list_ctx_t, listctx), + TP_FIELDS( + ctf_integer_hex(rados_list_ctx_t, listctx, listctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_objects_list_get_pg_hash_position_exit, + TP_ARGS( + uint32_t, retval), + TP_FIELDS( + ctf_integer(uint32_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_objects_list_next_enter, + TP_ARGS( + rados_list_ctx_t, listctx), + TP_FIELDS( + ctf_integer_hex(rados_list_ctx_t, listctx, listctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_objects_list_next_exit, + TP_ARGS( + int, retval, + const char*, entry, + char const* const*, key), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_string(entry, entry) + ceph_ctf_stringp(key, key) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_create_completion_enter, + TP_ARGS( + void*, cb_arg, + rados_callback_t, cb_complete, + rados_callback_t, cb_safe), + TP_FIELDS( + ctf_integer_hex(void*, cb_arg, cb_arg) + ctf_integer_hex(rados_callback_t, cb_complete, cb_complete) + ctf_integer_hex(rados_callback_t, cb_safe, cb_safe) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_create_completion_exit, + TP_ARGS( + int, retval, + rados_completion_t, completion), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_wait_for_complete_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_wait_for_complete_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_wait_for_safe_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_wait_for_safe_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_is_complete_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_is_complete_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_is_safe_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_is_safe_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_wait_for_complete_and_cb_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_wait_for_complete_and_cb_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_wait_for_safe_and_cb_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_wait_for_safe_and_cb_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_is_complete_and_cb_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_is_complete_and_cb_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_is_safe_and_cb_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_is_safe_and_cb_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_get_return_value_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_get_return_value_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_get_version_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_get_version_exit, + TP_ARGS( + uint64_t, retval), + TP_FIELDS( + ctf_integer(uint64_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_release_enter, + TP_ARGS( + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_release_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_aio_read_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion, + size_t, len, + uint64_t, off), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(rados_completion_t, completion, completion) + ctf_integer(size_t, len, len) + ctf_integer(uint64_t, off, off) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_read_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_write_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion, + const char*, buf, + size_t, len, + uint64_t, off), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(rados_completion_t, completion, completion) + ctf_sequence(unsigned char, buf, buf, size_t, CEPH_MIN(len, CEPH_TRACE_BUF_TRUNC_LEN)) + ctf_integer(size_t, len, len) + ctf_integer(uint64_t, off, off) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_write_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_append_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion, + const char*, buf, + size_t, len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(rados_completion_t, completion, completion) + ctf_sequence(unsigned char, buf, buf, size_t, CEPH_MIN(len, CEPH_TRACE_BUF_TRUNC_LEN)) + ctf_integer(size_t, len, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_append_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_write_full_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion, + const char*, buf, + size_t, len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(rados_completion_t, completion, completion) + ctf_sequence(unsigned char, buf, buf, size_t, CEPH_MIN(len, CEPH_TRACE_BUF_TRUNC_LEN)) + ctf_integer(size_t, len, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_write_full_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_remove_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_remove_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_flush_async_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_flush_async_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_flush_enter, + TP_ARGS( + rados_ioctx_t, ioctx), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_flush_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_stat_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + rados_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer_hex(rados_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_stat_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_watch_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + uint64_t, version, + rados_watchcb_t, callback, + void*, arg), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer(uint64_t, version, version) + ctf_integer_hex(rados_watchcb_t, callback, callback) + ctf_integer_hex(void*, arg, arg) + ) +) + +TRACEPOINT_EVENT(librados, rados_watch_exit, + TP_ARGS( + int, retval, + uint64_t, handle), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(uint64_t, handle, handle) + ) +) + +TRACEPOINT_EVENT(librados, rados_unwatch_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + uint64_t, handle), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer(uint64_t, handle, handle) + ) +) + +TRACEPOINT_EVENT(librados, rados_unwatch_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_notify_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + uint64_t, version, + const char*, buf, + int, buf_len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer(uint64_t, version, version) + ceph_ctf_sequence(unsigned char, buf, buf, size_t, buf_len) + ) +) + +TRACEPOINT_EVENT(librados, rados_notify_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_set_alloc_hint_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + uint64_t, expected_object_size, + uint64_t, expected_write_size), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ctf_integer(uint64_t, expected_object_size, expected_object_size) + ctf_integer(uint64_t, expected_write_size, expected_write_size) + ) +) + +TRACEPOINT_EVENT(librados, rados_set_alloc_hint_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_lock_exclusive_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, name, + const char*, cookie, + const char*, description, + struct timeval*, duration, + uint8_t, flags), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_string(name, name) + ceph_ctf_string(cookie, cookie) + ceph_ctf_string(description, description) + ceph_ctf_timevalp(duration, duration) + ctf_integer(uint8_t, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_lock_exclusive_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_lock_shared_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, name, + const char*, cookie, + const char*, tag, + const char*, description, + struct timeval*, duration, + uint8_t, flags), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_string(name, name) + ceph_ctf_string(cookie, cookie) + ceph_ctf_string(tag, tag) + ceph_ctf_string(description, description) + ceph_ctf_timevalp(duration, duration) + ctf_integer(uint8_t, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_lock_shared_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_unlock_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, name, + const char*, cookie), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_string(name, name) + ceph_ctf_string(cookie, cookie) + ) +) + +TRACEPOINT_EVENT(librados, rados_unlock_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_list_lockers_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, name, + size_t, tag_len, + size_t, clients_len, + size_t, cookies_len, + size_t, addrs_len), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_string(name, name) + ctf_integer(size_t, tag_len, tag_len) + ctf_integer(size_t, clients_len, clients_len) + ctf_integer(size_t, cookies_len, cookies_len) + ctf_integer(size_t, addrs_len, addrs_len) + ) +) + +TRACEPOINT_EVENT(librados, rados_list_lockers_locker, + TP_ARGS( + const char*, client, + const char*, cookie, + const char*, addr), + TP_FIELDS( + ctf_string(client, client) + ctf_string(cookie, cookie) + ctf_string(addr, addr) + ) +) + +TRACEPOINT_EVENT(librados, rados_list_lockers_exit, + TP_ARGS( + int, retval, + int, exclusive, + const char*, tag, + size_t, tag_len, + size_t, clients_len, + size_t, cookies_len, + size_t, addrs_len), + TP_FIELDS( + ctf_integer(int, retval, retval) + ctf_integer(int, exclusive, exclusive) + ctf_string(tag, tag) + ctf_integer(size_t, tag_len, tag_len) + ctf_integer(size_t, clients_len, clients_len) + ctf_integer(size_t, cookies_len, cookies_len) + ctf_integer(size_t, addrs_len, addrs_len) + ) +) + +TRACEPOINT_EVENT(librados, rados_break_lock_enter, + TP_ARGS( + rados_ioctx_t, ioctx, + const char*, oid, + const char*, name, + const char*, client, + const char*, cookie), + TP_FIELDS( + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_string(name, name) + ceph_ctf_string(client, client) + ceph_ctf_string(cookie, cookie) + ) +) + +TRACEPOINT_EVENT(librados, rados_break_lock_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_create_write_op_enter, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_create_write_op_exit, + TP_ARGS( + rados_write_op_t, retval), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_release_write_op_enter, + TP_ARGS( + rados_write_op_t, op), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ) +) + +TRACEPOINT_EVENT(librados, rados_release_write_op_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_set_flags_enter, + TP_ARGS( + rados_write_op_t, op, + int, flags), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer(int, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_set_flags_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_assert_exists_enter, + TP_ARGS( + rados_write_op_t, op), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_assert_exists_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_cmpxattr_enter, + TP_ARGS( + rados_write_op_t, op, + const char*, aname, + uint8_t, comparison_operator, + const char*, value, + size_t, value_len), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ceph_ctf_string(aname, aname) + ctf_integer(uint8_t, comparison_operator, comparison_operator) + ceph_ctf_sequence(unsigned char, value, value, size_t, value_len) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_cmpxattr_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_cmp_enter, + TP_ARGS( + rados_write_op_t, op, + const char*, name, + uint8_t, comparison_operator, + const char*, value, + size_t, value_len, + int*, prval), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ceph_ctf_string(name, name) + ctf_integer(uint8_t, comparison_operator, comparison_operator) + ceph_ctf_sequence(unsigned char, value, value, size_t, value_len) + ctf_integer_hex(int*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_cmp_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_setxattr_enter, + TP_ARGS( + rados_write_op_t, op, + const char*, name, + const char*, value, + size_t, value_len), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ceph_ctf_string(name, name) + ceph_ctf_sequence(unsigned char, value, value, size_t, value_len) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_setxattr_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_rmxattr_enter, + TP_ARGS( + rados_write_op_t, op, + const char*, name), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ceph_ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_rmxattr_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_create_enter, + TP_ARGS( + rados_write_op_t, op, + int, exclusive, + const char*, category), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer(int, exclusive, exclusive) + ceph_ctf_string(category, category) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_create_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_write_enter, + TP_ARGS( + rados_write_op_t, op, + const char*, buffer, + size_t, len, + uint64_t, offset), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ceph_ctf_sequence(unsigned char, buffer, buffer, size_t, len) + ctf_integer(uint64_t, offset, offset) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_write_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_write_full_enter, + TP_ARGS( + rados_write_op_t, op, + const char*, buffer, + size_t, len), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ceph_ctf_sequence(unsigned char, buffer, buffer, size_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_write_full_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_append_enter, + TP_ARGS( + rados_write_op_t, op, + const char*, buffer, + size_t, len), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ceph_ctf_sequence(unsigned char, buffer, buffer, size_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_append_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_remove_enter, + TP_ARGS( + rados_write_op_t, op), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_remove_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_truncate_enter, + TP_ARGS( + rados_write_op_t, op, + uint64_t, offset), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer(uint64_t, offset, offset) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_truncate_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_zero_enter, + TP_ARGS( + rados_write_op_t, op, + uint64_t, offset, + uint64_t, len), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, len, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_zero_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_exec_enter, + TP_ARGS( + rados_write_op_t, op, + const char*, cls, + const char*, method, + const char*, in_buf, + size_t, in_len, + int*, prval), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ceph_ctf_string(cls, cls) + ceph_ctf_string(method, method) + ceph_ctf_sequence(unsigned char, in_buf, in_buf, size_t, in_len) + ctf_integer_hex(int*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_exec_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_set_enter, + TP_ARGS( + rados_write_op_t, op, + size_t, num), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer(size_t, num, num) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_set_entry, + TP_ARGS( + const char*, key, + const char*, value, + size_t, value_len), + TP_FIELDS( + ceph_ctf_string(key, key) + ceph_ctf_sequence(unsigned char, value, value, size_t, value_len) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_set_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_rm_keys_enter, + TP_ARGS( + rados_write_op_t, op, + size_t, num), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer(size_t, num, num) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_rm_keys_entry, + TP_ARGS( + const char*, key), + TP_FIELDS( + ceph_ctf_string(key, key) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_rm_keys_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_clear_enter, + TP_ARGS( + rados_write_op_t, op), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_omap_clear_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_set_alloc_hint_enter, + TP_ARGS( + rados_write_op_t, op, + uint64_t, expected_object_size, + uint64_t, expected_write_size), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer(uint64_t, expected_object_size, expected_object_size) + ctf_integer(uint64_t, expected_write_size, expected_write_size) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_set_alloc_hint_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_write_op_operate_enter, + TP_ARGS( + rados_write_op_t, op, + rados_ioctx_t, ioctx, + const char*, oid, + time_t*, mtime, + int, flags), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_string(oid, oid) + ceph_ctf_time_tp(mtime, mtime) + ctf_integer_hex(int, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_write_op_operate_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_write_op_operate_enter, + TP_ARGS( + rados_write_op_t, op, + rados_ioctx_t, ioctx, + rados_completion_t, completion, + const char*, oid, + time_t*, mtime, + int, flags), + TP_FIELDS( + ctf_integer_hex(rados_write_op_t, op, op) + ctf_integer_hex(rados_ioctx_t, ioctx, ioctx) + ctf_integer_hex(rados_completion_t, completion, completion) + ctf_string(oid, oid) + ceph_ctf_time_tp(mtime, mtime) + ctf_integer_hex(int, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_write_op_operate_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_create_read_op_enter, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_create_read_op_exit, + TP_ARGS( + rados_read_op_t, retval), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_release_read_op_enter, + TP_ARGS( + rados_read_op_t, read_op), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ) +) + +TRACEPOINT_EVENT(librados, rados_release_read_op_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_set_flags_enter, + TP_ARGS( + rados_read_op_t, read_op, + int, flags), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ctf_integer_hex(int, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_set_flags_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_assert_exists_enter, + TP_ARGS( + rados_read_op_t, read_op), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_assert_exists_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_cmpxattr_enter, + TP_ARGS( + rados_read_op_t, read_op, + const char*, name, + uint8_t, comparison_operator, + const char*, value, + size_t, value_len), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ctf_string(name, name) + ctf_integer(uint8_t, comparison_operator, comparison_operator) + ceph_ctf_sequence(unsigned char, value, value, size_t, value_len) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_cmpxattr_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_omap_cmp_enter, + TP_ARGS( + rados_read_op_t, read_op, + const char*, name, + uint8_t, comparison_operator, + const char*, value, + size_t, value_len, + void*, prval), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ctf_string(name, name) + ctf_integer(uint8_t, comparison_operator, comparison_operator) + ceph_ctf_sequence(unsigned char, value, value, size_t, value_len) + ctf_integer_hex(void*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_omap_cmp_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_stat_enter, + TP_ARGS( + rados_read_op_t, read_op, + void*, psize, + void*, pmtime, + void*, prval), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ctf_integer_hex(void*, psize, psize) + ctf_integer_hex(void*, pmtime, pmtime) + ctf_integer_hex(void*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_stat_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_read_enter, + TP_ARGS( + rados_read_op_t, read_op, + uint64_t, offset, + size_t, len, + char*, buf, + size_t*, bytes_read, + int*, prval), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ctf_integer(uint64_t, offset, offset) + ctf_integer(size_t, len, len) + ctf_integer_hex(void*, buf, buf) + ctf_integer_hex(void*, bytes_read, bytes_read) + ctf_integer_hex(void*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_read_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_exec_enter, + TP_ARGS( + 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), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ceph_ctf_string(cls, cls) + ceph_ctf_string(method, method) + ceph_ctf_sequence(unsigned char, in_buf, in_buf, size_t, in_len) + ctf_integer_hex(void*, out_buf, out_buf) + ctf_integer_hex(void*, out_len, out_len) + ctf_integer_hex(void*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_exec_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_exec_user_buf_enter, + TP_ARGS( + 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), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ceph_ctf_string(cls, cls) + ceph_ctf_string(method, method) + ceph_ctf_sequence(unsigned char, in_buf, in_buf, size_t, in_len) + ctf_integer_hex(void*, out_buf, out_buf) + ctf_integer(size_t, out_len, out_len) + ctf_integer_hex(void*, used_len, used_len) + ctf_integer_hex(void*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_exec_user_buf_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_getxattrs_enter, + TP_ARGS( + rados_read_op_t, read_op, + int*, prval), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ctf_integer_hex(void*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_getxattrs_exit, + TP_ARGS( + rados_xattrs_iter_t, iter), + TP_FIELDS( + ctf_integer_hex(rados_xattrs_iter_t, iter, iter) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_omap_get_vals_enter, + TP_ARGS( + rados_read_op_t, read_op, + const char*, start_after, + const char*, filter_prefix, + uint64_t, max_return, + int*, prval), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ceph_ctf_string(start_after, start_after) + ceph_ctf_string(filter_prefix, filter_prefix) + ctf_integer(uint64_t, max_return, max_return) + ctf_integer_hex(void*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_omap_get_vals_exit, + TP_ARGS( + rados_omap_iter_t, iter), + TP_FIELDS( + ctf_integer_hex(rados_omap_iter_t, iter, iter) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_omap_get_keys_enter, + TP_ARGS( + rados_read_op_t, read_op, + const char*, start_after, + uint64_t, max_return, + int*, prval), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ceph_ctf_string(start_after, start_after) + ctf_integer(uint64_t, max_return, max_return) + ctf_integer_hex(void*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_omap_get_keys_exit, + TP_ARGS( + rados_omap_iter_t, iter), + TP_FIELDS( + ctf_integer_hex(rados_omap_iter_t, iter, iter) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_omap_get_vals_by_keys_enter, + TP_ARGS( + rados_read_op_t, read_op, + char const* const*, keys, + size_t, keys_len, + rados_omap_iter_t*, piter, + int*, prval), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ctf_integer_hex(void*, keys, keys) + ctf_integer(size_t, keys_len, keys_len) + ctf_integer_hex(void*, piter, piter) + ctf_integer_hex(void*, prval, prval) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_omap_get_vals_by_keys_exit, + TP_ARGS( + rados_omap_iter_t, iter), + TP_FIELDS( + ctf_integer_hex(rados_omap_iter_t, iter, iter) + ) +) + +TRACEPOINT_EVENT(librados, rados_omap_get_next_enter, + TP_ARGS( + rados_omap_iter_t, iter), + TP_FIELDS( + ctf_integer_hex(rados_omap_iter_t, iter, iter) + ) +) + +TRACEPOINT_EVENT(librados, rados_omap_get_next_exit, + TP_ARGS( + int, retval, + char**, key, + char**, val, + size_t*, len), + TP_FIELDS( + ctf_integer(int, retval, retval) + ceph_ctf_stringp(key, key) + ceph_ctf_sequencep(unsigned char, val, val, size_t, len) + ) +) + +TRACEPOINT_EVENT(librados, rados_omap_get_end_enter, + TP_ARGS( + rados_omap_iter_t, iter), + TP_FIELDS( + ctf_integer_hex(rados_omap_iter_t, iter, iter) + ) +) + +TRACEPOINT_EVENT(librados, rados_omap_get_end_exit, + TP_ARGS(), + TP_FIELDS() +) + +TRACEPOINT_EVENT(librados, rados_read_op_operate_enter, + TP_ARGS( + rados_read_op_t, read_op, + rados_ioctx_t, ctx, + const char*, oid, + int, flags), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ctf_integer_hex(rados_ioctx_t, ctx, ctx) + ctf_string(oid, oid) + ctf_integer(int, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_read_op_operate_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_read_op_operate_enter, + TP_ARGS( + rados_read_op_t, read_op, + rados_ioctx_t, ctx, + rados_completion_t, completion, + const char*, oid, + int, flags), + TP_FIELDS( + ctf_integer_hex(rados_read_op_t, read_op, read_op) + ctf_integer_hex(rados_ioctx_t, ctx, ctx) + ctf_integer_hex(rados_completion_t, completion, completion) + ceph_ctf_string(oid, oid) + ctf_integer(int, flags, flags) + ) +) + +TRACEPOINT_EVENT(librados, rados_aio_read_op_operate_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +)