*
*/
+#include "tracing/librados.h"
#include <limits.h>
#include "common/config.h"
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
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
*/
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<std::string> 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<const char*> 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
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<const char*> args;
for (int i=0; i<argc; i++)
args.push_back(argv[i]);
int ret = conf->parse_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<const char*> 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;
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<std::string> 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)
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;
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)
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;
}
char **outbuf, size_t *outbuflen,
char **outs, size_t *outslen)
{
+ tracepoint(librados, rados_mon_command_enter, cluster, cmdlen, inbuf, inbuflen);
librados::RadosClient *client = (librados::RadosClient *)cluster;
bufferlist inbl;
bufferlist outbl;
string outstring;
vector<string> cmdvec;
- for (size_t i = 0; i < cmdlen; i++)
+ 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;
}
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;
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;
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;
}
char **outbuf, size_t *outbuflen,
char **outs, size_t *outslen)
{
+ tracepoint(librados, rados_osd_command_enter, cluster, osdid, cmdlen, inbuf, inbuflen);
librados::RadosClient *client = (librados::RadosClient *)cluster;
bufferlist inbl;
bufferlist outbl;
string outstring;
vector<string> cmdvec;
- for (size_t i = 0; i < cmdlen; i++)
+ 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;
}
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;
pg_t pgid;
vector<string> 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))
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<string> ls;
ls.push_back(io_ctx_impl->pool_name);
map<string, ::pool_stat_t> 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);
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<snapid_t> snv;
snv.resize(num_snaps);
- for (int i=0; i<num_snaps; i++)
+ for (int i=0; i<num_snaps; i++) {
snv[i] = (snapid_t)snaps[i];
- return ctx->set_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);
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
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<uint64_t> 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; i<snapvec.size(); i++)
+ for (unsigned i=0; i<snapvec.size(); i++) {
snaps[i] = snapvec[i];
- return snapvec.size();
+ }
+ int retval = snapvec.size();
+ tracepoint(librados, rados_ioctx_snap_list_exit, retval, snaps, retval);
+ return retval;
}
- return -ERANGE;
+ int retval = -ERANGE;
+ tracepoint(librados, rados_ioctx_snap_list_exit, retval, snaps, 0);
+ return retval;
}
extern "C" int rados_ioctx_snap_lookup(rados_ioctx_t io, const char *name,
rados_snap_t *id)
{
+ tracepoint(librados, rados_ioctx_snap_lookup_enter, io, name);
librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io;
- return ctx->snap_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();
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<librados::RadosXattrsIter*>(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);
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<librados::RadosXattrsIter*>(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;
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;
}
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;
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();
else
*key = NULL;
}
- return 0;
+ int retval = 0;
+ tracepoint(librados, rados_objects_list_next_exit, 0, *entry, key);
+ return retval;
}
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;
}
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;
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,
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,
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,
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;
int tmp_exclusive;
std::list<librados::locker_t> lockers;
int r = ctx.list_lockers(oid, name_str, &tmp_exclusive, &tag_str, &lockers);
- if (r < 0)
+ 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;
*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;
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)
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,
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,
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,
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,
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,
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,
const size_t *lens,
size_t num)
{
+ tracepoint(librados, rados_write_op_omap_set_enter, write_op, num);
std::map<std::string, bufferlist> entries;
for (size_t i = 0; i < num; ++i) {
+ tracepoint(librados, rados_write_op_omap_set_entry, keys[i], vals[i], lens[i]);
bufferlist bl(lens[i]);
bl.append(vals[i], lens[i]);
entries[keys[i]] = bl;
}
((::ObjectOperation *)write_op)->omap_set(entries);
+ tracepoint(librados, rados_write_op_omap_set_exit);
}
extern "C" void rados_write_op_omap_rm_keys(rados_write_op_t write_op,
char const* const* keys,
size_t keys_len)
{
+ tracepoint(librados, rados_write_op_omap_rm_keys_enter, write_op, keys_len);
+ for(size_t i = 0; i < keys_len; i++) {
+ tracepoint(librados, rados_write_op_omap_rm_keys_entry, keys[i]);
+ }
std::set<std::string> to_remove(keys, keys + keys_len);
((::ObjectOperation *)write_op)->omap_rm_keys(to_remove);
+ tracepoint(librados, rados_write_op_omap_rm_keys_exit);
}
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,
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,
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,
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,
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,
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 {
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 {
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,
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 {
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,
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 : "";
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 {
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,
rados_omap_iter_t *iter,
int *prval)
{
+ tracepoint(librados, rados_read_op_omap_get_vals_by_keys_enter, read_op, keys, keys_len, iter, prval);
std::set<std::string> to_get(keys, keys + keys_len);
RadosOmapIter *omap_iter = new RadosOmapIter;
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,
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();
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,
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,
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;
}
--- /dev/null
+#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)
+ )
+)
projects / ceph.git / commitdiff