librbd: Add missing tracepoints

Signed-off-by: Adam Crume <adamcrume@gmail.com>

diff --git a/src/librbd/librbd.cc b/src/librbd/librbd.cc
index cde6dd98e10eea80ac5eabe08fc056c0f17e6931..d6aa9880ab911081453a6c297d421bba67af2764 100644 (file)
--- a/src/librbd/librbd.cc
+++ b/src/librbd/librbd.cc
@@ -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,

diff --git a/src/tracing/librbd.tp b/src/tracing/librbd.tp
index 7124637464d9b1f446438c970eae08fb23f59239..10360d96fd68557a635fc71d0f6cf33f0c4120ab 100644 (file)
--- a/src/tracing/librbd.tp
+++ b/src/tracing/librbd.tp
@@ -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)
+    )
+)