From cffb8f3b5b7241d9586d743ddac51f9b8d707ee8 Mon Sep 17 00:00:00 2001 From: Adam Crume Date: Wed, 9 Jul 2014 10:20:26 -0700 Subject: [PATCH] lttng: Add more tracing to librbd Includes: - aio_complete - aio_discard - aio_flush - aio_get_return_value - aio_is_complete - aio_read - aio_wait_for_complete - aio_write - copy - discard - flush - invalidate_cache - rename - resize - Add ImageCtx pointer to trace points - Add snap_name and readonly flag to trace point open_image_enter Signed-off-by: Adam Crume --- src/librbd/AioCompletion.cc | 57 +++++++ src/librbd/AioCompletion.h | 44 +---- src/librbd/internal.cc | 107 +++++++++--- src/tracing/librbd.tp | 320 +++++++++++++++++++++++++++++++++++- 4 files changed, 467 insertions(+), 61 deletions(-) diff --git a/src/librbd/AioCompletion.cc b/src/librbd/AioCompletion.cc index 86b5b504ebd3d..d98ed2388cefa 100644 --- a/src/librbd/AioCompletion.cc +++ b/src/librbd/AioCompletion.cc @@ -10,6 +10,7 @@ #include "librbd/internal.h" #include "librbd/AioCompletion.h" +#include "tracing/librbd.h" #define dout_subsys ceph_subsys_rbd #undef dout_prefix @@ -30,6 +31,16 @@ namespace librbd { lock.Unlock(); } + int AioCompletion::wait_for_complete() { + tracepoint(librbd, aio_wait_for_complete_enter, this); + lock.Lock(); + while (!done) + cond.Wait(lock); + lock.Unlock(); + tracepoint(librbd, aio_wait_for_complete_exit, 0); + return 0; + } + void AioCompletion::finalize(CephContext *cct, ssize_t rval) { ldout(cct, 20) << "AioCompletion::finalize() " << (void*)this << " rval " << rval << " read_buf " << (void*)read_buf @@ -54,6 +65,32 @@ namespace librbd { } } + void AioCompletion::complete() { + tracepoint(librbd, aio_complete_enter, this, rval); + utime_t elapsed; + assert(lock.is_locked()); + elapsed = ceph_clock_now(ictx->cct) - start_time; + switch (aio_type) { + case AIO_TYPE_READ: + ictx->perfcounter->tinc(l_librbd_aio_rd_latency, elapsed); break; + case AIO_TYPE_WRITE: + ictx->perfcounter->tinc(l_librbd_aio_wr_latency, elapsed); break; + case AIO_TYPE_DISCARD: + ictx->perfcounter->tinc(l_librbd_aio_discard_latency, elapsed); break; + case AIO_TYPE_FLUSH: + ictx->perfcounter->tinc(l_librbd_aio_flush_latency, elapsed); break; + default: + lderr(ictx->cct) << "completed invalid aio_type: " << aio_type << dendl; + break; + } + if (complete_cb) { + complete_cb(rbd_comp, complete_arg); + } + done = true; + cond.Signal(); + tracepoint(librbd, aio_complete_exit); + } + void AioCompletion::complete_request(CephContext *cct, ssize_t r) { ldout(cct, 20) << "AioCompletion::complete_request() " @@ -75,6 +112,26 @@ namespace librbd { put_unlock(); } + bool AioCompletion::is_complete() { + tracepoint(librbd, aio_is_complete_enter, this); + bool done; + { + Mutex::Locker l(lock); + done = this->done; + } + tracepoint(librbd, aio_is_complete_exit, done); + return done; + } + + ssize_t AioCompletion::get_return_value() { + tracepoint(librbd, aio_get_return_value_enter, this); + lock.Lock(); + ssize_t r = rval; + lock.Unlock(); + tracepoint(librbd, aio_get_return_value_exit, r); + return r; + } + void C_AioRead::finish(int r) { ldout(m_cct, 10) << "C_AioRead::finish() " << this << " r = " << r << dendl; diff --git a/src/librbd/AioCompletion.h b/src/librbd/AioCompletion.h index aaccefef9fcee..58eec66b8513d 100644 --- a/src/librbd/AioCompletion.h +++ b/src/librbd/AioCompletion.h @@ -72,13 +72,7 @@ namespace librbd { ~AioCompletion() { } - int wait_for_complete() { - lock.Lock(); - while (!done) - cond.Wait(lock); - lock.Unlock(); - return 0; - } + int wait_for_complete(); void add_request() { lock.Lock(); @@ -97,29 +91,7 @@ namespace librbd { start_time = ceph_clock_now(ictx->cct); } - void complete() { - utime_t elapsed; - assert(lock.is_locked()); - elapsed = ceph_clock_now(ictx->cct) - start_time; - switch (aio_type) { - case AIO_TYPE_READ: - ictx->perfcounter->tinc(l_librbd_aio_rd_latency, elapsed); break; - case AIO_TYPE_WRITE: - ictx->perfcounter->tinc(l_librbd_aio_wr_latency, elapsed); break; - case AIO_TYPE_DISCARD: - ictx->perfcounter->tinc(l_librbd_aio_discard_latency, elapsed); break; - case AIO_TYPE_FLUSH: - ictx->perfcounter->tinc(l_librbd_aio_flush_latency, elapsed); break; - default: - lderr(ictx->cct) << "completed invalid aio_type: " << aio_type << dendl; - break; - } - if (complete_cb) { - complete_cb(rbd_comp, complete_arg); - } - done = true; - cond.Signal(); - } + void complete(); void set_complete_cb(void *cb_arg, callback_t cb) { complete_cb = cb; @@ -128,17 +100,9 @@ namespace librbd { void complete_request(CephContext *cct, ssize_t r); - bool is_complete() { - Mutex::Locker l(lock); - return done; - } + bool is_complete(); - ssize_t get_return_value() { - lock.Lock(); - ssize_t r = rval; - lock.Unlock(); - return r; - } + ssize_t get_return_value(); void get() { lock.Lock(); diff --git a/src/librbd/internal.cc b/src/librbd/internal.cc index 5d786115ea61e..6c83c69309d0c 100644 --- a/src/librbd/internal.cc +++ b/src/librbd/internal.cc @@ -1072,6 +1072,7 @@ reprotect_and_return_err: int rename(IoCtx& io_ctx, const char *srcname, const char *dstname) { + tracepoint(librbd, rename_enter, io_ctx.get_pool_name().c_str(), io_ctx.get_id(), srcname, dstname); CephContext *cct = (CephContext *)io_ctx.cct(); ldout(cct, 20) << "rename " << &io_ctx << " " << srcname << " -> " << dstname << dendl; @@ -1094,6 +1095,7 @@ reprotect_and_return_err: r = cls_client::get_id(&io_ctx, src_oid, &id); if (r < 0) { lderr(cct) << "error reading image id: " << cpp_strerror(r) << dendl; + tracepoint(librbd, rename_exit, r); return r; } } @@ -1104,6 +1106,7 @@ reprotect_and_return_err: if (r < 0) { lderr(cct) << "error reading source object: " << src_oid << ": " << cpp_strerror(r) << dendl; + tracepoint(librbd, rename_exit, r); return r; } @@ -1115,6 +1118,7 @@ reprotect_and_return_err: if (r < 0) { lderr(cct) << "error reading source object omap values: " << cpp_strerror(r) << dendl; + tracepoint(librbd, rename_exit, r); return r; } omap_values.insert(outbl.begin(), outbl.end()); @@ -1126,10 +1130,12 @@ reprotect_and_return_err: if (r < 0 && r != -ENOENT) { lderr(cct) << "error checking for existing image called " << dstname << ":" << cpp_strerror(r) << dendl; + tracepoint(librbd, rename_exit, r); return r; } if (r == 0) { lderr(cct) << "rbd image " << dstname << " already exists" << dendl; + tracepoint(librbd, rename_exit, -EEXIST); return -EEXIST; } @@ -1142,6 +1148,7 @@ reprotect_and_return_err: if (r < 0) { lderr(cct) << "error writing destination object: " << dst_oid << ": " << cpp_strerror(r) << dendl; + tracepoint(librbd, rename_exit, r); return r; } @@ -1151,6 +1158,7 @@ reprotect_and_return_err: io_ctx.remove(dst_oid); lderr(cct) << "couldn't add " << dstname << " to directory: " << cpp_strerror(r) << dendl; + tracepoint(librbd, rename_exit, r); return r; } r = tmap_rm(io_ctx, srcname); @@ -1163,6 +1171,7 @@ reprotect_and_return_err: srcname, dstname, id); if (r < 0) { lderr(cct) << "error updating directory: " << cpp_strerror(r) << dendl; + tracepoint(librbd, rename_exit, r); return r; } } @@ -1177,6 +1186,7 @@ reprotect_and_return_err: notify_change(io_ctx, old_header_name(srcname), NULL, NULL); } + tracepoint(librbd, rename_exit, 0); return 0; } @@ -1514,30 +1524,38 @@ reprotect_and_return_err: int resize(ImageCtx *ictx, uint64_t size, ProgressContext& prog_ctx) { + tracepoint(librbd, resize_enter, ictx, ictx->name.c_str(), ictx->id.c_str(), size); CephContext *cct = ictx->cct; ldout(cct, 20) << "resize " << ictx << " " << ictx->size << " -> " << size << dendl; - if (ictx->read_only) + if (ictx->read_only) { + tracepoint(librbd, resize_exit, -EROFS); return -EROFS; + } int r = ictx_check(ictx); - if (r < 0) + if (r < 0) { + tracepoint(librbd, resize_exit, r); return r; + } RWLock::WLocker l(ictx->md_lock); if (size < ictx->size && ictx->object_cacher) { // need to invalidate since we're deleting objects, and // ObjectCacher doesn't track non-existent objects r = ictx->invalidate_cache(); - if (r < 0) + if (r < 0) { + tracepoint(librbd, resize_exit, r); return r; + } } resize_helper(ictx, size, prog_ctx); ldout(cct, 2) << "done." << dendl; ictx->perfcounter->inc(l_librbd_resize); + tracepoint(librbd, resize_exit, 0); return 0; } @@ -2010,6 +2028,7 @@ reprotect_and_return_err: int copy(ImageCtx *src, ImageCtx *dest, ProgressContext &prog_ctx) { + tracepoint(librbd, copy_enter, src, src->name.c_str(), src->id.c_str(), dest, dest->name.c_str(), dest->id.c_str()); src->md_lock.get_read(); src->snap_lock.get_read(); uint64_t src_size = src->get_image_size(src->snap_id); @@ -2026,6 +2045,7 @@ reprotect_and_return_err: if (dest_size < src_size) { lderr(cct) << " src size " << src_size << " >= dest size " << dest_size << dendl; + tracepoint(librbd, copy_exit, -EINVAL); return -EINVAL; } int r; @@ -2044,6 +2064,7 @@ reprotect_and_return_err: lderr(cct) << "could not read from source image from " << offset << " to " << offset + len << ": " << cpp_strerror(r) << dendl; + tracepoint(librbd, copy_exit, r); return r; } prog_ctx.update_progress(offset, src_size); @@ -2052,6 +2073,7 @@ reprotect_and_return_err: r = throttle.wait_for_ret(); if (r >= 0) prog_ctx.update_progress(src_size, src_size); + tracepoint(librbd, copy_exit, r); return r; } @@ -2093,7 +2115,7 @@ reprotect_and_return_err: int open_image(ImageCtx *ictx) { - tracepoint(librbd, open_image_enter, ictx->name.c_str(), ictx->id.c_str()); + tracepoint(librbd, open_image_enter, ictx, ictx->name.c_str(), ictx->id.c_str(), ictx->snap_name.c_str(), ictx->read_only); ldout(ictx->cct, 20) << "open_image: ictx = " << ictx << " name = '" << ictx->name << "' id = '" << ictx->id @@ -2132,7 +2154,7 @@ reprotect_and_return_err: void close_image(ImageCtx *ictx) { - tracepoint(librbd, close_image_enter, ictx->name.c_str(), ictx->id.c_str()); + tracepoint(librbd, close_image_enter, ictx, ictx->name.c_str(), ictx->id.c_str()); ldout(ictx->cct, 20) << "close_image " << ictx << dendl; if (ictx->object_cacher) ictx->shutdown_cache(); // implicitly flushes @@ -2649,7 +2671,7 @@ reprotect_and_return_err: ssize_t read(ImageCtx *ictx, const vector >& image_extents, char *buf, bufferlist *pbl) { - tracepoint(librbd, read_enter, ictx->name.c_str(), ictx->id.c_str()); + tracepoint(librbd, read_enter, ictx, ictx->name.c_str(), ictx->id.c_str()); for (vector >::const_iterator r = image_extents.begin(); r != image_extents.end(); ++r) { @@ -2681,7 +2703,7 @@ reprotect_and_return_err: ssize_t write(ImageCtx *ictx, uint64_t off, size_t len, const char *buf) { - tracepoint(librbd, write_enter, ictx->name.c_str(), ictx->id.c_str(), off, len, buf); + tracepoint(librbd, write_enter, ictx, ictx->name.c_str(), ictx->id.c_str(), off, len, buf); utime_t start_time, elapsed; ldout(ictx->cct, 20) << "write " << ictx << " off = " << off << " len = " << len << dendl; @@ -2729,6 +2751,7 @@ reprotect_and_return_err: int discard(ImageCtx *ictx, uint64_t off, uint64_t len) { + tracepoint(librbd, discard_enter, ictx, ictx->name.c_str(), ictx->id.c_str(), off, len); utime_t start_time, elapsed; ldout(ictx->cct, 20) << "discard " << ictx << " off = " << off << " len = " << len << dendl; @@ -2745,6 +2768,7 @@ reprotect_and_return_err: if (r < 0) { c->release(); delete ctx; + tracepoint(librbd, discard_exit, r); return r; } @@ -2753,13 +2777,16 @@ reprotect_and_return_err: cond.Wait(mylock); mylock.Unlock(); - if (ret < 0) + if (ret < 0) { + tracepoint(librbd, discard_exit, ret); return ret; + } elapsed = ceph_clock_now(ictx->cct) - start_time; ictx->perfcounter->inc(l_librbd_discard_latency, elapsed); ictx->perfcounter->inc(l_librbd_discard); ictx->perfcounter->inc(l_librbd_discard_bytes, len); + tracepoint(librbd, discard_exit, len); return len; } @@ -2866,12 +2893,15 @@ reprotect_and_return_err: int aio_flush(ImageCtx *ictx, AioCompletion *c) { + tracepoint(librbd, aio_flush_enter, ictx, ictx->name.c_str(), ictx->id.c_str(), c); CephContext *cct = ictx->cct; ldout(cct, 20) << "aio_flush " << ictx << " completion " << c << dendl; int r = ictx_check(ictx); - if (r < 0) + if (r < 0) { + tracepoint(librbd, aio_flush_exit, r); return r; + } ictx->user_flushed(); @@ -2891,21 +2921,26 @@ reprotect_and_return_err: c->put(); ictx->perfcounter->inc(l_librbd_aio_flush); + tracepoint(librbd, aio_flush_exit, 0); return 0; } int flush(ImageCtx *ictx) { + tracepoint(librbd, flush_enter, ictx, ictx->name.c_str(), ictx->id.c_str()); CephContext *cct = ictx->cct; ldout(cct, 20) << "flush " << ictx << dendl; int r = ictx_check(ictx); - if (r < 0) + if (r < 0) { + tracepoint(librbd, flush_exit, r); return r; + } ictx->user_flushed(); r = _flush(ictx); ictx->perfcounter->inc(l_librbd_flush); + tracepoint(librbd, flush_exit, r); return r; } @@ -2928,32 +2963,42 @@ reprotect_and_return_err: int invalidate_cache(ImageCtx *ictx) { + tracepoint(librbd, invalidate_cache_enter, ictx, ictx->name.c_str(), ictx->id.c_str()); CephContext *cct = ictx->cct; ldout(cct, 20) << "invalidate_cache " << ictx << dendl; int r = ictx_check(ictx); - if (r < 0) + if (r < 0) { + tracepoint(librbd, invalidate_cache_exit, r); return r; + } RWLock::WLocker l(ictx->md_lock); - return ictx->invalidate_cache(); + r = ictx->invalidate_cache(); + tracepoint(librbd, invalidate_cache_exit, r); + return r; } int aio_write(ImageCtx *ictx, uint64_t off, size_t len, const char *buf, AioCompletion *c) { + tracepoint(librbd, aio_write_enter, ictx, ictx->name.c_str(), ictx->id.c_str(), off, len, buf, c); CephContext *cct = ictx->cct; ldout(cct, 20) << "aio_write " << ictx << " off = " << off << " len = " << len << " buf = " << (void*)buf << dendl; int r = ictx_check(ictx); - if (r < 0) + if (r < 0) { + tracepoint(librbd, aio_write_exit, r); return r; + } uint64_t mylen = len; r = clip_io(ictx, off, &mylen); - if (r < 0) + if (r < 0) { + tracepoint(librbd, aio_write_exit, r); return r; + } ictx->snap_lock.get_read(); snapid_t snap_id = ictx->snap_id; @@ -2964,8 +3009,10 @@ reprotect_and_return_err: ictx->parent_lock.put_read(); ictx->snap_lock.put_read(); - if (snap_id != CEPH_NOSNAP || ictx->read_only) + if (snap_id != CEPH_NOSNAP || ictx->read_only) { + tracepoint(librbd, aio_write_exit, -EROFS); return -EROFS; + } ldout(cct, 20) << " parent overlap " << overlap << dendl; @@ -3018,22 +3065,28 @@ reprotect_and_return_err: ictx->perfcounter->inc(l_librbd_aio_wr_bytes, mylen); /* FIXME: cleanup all the allocated stuff */ + tracepoint(librbd, aio_write_exit, r); return r; } int aio_discard(ImageCtx *ictx, uint64_t off, uint64_t len, AioCompletion *c) { + tracepoint(librbd, aio_discard_enter, ictx, ictx->name.c_str(), ictx->id.c_str(), off, len, c); CephContext *cct = ictx->cct; ldout(cct, 20) << "aio_discard " << ictx << " off = " << off << " len = " << len << dendl; int r = ictx_check(ictx); - if (r < 0) + if (r < 0) { + tracepoint(librbd, aio_discard_exit, r); return r; + } r = clip_io(ictx, off, &len); - if (r < 0) + if (r < 0) { + tracepoint(librbd, aio_discard_exit, r); return r; + } // TODO: check for snap ictx->snap_lock.get_read(); @@ -3045,8 +3098,10 @@ reprotect_and_return_err: ictx->parent_lock.put_read(); ictx->snap_lock.put_read(); - if (snap_id != CEPH_NOSNAP || ictx->read_only) + if (snap_id != CEPH_NOSNAP || ictx->read_only) { + tracepoint(librbd, aio_discard_exit, -EROFS); return -EROFS; + } // map vector extents; @@ -3104,6 +3159,7 @@ reprotect_and_return_err: ictx->perfcounter->inc(l_librbd_aio_discard_bytes, len); /* FIXME: cleanup all the allocated stuff */ + tracepoint(librbd, aio_discard_exit, r); return r; } @@ -3126,11 +3182,19 @@ reprotect_and_return_err: int aio_read(ImageCtx *ictx, const vector >& image_extents, char *buf, bufferlist *pbl, AioCompletion *c) { + tracepoint(librbd, aio_read_enter, ictx, ictx->name.c_str(), ictx->id.c_str(), buf, c); + for (vector >::const_iterator r = image_extents.begin(); + r != image_extents.end(); + ++r) { + tracepoint(librbd, aio_read_extent, r->first, r->second); + } ldout(ictx->cct, 20) << "aio_read " << ictx << " completion " << c << " " << image_extents << dendl; int r = ictx_check(ictx); - if (r < 0) + if (r < 0) { + tracepoint(librbd, aio_read_exit, r); return r; + } ictx->snap_lock.get_read(); snap_t snap_id = ictx->snap_id; @@ -3145,8 +3209,10 @@ reprotect_and_return_err: ++p) { uint64_t len = p->second; r = clip_io(ictx, p->first, &len); - if (r < 0) + if (r < 0) { + tracepoint(librbd, aio_read_exit, r); return r; + } if (len == 0) continue; @@ -3200,6 +3266,7 @@ reprotect_and_return_err: ictx->perfcounter->inc(l_librbd_aio_rd); ictx->perfcounter->inc(l_librbd_aio_rd_bytes, buffer_ofs); + tracepoint(librbd, aio_read_exit, ret); return ret; } diff --git a/src/tracing/librbd.tp b/src/tracing/librbd.tp index 70e5218b371c2..373f3eedd246c 100644 --- a/src/tracing/librbd.tp +++ b/src/tracing/librbd.tp @@ -3,9 +3,11 @@ TRACEPOINT_EVENT(librbd, read_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) ) @@ -31,12 +33,14 @@ TRACEPOINT_EVENT(librbd, read_exit, TRACEPOINT_EVENT(librbd, write_enter, TP_ARGS( + void*, imagectx, const char*, name, const char*, id, uint64_t, off, size_t, len, const char*, buf), TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) ctf_string(name, name) ctf_string(id, id) ctf_integer(uint64_t, off, off) @@ -54,11 +58,17 @@ TRACEPOINT_EVENT(librbd, write_exit, TRACEPOINT_EVENT(librbd, open_image_enter, TP_ARGS( + void*, imagectx, const char*, name, - const char*, id), + const char*, id, + const char*, snap_name, + int, read_only), TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) ctf_string(name, name) ctf_string(id, id) + ctf_string(snap_name, snap_name) + ctf_integer(uint8_t, read_only, read_only ? 1 : 0) ) ) @@ -72,9 +82,11 @@ TRACEPOINT_EVENT(librbd, open_image_exit, TRACEPOINT_EVENT(librbd, close_image_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) ) @@ -162,3 +174,309 @@ TRACEPOINT_EVENT(librbd, remove_exit, ctf_integer(int, retval, retval) ) ) + +TRACEPOINT_EVENT(librbd, aio_write_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, id, + uint64_t, off, + size_t, len, + const char*, buf, + const void*, completion), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(id, id) + ctf_integer(uint64_t, off, off) + ctf_integer(size_t, len, len) + ceph_ctf_sequence(unsigned char, buf, buf, size_t, len) + ctf_integer_hex(const void*, completion, completion) + ) +) + +TRACEPOINT_EVENT(librbd, aio_write_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, aio_read_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, id, + const char*, buf, + const void*, completion), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(id, id) + ctf_integer_hex(const void*, completion, completion) + ) +) + +TRACEPOINT_EVENT(librbd, aio_read_extent, + TP_ARGS( + uint64_t, offset, + uint64_t, length), + TP_FIELDS( + ctf_integer(uint64_t, offset, offset) + ctf_integer(uint64_t, length, length) + ) +) + +TRACEPOINT_EVENT(librbd, aio_read_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, aio_discard_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, id, + uint64_t, off, + uint64_t, len, + void*, completion), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(id, id) + ctf_integer(uint64_t, off, off) + ctf_integer(uint64_t, len, len) + ctf_integer_hex(void*, completion, completion) + ) +) + +TRACEPOINT_EVENT(librbd, aio_discard_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, invalidate_cache_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, invalidate_cache_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, flush_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, flush_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, aio_flush_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, id, + const void*, completion), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(id, id) + ctf_integer_hex(const void*, completion, completion) + ) +) + +TRACEPOINT_EVENT(librbd, aio_flush_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, copy_enter, + TP_ARGS( + void*, src_imagectx, + const char*, src_name, + const char*, src_id, + void*, dst_imagectx, + const char*, dst_name, + const char*, dst_id), + TP_FIELDS( + ctf_integer_hex(void*, src_imagectx, src_imagectx) + ctf_string(src_name, src_name) + ctf_string(src_id, src_id) + ctf_integer_hex(void*, dst_imagectx, dst_imagectx) + ctf_string(dst_name, dst_name) + ctf_string(dst_id, dst_id) + ) +) + +TRACEPOINT_EVENT(librbd, copy_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, resize_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, id, + uint64_t, size), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(id, id) + ctf_integer(uint64_t, size, size) + ) +) + +TRACEPOINT_EVENT(librbd, resize_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, rename_enter, + TP_ARGS( + const char*, pool_name, + uint64_t, id, + const char*, srcname, + const char*, dstname), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(uint64_t, id, id) + ctf_string(srcname, srcname) + ctf_string(dstname, dstname) + ) +) + +TRACEPOINT_EVENT(librbd, rename_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, discard_enter, + TP_ARGS( + void*, imagectx, + const char*, name, + const char*, id, + uint64_t, off, + uint64_t, len), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ctf_string(id, id) + ctf_integer(uint64_t, off, off) + ctf_integer(uint64_t, len, len) + ) +) + +TRACEPOINT_EVENT(librbd, discard_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, aio_is_complete_enter, + TP_ARGS( + rbd_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rbd_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librbd, aio_is_complete_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, aio_get_return_value_enter, + TP_ARGS( + rbd_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rbd_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librbd, aio_get_return_value_exit, + TP_ARGS( + ssize_t, retval), + TP_FIELDS( + ctf_integer(ssize_t, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, aio_wait_for_complete_enter, + TP_ARGS( + rbd_completion_t, completion), + TP_FIELDS( + ctf_integer_hex(rbd_completion_t, completion, completion) + ) +) + +TRACEPOINT_EVENT(librbd, aio_wait_for_complete_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, aio_complete_enter, + TP_ARGS( + rbd_completion_t, completion, + ssize_t, rval), + TP_FIELDS( + ctf_integer_hex(rbd_completion_t, completion, completion) + ctf_integer(ssize_t, rval, rval) + ) +) + +TRACEPOINT_EVENT(librbd, aio_complete_exit, + TP_ARGS(), + TP_FIELDS() +) -- 2.39.5