RepoMirrors/ceph
1
0
Fork 0
mirror of https://github.com/ceph/ceph synced 2025-03-11 02:39:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

librbd: Add missing tracepoints

Browse Source 
Signed-off-by: Adam Crume <adamcrume@gmail.com>
This commit is contained in:
Adam Crume 2014-09-03 11:48:33 -07:00
parent 3911354d61
commit 398ebc0b84
2 changed files with 1126 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

415
src/librbd/librbd.cc
View File

@ -157,16 +157,22 @@ namespace librbd {
IoCtx& c_ioctx, const char *c_name, uint64_t features,
int *c_order)
{
return librbd::clone(p_ioctx, p_name, p_snap_name, c_ioctx, c_name,
tracepoint(librbd, clone_enter, p_ioctx.get_pool_name().c_str(), p_ioctx.get_id(), p_name, p_snap_name, c_ioctx.get_pool_name().c_str(), c_ioctx.get_id(), c_name, features);
int r = librbd::clone(p_ioctx, p_name, p_snap_name, c_ioctx, c_name,
features, c_order, 0, 0);
tracepoint(librbd, clone_exit, r, *c_order);
return r;
}
int RBD::clone2(IoCtx& p_ioctx, const char *p_name, const char *p_snap_name,
IoCtx& c_ioctx, const char *c_name, uint64_t features,
int *c_order, uint64_t stripe_unit, int stripe_count)
{
return librbd::clone(p_ioctx, p_name, p_snap_name, c_ioctx, c_name,
tracepoint(librbd, clone2_enter, p_ioctx.get_pool_name().c_str(), p_ioctx.get_id(), p_name, p_snap_name, c_ioctx.get_pool_name().c_str(), c_ioctx.get_id(), c_name, features, stripe_unit, stripe_count);
int r = librbd::clone(p_ioctx, p_name, p_snap_name, c_ioctx, c_name,
features, c_order, stripe_unit, stripe_count);
tracepoint(librbd, clone_exit, r, *c_order);
return r;
}
int RBD::remove(IoCtx& io_ctx, const char *name)
@ -189,7 +195,14 @@ namespace librbd {
int RBD::list(IoCtx& io_ctx, vector<string>& names)
{
tracepoint(librbd, list_enter, io_ctx.get_pool_name().c_str(), io_ctx.get_id());
int r = librbd::list(io_ctx, names);
if (r >= 0) {
for (vector<string>::iterator itr = names.begin(), end = names.end(); itr != end; ++itr) {
tracepoint(librbd, list_entry, itr->c_str());
}
}
tracepoint(librbd, list_exit, r, r);
return r;
}
@ -274,57 +287,81 @@ namespace librbd {
int Image::stat(image_info_t& info, size_t infosize)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::info(ictx, info, infosize);
tracepoint(librbd, stat_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only);
int r = librbd::info(ictx, info, infosize);
tracepoint(librbd, stat_exit, r, &info);
return r;
}
int Image::old_format(uint8_t *old)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::get_old_format(ictx, old);
tracepoint(librbd, get_old_format_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only);
int r = librbd::get_old_format(ictx, old);
tracepoint(librbd, get_old_format_exit, r, *old);
return r;
}
int Image::size(uint64_t *size)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::get_size(ictx, size);
tracepoint(librbd, get_size_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only);
int r = librbd::get_size(ictx, size);
tracepoint(librbd, get_size_exit, r, *size);
return r;
}
int Image::features(uint64_t *features)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::get_features(ictx, features);
tracepoint(librbd, get_features_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only);
int r = librbd::get_features(ictx, features);
tracepoint(librbd, get_features_exit, r, *features);
return r;
}
uint64_t Image::get_stripe_unit() const
{
ImageCtx *ictx = (ImageCtx *)ctx;
return ictx->get_stripe_unit();
tracepoint(librbd, get_stripe_unit_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only);
uint64_t stripe_unit = ictx->get_stripe_unit();
tracepoint(librbd, get_stripe_unit_exit, 0, stripe_unit);
return stripe_unit;
}
uint64_t Image::get_stripe_count() const
{
ImageCtx *ictx = (ImageCtx *)ctx;
return ictx->get_stripe_count();
tracepoint(librbd, get_stripe_count_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only);
uint64_t stripe_count = ictx->get_stripe_count();
tracepoint(librbd, get_stripe_count_exit, 0, stripe_count);
return stripe_count;
}
int Image::overlap(uint64_t *overlap)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::get_overlap(ictx, overlap);
tracepoint(librbd, get_overlap_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only);
int r = librbd::get_overlap(ictx, overlap);
tracepoint(librbd, get_overlap_exit, r, *overlap);
return r;
}
int Image::parent_info(string *parent_pool_name, string *parent_name,
string *parent_snap_name)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::get_parent_info(ictx, parent_pool_name, parent_name,
tracepoint(librbd, get_parent_info_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only);
int r = librbd::get_parent_info(ictx, parent_pool_name, parent_name,
parent_snap_name);
tracepoint(librbd, get_parent_info_exit, r, parent_pool_name ? parent_pool_name->c_str() : NULL, parent_name ? parent_name->c_str() : NULL, parent_snap_name ? parent_snap_name->c_str() : NULL);
return r;
}
int Image::copy(IoCtx& dest_io_ctx, const char *destname)
{
ImageCtx *ictx = (ImageCtx *)ctx;
tracepoint(librbd, copy_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, destname);
tracepoint(librbd, copy_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, dest_io_ctx.get_pool_name().c_str(), dest_io_ctx.get_id(), destname);
librbd::NoOpProgressContext prog_ctx;
int r = librbd::copy(ictx, dest_io_ctx, destname, prog_ctx);
tracepoint(librbd, copy_exit, r);
@ -346,7 +383,7 @@ namespace librbd {
librbd::ProgressContext &pctx)
{
ImageCtx *ictx = (ImageCtx *)ctx;
tracepoint(librbd, copy_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, destname);
tracepoint(librbd, copy_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, dest_io_ctx.get_pool_name().c_str(), dest_io_ctx.get_id(), destname);
int r = librbd::copy(ictx, dest_io_ctx, destname, pctx);
tracepoint(librbd, copy_exit, r);
return r;
@ -365,101 +402,172 @@ namespace librbd {
int Image::flatten()
{
ImageCtx *ictx = (ImageCtx *)ctx;
tracepoint(librbd, flatten_enter, ictx, ictx->name.c_str(), ictx->id.c_str());
librbd::NoOpProgressContext prog_ctx;
return librbd::flatten(ictx, prog_ctx);
int r = librbd::flatten(ictx, prog_ctx);
tracepoint(librbd, flatten_exit, r);
return r;
}
int Image::flatten_with_progress(librbd::ProgressContext& prog_ctx)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::flatten(ictx, prog_ctx);
tracepoint(librbd, flatten_enter, ictx, ictx->name.c_str(), ictx->id.c_str());
int r = librbd::flatten(ictx, prog_ctx);
tracepoint(librbd, flatten_exit, r);
return r;
}
int Image::list_children(set<pair<string, string> > *children)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::list_children(ictx, *children);
tracepoint(librbd, list_children_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only);
int r = librbd::list_children(ictx, *children);
if (r >= 0) {
for (set<pair<string, string> >::const_iterator it = children->begin();
it != children->end(); ++it) {
tracepoint(librbd, list_children_entry, it->first.c_str(), it->second.c_str());
}
}
tracepoint(librbd, list_children_exit, r);
return r;
}
int Image::list_lockers(std::list<librbd::locker_t> *lockers,
bool *exclusive, string *tag)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::list_lockers(ictx, lockers, exclusive, tag);
tracepoint(librbd, list_lockers_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only);
int r = librbd::list_lockers(ictx, lockers, exclusive, tag);
if (r >= 0) {
for (std::list<librbd::locker_t>::const_iterator it = lockers->begin();
it != lockers->end(); ++it) {
tracepoint(librbd, list_lockers_entry, it->client.c_str(), it->cookie.c_str(), it->address.c_str());
}
}
tracepoint(librbd, list_lockers_exit, r);
return r;
}
int Image::lock_exclusive(const string& cookie)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::lock(ictx, true, cookie, "");
tracepoint(librbd, lock_exclusive_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, cookie.c_str());
int r = librbd::lock(ictx, true, cookie, "");
tracepoint(librbd, lock_exclusive_exit, r);
return r;
}
int Image::lock_shared(const string& cookie, const std::string& tag)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::lock(ictx, false, cookie, tag);
tracepoint(librbd, lock_shared_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, cookie.c_str(), tag.c_str());
int r = librbd::lock(ictx, false, cookie, tag);
tracepoint(librbd, lock_shared_exit, r);
return r;
}
int Image::unlock(const string& cookie)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::unlock(ictx, cookie);
tracepoint(librbd, unlock_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, cookie.c_str());
int r = librbd::unlock(ictx, cookie);
tracepoint(librbd, unlock_exit, r);
return r;
}
int Image::break_lock(const string& client, const string& cookie)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::break_lock(ictx, client, cookie);
tracepoint(librbd, break_lock_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, client.c_str(), cookie.c_str());
int r = librbd::break_lock(ictx, client, cookie);
tracepoint(librbd, break_lock_exit, r);
return r;
}
int Image::snap_create(const char *snap_name)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::snap_create(ictx, snap_name);
tracepoint(librbd, snap_create_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name);
int r = librbd::snap_create(ictx, snap_name);
tracepoint(librbd, snap_create_exit, r);
return r;
}
int Image::snap_remove(const char *snap_name)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::snap_remove(ictx, snap_name);
tracepoint(librbd, snap_remove_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name);
int r = librbd::snap_remove(ictx, snap_name);
tracepoint(librbd, snap_remove_exit, r);
return r;
}
int Image::snap_rollback(const char *snap_name)
{
ImageCtx *ictx = (ImageCtx *)ctx;
tracepoint(librbd, snap_rollback_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name);
librbd::NoOpProgressContext prog_ctx;
return librbd::snap_rollback(ictx, snap_name, prog_ctx);
int r = librbd::snap_rollback(ictx, snap_name, prog_ctx);
tracepoint(librbd, snap_rollback_exit, r);
return r;
}
int Image::snap_rollback_with_progress(const char *snap_name,
ProgressContext& prog_ctx)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::snap_rollback(ictx, snap_name, prog_ctx);
tracepoint(librbd, snap_rollback_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name);
int r = librbd::snap_rollback(ictx, snap_name, prog_ctx);
tracepoint(librbd, snap_rollback_exit, r);
return r;
}
int Image::snap_protect(const char *snap_name)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::snap_protect(ictx, snap_name);
tracepoint(librbd, snap_protect_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name);
int r = librbd::snap_protect(ictx, snap_name);
tracepoint(librbd, snap_protect_exit, r);
return r;
}
int Image::snap_unprotect(const char *snap_name)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::snap_unprotect(ictx, snap_name);
tracepoint(librbd, snap_unprotect_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name);
int r = librbd::snap_unprotect(ictx, snap_name);
tracepoint(librbd, snap_unprotect_exit, r);
return r;
}
int Image::snap_is_protected(const char *snap_name, bool *is_protected)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::snap_is_protected(ictx, snap_name, is_protected);
tracepoint(librbd, snap_is_protected_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name);
int r = librbd::snap_is_protected(ictx, snap_name, is_protected);
tracepoint(librbd, snap_is_protected_exit, r, *is_protected ? 1 : 0);
return r;
}
int Image::snap_list(vector<librbd::snap_info_t>& snaps)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::snap_list(ictx, snaps);
tracepoint(librbd, snap_list_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, &snaps);
int r = librbd::snap_list(ictx, snaps);
if (r >= 0) {
for (int i = 0, n = snaps.size(); i < n; i++) {
tracepoint(librbd, snap_list_entry, snaps[i].id, snaps[i].size, snaps[i].name.c_str());
}
}
tracepoint(librbd, snap_list_exit, r, snaps.size());
if (r >= 0) {
// A little ugly, but the C++ API doesn't need a Image::snap_list_end,
// and we want the tracepoints to mirror the C API
tracepoint(librbd, snap_list_end_enter, &snaps);
tracepoint(librbd, snap_list_end_exit);
}
return r;
}
bool Image::snap_exists(const char *snap_name)
@ -471,7 +579,10 @@ namespace librbd {
int Image::snap_set(const char *snap_name)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::snap_set(ictx, snap_name);
tracepoint(librbd, snap_set_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name);
int r = librbd::snap_set(ictx, snap_name);
tracepoint(librbd, snap_set_exit, r);
return r;
}
ssize_t Image::read(uint64_t ofs, size_t len, bufferlist& bl)
@ -490,7 +601,10 @@ namespace librbd {
void *arg)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::read_iterate(ictx, ofs, len, cb, arg);
tracepoint(librbd, read_iterate_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, ofs, len);
int64_t r = librbd::read_iterate(ictx, ofs, len, cb, arg);
tracepoint(librbd, read_iterate_exit, r);
return r;
}
int Image::read_iterate2(uint64_t ofs, uint64_t len,
@ -498,9 +612,11 @@ namespace librbd {
void *arg)
{
ImageCtx *ictx = (ImageCtx *)ctx;
tracepoint(librbd, read_iterate2_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, ofs, len);
int64_t r = librbd::read_iterate(ictx, ofs, len, cb, arg);
if (r > 0)
r = 0;
tracepoint(librbd, read_iterate2_exit, r);
return (int)r;
}
@ -510,7 +626,10 @@ namespace librbd {
void *arg)
{
ImageCtx *ictx = (ImageCtx *)ctx;
return librbd::diff_iterate(ictx, fromsnapname, ofs, len, cb, arg);
tracepoint(librbd, diff_iterate_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, fromsnapname, ofs, len);
int r = librbd::diff_iterate(ictx, fromsnapname, ofs, len, cb, arg);
tracepoint(librbd, diff_iterate_exit, r);
return r;
}
ssize_t Image::write(uint64_t ofs, size_t len, bufferlist& bl)
@ -615,13 +734,18 @@ extern "C" int rbd_list(rados_ioctx_t p, char *names, size_t *size)
{
librados::IoCtx io_ctx;
librados::IoCtx::from_rados_ioctx_t(p, io_ctx);
tracepoint(librbd, list_enter, io_ctx.get_pool_name().c_str(), io_ctx.get_id());
vector<string> cpp_names;
int r = librbd::list(io_ctx, cpp_names);
if (r == -ENOENT)
if (r == -ENOENT) {
tracepoint(librbd, list_exit, 0, *size);
return 0;
}
if (r < 0)
if (r < 0) {
tracepoint(librbd, list_exit, r, *size);
return r;
}
size_t expected_size = 0;
@ -630,6 +754,7 @@ extern "C" int rbd_list(rados_ioctx_t p, char *names, size_t *size)
}
if (*size < expected_size) {
*size = expected_size;
tracepoint(librbd, list_exit, -ERANGE, *size);
return -ERANGE;
}
@ -637,9 +762,12 @@ extern "C" int rbd_list(rados_ioctx_t p, char *names, size_t *size)
return -EINVAL;
for (int i = 0; i < (int)cpp_names.size(); i++) {
strcpy(names, cpp_names[i].c_str());
const char* name = cpp_names[i].c_str();
tracepoint(librbd, list_entry, name);
strcpy(names, name);
names += strlen(names) + 1;
}
tracepoint(librbd, list_exit, (int)expected_size, *size);
return (int)expected_size;
}
@ -686,8 +814,11 @@ extern "C" int rbd_clone(rados_ioctx_t p_ioctx, const char *p_name,
librados::IoCtx p_ioc, c_ioc;
librados::IoCtx::from_rados_ioctx_t(p_ioctx, p_ioc);
librados::IoCtx::from_rados_ioctx_t(c_ioctx, c_ioc);
return librbd::clone(p_ioc, p_name, p_snap_name, c_ioc, c_name,
tracepoint(librbd, clone_enter, p_ioc.get_pool_name().c_str(), p_ioc.get_id(), p_name, p_snap_name, c_ioc.get_pool_name().c_str(), c_ioc.get_id(), c_name, features);
int r = librbd::clone(p_ioc, p_name, p_snap_name, c_ioc, c_name,
features, c_order, 0, 0);
tracepoint(librbd, clone_exit, r, *c_order);
return r;
}
extern "C" int rbd_clone2(rados_ioctx_t p_ioctx, const char *p_name,
@ -698,8 +829,11 @@ extern "C" int rbd_clone2(rados_ioctx_t p_ioctx, const char *p_name,
librados::IoCtx p_ioc, c_ioc;
librados::IoCtx::from_rados_ioctx_t(p_ioctx, p_ioc);
librados::IoCtx::from_rados_ioctx_t(c_ioctx, c_ioc);
return librbd::clone(p_ioc, p_name, p_snap_name, c_ioc, c_name,
tracepoint(librbd, clone2_enter, p_ioc.get_pool_name().c_str(), p_ioc.get_id(), p_name, p_snap_name, c_ioc.get_pool_name().c_str(), c_ioc.get_id(), c_name, features, stripe_unit, stripe_count);
int r = librbd::clone(p_ioc, p_name, p_snap_name, c_ioc, c_name,
features, c_order, stripe_unit, stripe_count);
tracepoint(librbd, clone2_exit, r, *c_order);
return r;
}
extern "C" int rbd_remove(rados_ioctx_t p, const char *name)
@ -731,16 +865,22 @@ extern "C" int rbd_copy(rbd_image_t image, rados_ioctx_t dest_p,
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
librados::IoCtx dest_io_ctx;
librados::IoCtx::from_rados_ioctx_t(dest_p, dest_io_ctx);
tracepoint(librbd, copy_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, dest_io_ctx.get_pool_name().c_str(), dest_io_ctx.get_id(), destname);
librbd::NoOpProgressContext prog_ctx;
return librbd::copy(ictx, dest_io_ctx, destname, prog_ctx);
int r = librbd::copy(ictx, dest_io_ctx, destname, prog_ctx);
tracepoint(librbd, copy_exit, r);
return r;
}
extern "C" int rbd_copy2(rbd_image_t srcp, rbd_image_t destp)
{
librbd::ImageCtx *src = (librbd::ImageCtx *)srcp;
librbd::ImageCtx *dest = (librbd::ImageCtx *)destp;
tracepoint(librbd, copy2_enter, src, src->name.c_str(), src->snap_name.c_str(), src->read_only, dest, dest->name.c_str(), dest->snap_name.c_str(), dest->read_only);
librbd::NoOpProgressContext prog_ctx;
return librbd::copy(src, dest, prog_ctx);
int r = librbd::copy(src, dest, prog_ctx);
tracepoint(librbd, copy2_exit, r);
return r;
}
extern "C" int rbd_copy_with_progress(rbd_image_t image, rados_ioctx_t dest_p,
@ -750,8 +890,10 @@ extern "C" int rbd_copy_with_progress(rbd_image_t image, rados_ioctx_t dest_p,
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
librados::IoCtx dest_io_ctx;
librados::IoCtx::from_rados_ioctx_t(dest_p, dest_io_ctx);
tracepoint(librbd, copy_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, dest_io_ctx.get_pool_name().c_str(), dest_io_ctx.get_id(), destname);
librbd::CProgressContext prog_ctx(fn, data);
int ret = librbd::copy(ictx, dest_io_ctx, destname, prog_ctx);
tracepoint(librbd, copy_exit, ret);
return ret;
}
@ -760,24 +902,32 @@ extern "C" int rbd_copy_with_progress2(rbd_image_t srcp, rbd_image_t destp,
{
librbd::ImageCtx *src = (librbd::ImageCtx *)srcp;
librbd::ImageCtx *dest = (librbd::ImageCtx *)destp;
tracepoint(librbd, copy2_enter, src, src->name.c_str(), src->snap_name.c_str(), src->read_only, dest, dest->name.c_str(), dest->snap_name.c_str(), dest->read_only);
librbd::CProgressContext prog_ctx(fn, data);
int ret = librbd::copy(src, dest, prog_ctx);
tracepoint(librbd, copy2_exit, ret);
return ret;
}
extern "C" int rbd_flatten(rbd_image_t image)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
tracepoint(librbd, flatten_enter, ictx, ictx->name.c_str(), ictx->id.c_str());
librbd::NoOpProgressContext prog_ctx;
return librbd::flatten(ictx, prog_ctx);
int r = librbd::flatten(ictx, prog_ctx);
tracepoint(librbd, flatten_exit, r);
return r;
}
extern "C" int rbd_flatten_with_progress(rbd_image_t image,
librbd_progress_fn_t cb, void *cbdata)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
tracepoint(librbd, flatten_enter, ictx, ictx->name.c_str(), ictx->id.c_str());
librbd::CProgressContext prog_ctx(cb, cbdata);
return librbd::flatten(ictx, prog_ctx);
int r = librbd::flatten(ictx, prog_ctx);
tracepoint(librbd, flatten_exit, r);
return r;
}
extern "C" int rbd_rename(rados_ioctx_t src_p, const char *srcname,
@ -855,45 +1005,64 @@ extern "C" int rbd_stat(rbd_image_t image, rbd_image_info_t *info,
size_t infosize)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
return librbd::info(ictx, *info, infosize);
tracepoint(librbd, stat_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only);
int r = librbd::info(ictx, *info, infosize);
tracepoint(librbd, stat_exit, r, info);
return r;
}
extern "C" int rbd_get_old_format(rbd_image_t image, uint8_t *old)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
return librbd::get_old_format(ictx, old);
tracepoint(librbd, get_old_format_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only);
int r = librbd::get_old_format(ictx, old);
tracepoint(librbd, get_old_format_exit, r, *old);
return r;
}
extern "C" int rbd_get_size(rbd_image_t image, uint64_t *size)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
return librbd::get_size(ictx, size);
tracepoint(librbd, get_size_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only);
int r = librbd::get_size(ictx, size);
tracepoint(librbd, get_size_exit, r, *size);
return r;
}
extern "C" int rbd_get_features(rbd_image_t image, uint64_t *features)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
return librbd::get_features(ictx, features);
tracepoint(librbd, get_features_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only);
int r = librbd::get_features(ictx, features);
tracepoint(librbd, get_features_exit, r, *features);
return r;
}
extern "C" int rbd_get_stripe_unit(rbd_image_t image, uint64_t *stripe_unit)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
tracepoint(librbd, get_stripe_unit_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only);
*stripe_unit = ictx->get_stripe_unit();
tracepoint(librbd, get_stripe_unit_exit, 0, *stripe_unit);
return 0;
}
extern "C" int rbd_get_stripe_count(rbd_image_t image, uint64_t *stripe_count)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
tracepoint(librbd, get_stripe_count_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only);
*stripe_count = ictx->get_stripe_count();
tracepoint(librbd, get_stripe_count_exit, 0, *stripe_count);
return 0;
}
extern "C" int rbd_get_overlap(rbd_image_t image, uint64_t *overlap)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
return librbd::get_overlap(ictx, overlap);
tracepoint(librbd, get_overlap_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only);
int r = librbd::get_overlap(ictx, overlap);
tracepoint(librbd, get_overlap_exit, r, *overlap);
return r;
}
extern "C" int rbd_get_parent_info(rbd_image_t image,
@ -901,31 +1070,41 @@ extern "C" int rbd_get_parent_info(rbd_image_t image,
size_t pnamelen, char *parent_snap_name, size_t psnap_namelen)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
tracepoint(librbd, get_parent_info_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only);
string p_pool_name, p_name, p_snap_name;
int r = librbd::get_parent_info(ictx, &p_pool_name, &p_name, &p_snap_name);
if (r < 0)
if (r < 0) {
tracepoint(librbd, get_parent_info_exit, r, NULL, NULL, NULL);
return r;
}
if (parent_pool_name) {
if (p_pool_name.length() + 1 > ppool_namelen)
if (p_pool_name.length() + 1 > ppool_namelen) {
tracepoint(librbd, get_parent_info_exit, -ERANGE, NULL, NULL, NULL);
return -ERANGE;
}
strcpy(parent_pool_name, p_pool_name.c_str());
}
if (parent_name) {
if (p_name.length() + 1 > pnamelen)
if (p_name.length() + 1 > pnamelen) {
tracepoint(librbd, get_parent_info_exit, -ERANGE, NULL, NULL, NULL);
return -ERANGE;
}
strcpy(parent_name, p_name.c_str());
}
if (parent_snap_name) {
if (p_snap_name.length() + 1 > psnap_namelen)
if (p_snap_name.length() + 1 > psnap_namelen) {
tracepoint(librbd, get_parent_info_exit, -ERANGE, NULL, NULL, NULL);
return -ERANGE;
}
strcpy(parent_snap_name, p_snap_name.c_str());
}
tracepoint(librbd, get_parent_info_exit, 0, parent_pool_name, parent_name, parent_snap_name);
return 0;
}
@ -933,20 +1112,29 @@ extern "C" int rbd_get_parent_info(rbd_image_t image,
extern "C" int rbd_snap_create(rbd_image_t image, const char *snap_name)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
return librbd::snap_create(ictx, snap_name);
tracepoint(librbd, snap_create_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name);
int r = librbd::snap_create(ictx, snap_name);
tracepoint(librbd, snap_create_exit, r);
return r;
}
extern "C" int rbd_snap_remove(rbd_image_t image, const char *snap_name)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
return librbd::snap_remove(ictx, snap_name);
tracepoint(librbd, snap_remove_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name);
int r = librbd::snap_remove(ictx, snap_name);
tracepoint(librbd, snap_remove_exit, r);
return r;
}
extern "C" int rbd_snap_rollback(rbd_image_t image, const char *snap_name)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
tracepoint(librbd, snap_rollback_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name);
librbd::NoOpProgressContext prog_ctx;
return librbd::snap_rollback(ictx, snap_name, prog_ctx);
int r = librbd::snap_rollback(ictx, snap_name, prog_ctx);
tracepoint(librbd, snap_rollback_exit, r);
return r;
}
extern "C" int rbd_snap_rollback_with_progress(rbd_image_t image,
@ -955,8 +1143,11 @@ extern "C" int rbd_snap_rollback_with_progress(rbd_image_t image,
void *cbdata)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
tracepoint(librbd, snap_rollback_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name);
librbd::CProgressContext prog_ctx(cb, cbdata);
return librbd::snap_rollback(ictx, snap_name, prog_ctx);
int r = librbd::snap_rollback(ictx, snap_name, prog_ctx);
tracepoint(librbd, snap_rollback_exit, r);
return r;
}
extern "C" int rbd_snap_list(rbd_image_t image, rbd_snap_info_t *snaps,
@ -964,15 +1155,23 @@ extern "C" int rbd_snap_list(rbd_image_t image, rbd_snap_info_t *snaps,
{
vector<librbd::snap_info_t> cpp_snaps;
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
tracepoint(librbd, snap_list_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snaps);
int r = librbd::snap_list(ictx, cpp_snaps);
if (r == -ENOENT)
if (r == -ENOENT) {
tracepoint(librbd, snap_list_exit, 0, *max_snaps);
return 0;
if (r < 0)
}
if (r < 0) {
tracepoint(librbd, snap_list_exit, r, *max_snaps);
return r;
if (!max_snaps)
}
if (!max_snaps) {
tracepoint(librbd, snap_list_exit, -EINVAL, *max_snaps);
return -EINVAL;
}
if (*max_snaps < (int)cpp_snaps.size() + 1) {
*max_snaps = (int)cpp_snaps.size() + 1;
tracepoint(librbd, snap_list_exit, -ERANGE, *max_snaps);
return -ERANGE;
}
@ -985,52 +1184,71 @@ extern "C" int rbd_snap_list(rbd_image_t image, rbd_snap_info_t *snaps,
if (!snaps[i].name) {
for (int j = 0; j < i; j++)
free((void *)snaps[j].name);
tracepoint(librbd, snap_list_exit, -ENOMEM, *max_snaps);
return -ENOMEM;
}
tracepoint(librbd, snap_list_entry, snaps[i].id, snaps[i].size, snaps[i].name);
}
snaps[i].id = 0;
snaps[i].size = 0;
snaps[i].name = NULL;
return (int)cpp_snaps.size();
r = (int)cpp_snaps.size();
tracepoint(librbd, snap_list_exit, r, *max_snaps);
return r;
}
extern "C" void rbd_snap_list_end(rbd_snap_info_t *snaps)
{
tracepoint(librbd, snap_list_end_enter, snaps);
while (snaps->name) {
free((void *)snaps->name);
snaps++;
}
tracepoint(librbd, snap_list_end_exit);
}
extern "C" int rbd_snap_protect(rbd_image_t image, const char *snap_name)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
return librbd::snap_protect(ictx, snap_name);
tracepoint(librbd, snap_protect_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name);
int r = librbd::snap_protect(ictx, snap_name);
tracepoint(librbd, snap_protect_exit, r);
return r;
}
extern "C" int rbd_snap_unprotect(rbd_image_t image, const char *snap_name)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
return librbd::snap_unprotect(ictx, snap_name);
tracepoint(librbd, snap_unprotect_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name);
int r = librbd::snap_unprotect(ictx, snap_name);
tracepoint(librbd, snap_unprotect_exit, r);
return r;
}
extern "C" int rbd_snap_is_protected(rbd_image_t image, const char *snap_name,
int *is_protected)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
tracepoint(librbd, snap_is_protected_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name);
bool protected_snap;
int r = librbd::snap_is_protected(ictx, snap_name, &protected_snap);
if (r < 0)
if (r < 0) {
tracepoint(librbd, snap_is_protected_exit, r, *is_protected ? 1 : 0);
return r;
}
*is_protected = protected_snap ? 1 : 0;
tracepoint(librbd, snap_is_protected_exit, 0, *is_protected ? 1 : 0);
return 0;
}
extern "C" int rbd_snap_set(rbd_image_t image, const char *snap_name)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
return librbd::snap_set(ictx, snap_name);
tracepoint(librbd, snap_set_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name);
int r = librbd::snap_set(ictx, snap_name);
tracepoint(librbd, snap_set_exit, r);
return r;
}
extern "C" ssize_t rbd_list_children(rbd_image_t image, char *pools,
@ -1038,11 +1256,14 @@ extern "C" ssize_t rbd_list_children(rbd_image_t image, char *pools,
size_t *images_len)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
tracepoint(librbd, list_children_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only);
set<pair<string, string> > image_set;
int r = librbd::list_children(ictx, image_set);
if (r < 0)
if (r < 0) {
tracepoint(librbd, list_children_exit, r);
return r;
}
size_t pools_total = 0;
size_t images_total = 0;
@ -1059,20 +1280,27 @@ extern "C" ssize_t rbd_list_children(rbd_image_t image, char *pools,
too_short = true;
*pools_len = pools_total;
*images_len = images_total;
if (too_short)
if (too_short) {
tracepoint(librbd, list_children_exit, -ERANGE);
return -ERANGE;
}
char *pools_p = pools;
char *images_p = images;
for (set<pair<string, string> >::const_iterator it = image_set.begin();
it != image_set.end(); ++it) {
strcpy(pools_p, it->first.c_str());
const char* pool = it->first.c_str();
strcpy(pools_p, pool);
pools_p += it->first.length() + 1;
strcpy(images_p, it->second.c_str());
const char* image = it->second.c_str();
strcpy(images_p, image);
images_p += it->second.length() + 1;
tracepoint(librbd, list_children_entry, pool, image);
}
return image_set.size();
ssize_t ret = image_set.size();
tracepoint(librbd, list_children_exit, ret);
return ret;
}
extern "C" ssize_t rbd_list_lockers(rbd_image_t image, int *exclusive,
@ -1082,13 +1310,16 @@ extern "C" ssize_t rbd_list_lockers(rbd_image_t image, int *exclusive,
char *addrs, size_t *addrs_len)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
tracepoint(librbd, list_lockers_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only);
std::list<librbd::locker_t> lockers;
bool exclusive_bool;
string tag_str;
int r = list_lockers(ictx, &lockers, &exclusive_bool, &tag_str);
if (r < 0)
if (r < 0) {
tracepoint(librbd, list_lockers_exit, r);
return r;
}
ldout(ictx->cct, 20) << "list_lockers r = " << r << " lockers.size() = " << lockers.size() << dendl;
@ -1111,8 +1342,10 @@ extern "C" ssize_t rbd_list_lockers(rbd_image_t image, int *exclusive,
*cookies_len = cookies_total;
*addrs_len = addrs_total;
*tag_len = tag_str.length() + 1;
if (too_short)
if (too_short) {
tracepoint(librbd, list_lockers_exit, -ERANGE);
return -ERANGE;
}
strcpy(tag, tag_str.c_str());
char *clients_p = clients;
@ -1120,41 +1353,59 @@ extern "C" ssize_t rbd_list_lockers(rbd_image_t image, int *exclusive,
char *addrs_p = addrs;
for (list<librbd::locker_t>::const_iterator it = lockers.begin();
it != lockers.end(); ++it) {
strcpy(clients_p, it->client.c_str());
const char* client = it->client.c_str();
strcpy(clients_p, client);
clients_p += it->client.length() + 1;
strcpy(cookies_p, it->cookie.c_str());
const char* cookie = it->cookie.c_str();
strcpy(cookies_p, cookie);
cookies_p += it->cookie.length() + 1;
strcpy(addrs_p, it->address.c_str());
const char* address = it->address.c_str();
strcpy(addrs_p, address);
addrs_p += it->address.length() + 1;
tracepoint(librbd, list_lockers_entry, client, cookie, address);
}
return lockers.size();
ssize_t ret = lockers.size();
tracepoint(librbd, list_lockers_exit, ret);
return ret;
}
extern "C" int rbd_lock_exclusive(rbd_image_t image, const char *cookie)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
return librbd::lock(ictx, true, cookie ? cookie : "", "");
tracepoint(librbd, lock_exclusive_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, cookie);
int r = librbd::lock(ictx, true, cookie ? cookie : "", "");
tracepoint(librbd, lock_exclusive_exit, r);
return r;
}
extern "C" int rbd_lock_shared(rbd_image_t image, const char *cookie,
const char *tag)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
return librbd::lock(ictx, false, cookie ? cookie : "", tag ? tag : "");
tracepoint(librbd, lock_shared_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, cookie, tag);
int r = librbd::lock(ictx, false, cookie ? cookie : "", tag ? tag : "");
tracepoint(librbd, lock_shared_exit, r);
return r;
}
extern "C" int rbd_unlock(rbd_image_t image, const char *cookie)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
return librbd::unlock(ictx, cookie ? cookie : "");
tracepoint(librbd, unlock_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, cookie);
int r = librbd::unlock(ictx, cookie ? cookie : "");
tracepoint(librbd, unlock_exit, r);
return r;
}
extern "C" int rbd_break_lock(rbd_image_t image, const char *client,
const char *cookie)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
return librbd::break_lock(ictx, client, cookie ? cookie : "");
tracepoint(librbd, break_lock_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, client, cookie);
int r = librbd::break_lock(ictx, client, cookie ? cookie : "");
tracepoint(librbd, break_lock_exit, r);
return r;
}
/* I/O */
@ -1173,7 +1424,10 @@ extern "C" int64_t rbd_read_iterate(rbd_image_t image, uint64_t ofs, size_t len,
void *arg)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
return librbd::read_iterate(ictx, ofs, len, cb, arg);
tracepoint(librbd, read_iterate_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, ofs, len);
int64_t r = librbd::read_iterate(ictx, ofs, len, cb, arg);
tracepoint(librbd, read_iterate_exit, r);
return r;
}
extern "C" int rbd_read_iterate2(rbd_image_t image, uint64_t ofs, uint64_t len,
@ -1181,9 +1435,11 @@ extern "C" int rbd_read_iterate2(rbd_image_t image, uint64_t ofs, uint64_t len,
void *arg)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
tracepoint(librbd, read_iterate2_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, ofs, len);
int64_t r = librbd::read_iterate(ictx, ofs, len, cb, arg);
if (r > 0)
r = 0;
tracepoint(librbd, read_iterate2_exit, r);
return (int)r;
}
@ -1194,7 +1450,10 @@ extern "C" int rbd_diff_iterate(rbd_image_t image,
void *arg)
{
librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
return librbd::diff_iterate(ictx, fromsnapname, ofs, len, cb, arg);
tracepoint(librbd, diff_iterate_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, fromsnapname, ofs, len);
int r = librbd::diff_iterate(ictx, fromsnapname, ofs, len, cb, arg);
tracepoint(librbd, diff_iterate_exit, r);
return r;
}
extern "C" ssize_t rbd_write(rbd_image_t image, uint64_t ofs, size_t len,

789
src/tracing/librbd.tp
View File

@ -27,6 +27,58 @@ TRACEPOINT_EVENT(librbd, read_exit,
)
)
TRACEPOINT_EVENT(librbd, read_iterate_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only,
uint64_t, offset,
uint64_t, length),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
ctf_integer(uint64_t, offset, offset)
ctf_integer(uint64_t, length, length)
)
)
TRACEPOINT_EVENT(librbd, read_iterate_exit,
TP_ARGS(
int64_t, retval),
TP_FIELDS(
ctf_integer(int64_t, retval, retval)
)
)
TRACEPOINT_EVENT(librbd, read_iterate2_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only,
uint64_t, offset,
uint64_t, length),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
ctf_integer(uint64_t, offset, offset)
ctf_integer(uint64_t, length, length)
)
)
TRACEPOINT_EVENT(librbd, read_iterate2_exit,
TP_ARGS(
int, retval),
TP_FIELDS(
ctf_integer(int, retval, retval)
)
)
TRACEPOINT_EVENT(librbd, write_enter,
TP_ARGS(
void*, imagectx,
@ -95,6 +147,34 @@ TRACEPOINT_EVENT(librbd, close_image_exit,
TP_FIELDS()
)
TRACEPOINT_EVENT(librbd, list_enter,
TP_ARGS(
const char*, pool_name,
int64_t, id),
TP_FIELDS(
ctf_string(pool_name, pool_name)
ctf_integer(int64_t, id, id)
)
)
TRACEPOINT_EVENT(librbd, list_entry,
TP_ARGS(
const char*, name),
TP_FIELDS(
ctf_string(name, name)
)
)
TRACEPOINT_EVENT(librbd, list_exit,
TP_ARGS(
int, retval,
int, size),
TP_FIELDS(
ctf_integer(int, retval, retval)
ctf_integer(size_t, size, size)
)
)
TRACEPOINT_EVENT(librbd, create_enter,
TP_ARGS(
const char*, pool_name,
@ -362,12 +442,16 @@ TRACEPOINT_EVENT(librbd, copy_enter,
const char*, src_name,
const char*, src_snap_name,
char, src_read_only,
const char*, dst_pool_name,
uint64_t, dst_id,
const char*, dst_name),
TP_FIELDS(
ctf_integer_hex(void*, src_imagectx, src_imagectx)
ctf_string(src_name, src_name)
ctf_string(src_snap_name, src_snap_name)
ctf_integer(char, src_read_only, src_read_only)
ctf_string(dst_pool_name, dst_pool_name)
ctf_integer(uint64_t, dst_id, dst_id)
ctf_string(dst_name, dst_name)
)
)
@ -544,3 +628,708 @@ TRACEPOINT_EVENT(librbd, aio_complete_exit,
TP_ARGS(),
TP_FIELDS()
)
TRACEPOINT_EVENT(librbd, clone_enter,
TP_ARGS(
const char*, parent_pool_name,
uint64_t, parent_id,
const char*, parent_name,
const char*, parent_snap_name,
const char*, child_pool_name,
uint64_t, child_id,
const char*, child_name,
uint64_t, features),
TP_FIELDS(
ctf_string(parent_pool_name, parent_pool_name)
ctf_integer(uint64_t, parent_id, parent_id)
ctf_string(parent_name, parent_name)
ctf_string(parent_snap_name, parent_snap_name)
ctf_string(child_pool_name, child_pool_name)
ctf_integer(uint64_t, child_id, child_id)
ctf_string(child_name, child_name)
ctf_integer(uint64_t, features, features)
)
)
TRACEPOINT_EVENT(librbd, clone_exit,
TP_ARGS(
int, retval,
int, order),
TP_FIELDS(
ctf_integer(int, retval, retval)
ctf_integer(int, order, order)
)
)
TRACEPOINT_EVENT(librbd, clone2_enter,
TP_ARGS(
const char*, parent_pool_name,
uint64_t, parent_id,
const char*, parent_name,
const char*, parent_snap_name,
const char*, child_pool_name,
uint64_t, child_id,
const char*, child_name,
uint64_t, features,
uint64_t, stripe_unit,
int, stripe_count),
TP_FIELDS(
ctf_string(parent_pool_name, parent_pool_name)
ctf_integer(uint64_t, parent_id, parent_id)
ctf_string(parent_name, parent_name)
ctf_string(parent_snap_name, parent_snap_name)
ctf_string(child_pool_name, child_pool_name)
ctf_integer(uint64_t, child_id, child_id)
ctf_string(child_name, child_name)
ctf_integer(uint64_t, features, features)
ctf_integer(uint64_t, stripe_unit, stripe_unit)
ctf_integer(int, stripe_count, stripe_count)
)
)
TRACEPOINT_EVENT(librbd, clone2_exit,
TP_ARGS(
int, retval,
int, order),
TP_FIELDS(
ctf_integer(int, retval, retval)
ctf_integer(int, order, order)
)
)
TRACEPOINT_EVENT(librbd, flatten_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, id),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(id, id)
)
)
TRACEPOINT_EVENT(librbd, flatten_exit,
TP_ARGS(
int, retval),
TP_FIELDS(
ctf_integer(int, retval, retval)
)
)
TRACEPOINT_EVENT(librbd, snap_create_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only,
const char*, create_snap_name),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
ctf_string(create_snap_name, create_snap_name)
)
)
TRACEPOINT_EVENT(librbd, snap_create_exit,
TP_ARGS(
int, retval),
TP_FIELDS(
ctf_integer(int, retval, retval)
)
)
TRACEPOINT_EVENT(librbd, snap_remove_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only,
const char*, remove_snap_name),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
ctf_string(remove_snap_name, remove_snap_name)
)
)
TRACEPOINT_EVENT(librbd, snap_remove_exit,
TP_ARGS(
int, retval),
TP_FIELDS(
ctf_integer(int, retval, retval)
)
)
TRACEPOINT_EVENT(librbd, snap_rollback_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only,
const char*, rollback_snap_name),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
ctf_string(rollback_snap_name, rollback_snap_name)
)
)
TRACEPOINT_EVENT(librbd, snap_rollback_exit,
TP_ARGS(
int, retval),
TP_FIELDS(
ctf_integer(int, retval, retval)
)
)
TRACEPOINT_EVENT(librbd, snap_list_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only,
void*, snaps),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
ctf_integer_hex(void*, snaps, snaps)
)
)
TRACEPOINT_EVENT(librbd, snap_list_entry,
TP_ARGS(
uint64_t, id,
uint64_t, size,
const char*, name),
TP_FIELDS(
ctf_integer(uint64_t, id, id)
ctf_integer(uint64_t, size, size)
ctf_string(name, name)
)
)
TRACEPOINT_EVENT(librbd, snap_list_exit,
TP_ARGS(
int, retval,
int, max_snaps),
TP_FIELDS(
ctf_integer(int, retval, retval)
ctf_integer(int, max_snaps, max_snaps)
)
)
TRACEPOINT_EVENT(librbd, snap_list_end_enter,
TP_ARGS(
void*, snaps),
TP_FIELDS(
ctf_integer_hex(void*, snaps, snaps)
)
)
TRACEPOINT_EVENT(librbd, snap_list_end_exit,
TP_ARGS(),
TP_FIELDS()
)
TRACEPOINT_EVENT(librbd, snap_protect_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only,
const char*, protect_snap_name),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
ctf_string(protect_snap_name, protect_snap_name)
)
)
TRACEPOINT_EVENT(librbd, snap_protect_exit,
TP_ARGS(
int, retval),
TP_FIELDS(
ctf_integer(int, retval, retval)
)
)
TRACEPOINT_EVENT(librbd, snap_unprotect_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only,
const char*, unprotect_snap_name),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
ctf_string(unprotect_snap_name, unprotect_snap_name)
)
)
TRACEPOINT_EVENT(librbd, snap_unprotect_exit,
TP_ARGS(
int, retval),
TP_FIELDS(
ctf_integer(int, retval, retval)
)
)
TRACEPOINT_EVENT(librbd, snap_is_protected_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only,
const char*, is_protected_snap_name),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
ctf_string(is_protected_snap_name, is_protected_snap_name)
)
)
TRACEPOINT_EVENT(librbd, snap_is_protected_exit,
TP_ARGS(
int, retval,
int, is_protected),
TP_FIELDS(
ctf_integer(int, retval, retval)
ctf_integer(int, is_protected, is_protected)
)
)
TRACEPOINT_EVENT(librbd, snap_set_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only,
const char*, set_snap_name),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
ctf_string(set_snap_name, set_snap_name)
)
)
TRACEPOINT_EVENT(librbd, snap_set_exit,
TP_ARGS(
int, retval),
TP_FIELDS(
ctf_integer(int, retval, retval)
)
)
TRACEPOINT_EVENT(librbd, list_children_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
)
)
TRACEPOINT_EVENT(librbd, list_children_entry,
TP_ARGS(
const char*, pool,
const char*, image),
TP_FIELDS(
ctf_string(pool, pool)
ctf_string(image, image)
)
)
TRACEPOINT_EVENT(librbd, list_children_exit,
TP_ARGS(
ssize_t, retval),
TP_FIELDS(
ctf_integer(ssize_t, retval, retval)
)
)
TRACEPOINT_EVENT(librbd, list_lockers_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
)
)
TRACEPOINT_EVENT(librbd, list_lockers_entry,
TP_ARGS(
const char*, client,
const char*, cookie,
const char*, address),
TP_FIELDS(
ctf_string(client, client)
ctf_string(cookie, cookie)
ctf_string(address, address)
)
)
TRACEPOINT_EVENT(librbd, list_lockers_exit,
TP_ARGS(
ssize_t, retval),
TP_FIELDS(
ctf_integer(ssize_t, retval, retval)
)
)
TRACEPOINT_EVENT(librbd, lock_exclusive_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only,
const char*, cookie),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
ceph_ctf_string(cookie, cookie)
)
)
TRACEPOINT_EVENT(librbd, lock_exclusive_exit,
TP_ARGS(
int, retval),
TP_FIELDS(
ctf_integer(int, retval, retval)
)
)
TRACEPOINT_EVENT(librbd, lock_shared_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only,
const char*, cookie,
const char*, tag),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
ceph_ctf_string(cookie, cookie)
ceph_ctf_string(tag, tag)
)
)
TRACEPOINT_EVENT(librbd, lock_shared_exit,
TP_ARGS(
int, retval),
TP_FIELDS(
ctf_integer(int, retval, retval)
)
)
TRACEPOINT_EVENT(librbd, unlock_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only,
const char*, cookie),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
ceph_ctf_string(cookie, cookie)
)
)
TRACEPOINT_EVENT(librbd, unlock_exit,
TP_ARGS(
int, retval),
TP_FIELDS(
ctf_integer(int, retval, retval)
)
)
TRACEPOINT_EVENT(librbd, break_lock_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only,
const char*, client,
const char*, cookie),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
ceph_ctf_string(client, client)
ceph_ctf_string(cookie, cookie)
)
)
TRACEPOINT_EVENT(librbd, break_lock_exit,
TP_ARGS(
int, retval),
TP_FIELDS(
ctf_integer(int, retval, retval)
)
)
TRACEPOINT_EVENT(librbd, diff_iterate_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only,
const char*, from_snap_name,
uint64_t, offset,
uint64_t, length),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
ctf_string(from_snap_name, from_snap_name)
ctf_integer(uint64_t, offset, offset)
ctf_integer(uint64_t, length, length)
)
)
TRACEPOINT_EVENT(librbd, diff_iterate_exit,
TP_ARGS(
int, retval),
TP_FIELDS(
ctf_integer(int, retval, retval)
)
)
TRACEPOINT_EVENT(librbd, get_parent_info_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
)
)
TRACEPOINT_EVENT(librbd, get_parent_info_exit,
TP_ARGS(
int, retval,
const char*, parent_pool_name,
const char*, parent_name,
const char*, parent_snap_name),
TP_FIELDS(
ctf_integer(int, retval, retval)
ceph_ctf_string(parent_pool_name, parent_pool_name)
ceph_ctf_string(parent_name, parent_name)
ceph_ctf_string(parent_snap_name, parent_snap_name)
)
)
TRACEPOINT_EVENT(librbd, get_overlap_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
)
)
TRACEPOINT_EVENT(librbd, get_overlap_exit,
TP_ARGS(
int, retval,
uint64_t, overlap),
TP_FIELDS(
ctf_integer(int, retval, retval)
ctf_integer(uint64_t, overlap, overlap)
)
)
TRACEPOINT_EVENT(librbd, get_stripe_unit_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
)
)
TRACEPOINT_EVENT(librbd, get_stripe_unit_exit,
TP_ARGS(
int, retval,
uint64_t, stripe_unit),
TP_FIELDS(
ctf_integer(int, retval, retval)
ctf_integer(uint64_t, stripe_unit, stripe_unit)
)
)
TRACEPOINT_EVENT(librbd, get_stripe_count_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
)
)
TRACEPOINT_EVENT(librbd, get_stripe_count_exit,
TP_ARGS(
int, retval,
uint64_t, stripe_count),
TP_FIELDS(
ctf_integer(int, retval, retval)
ctf_integer(uint64_t, stripe_count, stripe_count)
)
)
TRACEPOINT_EVENT(librbd, get_features_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
)
)
TRACEPOINT_EVENT(librbd, get_features_exit,
TP_ARGS(
int, retval,
uint64_t, features),
TP_FIELDS(
ctf_integer(int, retval, retval)
ctf_integer(uint64_t, features, features)
)
)
TRACEPOINT_EVENT(librbd, get_size_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
)
)
TRACEPOINT_EVENT(librbd, get_size_exit,
TP_ARGS(
int, retval,
uint64_t, size),
TP_FIELDS(
ctf_integer(int, retval, retval)
ctf_integer(uint64_t, size, size)
)
)
TRACEPOINT_EVENT(librbd, get_old_format_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
)
)
TRACEPOINT_EVENT(librbd, get_old_format_exit,
TP_ARGS(
int, retval,
uint64_t, old_format),
TP_FIELDS(
ctf_integer(int, retval, retval)
ctf_integer(uint64_t, old_format, old_format)
)
)
TRACEPOINT_EVENT(librbd, stat_enter,
TP_ARGS(
void*, imagectx,
const char*, name,
const char*, snap_name,
char, read_only),
TP_FIELDS(
ctf_integer_hex(void*, imagectx, imagectx)
ctf_string(name, name)
ctf_string(snap_name, snap_name)
ctf_integer(char, read_only, read_only)
)
)
TRACEPOINT_EVENT(librbd, stat_exit,
TP_ARGS(
int, retval,
rbd_image_info_t*, info),
TP_FIELDS(
ctf_integer(int, retval, retval)
ctf_integer(uint64_t, size, info->size)
ctf_integer(uint64_t, obj_size, info->obj_size)
ctf_integer(uint64_t, num_objs, info->num_objs)
ctf_integer(int, order, info->order)
ctf_array_text(char, block_name_prefix, info->block_name_prefix, RBD_MAX_BLOCK_NAME_SIZE)
ctf_integer(int64_t, parent_pool, info->parent_pool)
ctf_array_text(char, parent_name, info->parent_name, RBD_MAX_IMAGE_NAME_SIZE)
)
)