lttng: Trace ReplicatedPG::do_osd_ops

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

diff --git a/src/osd/ReplicatedPG.cc b/src/osd/ReplicatedPG.cc
index cdc8e06617aaa441290ebf781c35d1036d11ca50..5f80b6042f9c9a0f7942896c9e9234539880aa81 100644 (file)
--- a/src/osd/ReplicatedPG.cc
+++ b/src/osd/ReplicatedPG.cc
@@ -15,6 +15,8 @@
  * 
  */
 
+#include <boost/algorithm/string/join.hpp>
+#include <boost/range/adaptors.hpp>
 #include "boost/tuple/tuple.hpp"
 #include "PG.h"
 #include "ReplicatedPG.h"
@@ -3027,7 +3029,13 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
   for (vector<OSDOp>::iterator p = ops.begin(); p != ops.end(); ++p, ctx->current_osd_subop_num++) {
     OSDOp& osd_op = *p;
     ceph_osd_op& op = osd_op.op;
- 
+
+    // TODO: check endianness (__le32 vs uint32_t, etc.)
+    // The fields in ceph_osd_op are little-endian (according to the definition in rados.h),
+    // but the code in this function seems to treat them as native-endian.  What should the
+    // tracepoints do?
+    tracepoint(osd, do_osd_op_pre, soid.oid.name.c_str(), soid.snap.val, op.op, ceph_osd_op_name(op.op), op.flags);
+
     dout(10) << "do_osd_op  " << osd_op << dendl;
 
     bufferlist::iterator bp = osd_op.indata.begin();
@@ -3098,6 +3106,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
       {
        __u32 seq = oi.truncate_seq;
        uint64_t size = oi.size;
+       tracepoint(osd, do_osd_op_pre_read, soid.oid.name.c_str(), soid.snap.val, size, seq, op.extent.offset, op.extent.length, op.extent.truncate_size, op.extent.truncate_seq);
        bool trimmed_read = false;
        // are we beyond truncate_size?
        if ( (seq < op.extent.truncate_seq) &&
@@ -3148,6 +3157,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
 
     /* map extents */
     case CEPH_OSD_OP_MAPEXT:
+      tracepoint(osd, do_osd_op_pre_mapext, soid.oid.name.c_str(), soid.snap.val, op.extent.offset, op.extent.length);
       if (pool.info.require_rollback()) {
        result = -EOPNOTSUPP;
        break;
@@ -3168,6 +3178,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
 
     /* map extents */
     case CEPH_OSD_OP_SPARSE_READ:
+      tracepoint(osd, do_osd_op_pre_sparse_read, soid.oid.name.c_str(), soid.snap.val, oi.size, oi.truncate_seq, op.extent.offset, op.extent.length, op.extent.truncate_size, op.extent.truncate_seq);
       if (pool.info.require_rollback()) {
        result = -EOPNOTSUPP;
        break;
@@ -3267,8 +3278,10 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
          osd_op.indata.hexdump(*_dout);
          *_dout << dendl;
          result = -EINVAL;
+         tracepoint(osd, do_osd_op_pre_call, soid.oid.name.c_str(), soid.snap.val, "???", "???");
          break;
        }
+       tracepoint(osd, do_osd_op_pre_call, soid.oid.name.c_str(), soid.snap.val, cname.c_str(), mname.c_str());
 
        ClassHandler::ClassData *cls;
        result = osd->class_handler->open_class(cname, &cls);
@@ -3314,6 +3327,8 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
     case CEPH_OSD_OP_STAT:
       // note: stat does not require RD
       {
+       tracepoint(osd, do_osd_op_pre_stat, soid.oid.name.c_str(), soid.snap.val);
+
        if (obs.exists && !oi.is_whiteout()) {
          ::encode(oi.size, osd_op.outdata);
          ::encode(oi.mtime, osd_op.outdata);
@@ -3330,6 +3345,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
     case CEPH_OSD_OP_ISDIRTY:
       ++ctx->num_read;
       {
+       tracepoint(osd, do_osd_op_pre_isdirty, soid.oid.name.c_str(), soid.snap.val);
        bool is_dirty = obs.oi.is_dirty();
        ::encode(is_dirty, osd_op.outdata);
        ctx->delta_stats.num_rd++;
@@ -3340,6 +3356,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
     case CEPH_OSD_OP_UNDIRTY:
       ++ctx->num_write;
       {
+       tracepoint(osd, do_osd_op_pre_undirty, soid.oid.name.c_str(), soid.snap.val);
        if (oi.is_dirty()) {
          ctx->undirty = true;  // see make_writeable()
          ctx->modify = true;
@@ -3352,6 +3369,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
     case CEPH_OSD_OP_CACHE_TRY_FLUSH:
       ++ctx->num_write;
       {
+       tracepoint(osd, do_osd_op_pre_try_flush, soid.oid.name.c_str(), soid.snap.val);
        if (ctx->lock_to_release != OpContext::NONE) {
          dout(10) << "cache-try-flush without SKIPRWLOCKS flag set" << dendl;
          result = -EINVAL;
@@ -3378,6 +3396,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
     case CEPH_OSD_OP_CACHE_FLUSH:
       ++ctx->num_write;
       {
+       tracepoint(osd, do_osd_op_pre_cache_flush, soid.oid.name.c_str(), soid.snap.val);
        if (ctx->lock_to_release == OpContext::NONE) {
          dout(10) << "cache-flush with SKIPRWLOCKS flag set" << dendl;
          result = -EINVAL;
@@ -3413,6 +3432,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
     case CEPH_OSD_OP_CACHE_EVICT:
       ++ctx->num_write;
       {
+       tracepoint(osd, do_osd_op_pre_cache_evict, soid.oid.name.c_str(), soid.snap.val);
        if (pool.info.cache_mode == pg_pool_t::CACHEMODE_NONE) {
          result = -EINVAL;
          break;
@@ -3440,6 +3460,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
       {
        string aname;
        bp.copy(op.xattr.name_len, aname);
+       tracepoint(osd, do_osd_op_pre_getxattr, soid.oid.name.c_str(), soid.snap.val, aname.c_str());
        string name = "_" + aname;
        int r = getattr_maybe_cache(
          ctx->obc,
@@ -3458,6 +3479,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
    case CEPH_OSD_OP_GETXATTRS:
       ++ctx->num_read;
       {
+       tracepoint(osd, do_osd_op_pre_getxattrs, soid.oid.name.c_str(), soid.snap.val);
        map<string, bufferlist> out;
        result = getattrs_maybe_cache(
          ctx->obc,
@@ -3478,6 +3500,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
       {
        string aname;
        bp.copy(op.xattr.name_len, aname);
+       tracepoint(osd, do_osd_op_pre_cmpxattr, soid.oid.name.c_str(), soid.snap.val, aname.c_str());
        string name = "_" + aname;
        name[op.xattr.name_len + 1] = 0;
        
@@ -3549,6 +3572,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
       ++ctx->num_read;
       {
        uint64_t ver = op.watch.ver;
+       tracepoint(osd, do_osd_op_pre_assert_ver, soid.oid.name.c_str(), soid.snap.val, ver);
        if (!ver)
          result = -EINVAL;
         else if (ver < oi.user_version)
@@ -3561,6 +3585,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
     case CEPH_OSD_OP_LIST_WATCHERS:
       ++ctx->num_read;
       {
+       tracepoint(osd, do_osd_op_pre_list_watchers, soid.oid.name.c_str(), soid.snap.val);
         obj_list_watch_response_t resp;
 
         map<pair<uint64_t, entity_name_t>, watch_info_t>::const_iterator oi_iter;
@@ -3587,6 +3612,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
     case CEPH_OSD_OP_LIST_SNAPS:
       ++ctx->num_read;
       {
+       tracepoint(osd, do_osd_op_pre_list_snaps, soid.oid.name.c_str(), soid.snap.val);
         obj_list_snap_response_t resp;
 
         if (!ssc) {
@@ -3666,6 +3692,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
       ++ctx->num_read;
       {
        uint64_t ver = op.assert_ver.ver;
+       tracepoint(osd, do_osd_op_pre_assert_src_version, soid.oid.name.c_str(), soid.snap.val, ver);
        if (!ver)
          result = -EINVAL;
         else if (ver < src_obc->obs.oi.user_version)
@@ -3689,6 +3716,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
        } catch (const buffer::error &e) {
          timeout = 0;
        }
+       tracepoint(osd, do_osd_op_pre_notify, soid.oid.name.c_str(), soid.snap.val, ver, timeout);
        if (!timeout)
          timeout = cct->_conf->osd_default_notify_timeout;
 
@@ -3708,9 +3736,11 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
          uint64_t watch_cookie = 0;
          ::decode(notify_id, bp);
          ::decode(watch_cookie, bp);
+         tracepoint(osd, do_osd_op_pre_notify_ack, soid.oid.name.c_str(), soid.snap.val, notify_id, watch_cookie, "Y");
          OpContext::NotifyAck ack(notify_id, watch_cookie);
          ctx->notify_acks.push_back(ack);
        } catch (const buffer::error &e) {
+         tracepoint(osd, do_osd_op_pre_notify_ack, soid.oid.name.c_str(), soid.snap.val, op.watch.cookie, 0, "N");
          OpContext::NotifyAck ack(
            // op.watch.cookie is actually the notify_id for historical reasons
            op.watch.cookie
@@ -3723,6 +3753,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
     case CEPH_OSD_OP_SETALLOCHINT:
       ++ctx->num_write;
       {
+       tracepoint(osd, do_osd_op_pre_setallochint, soid.oid.name.c_str(), soid.snap.val, op.alloc_hint.expected_object_size, op.alloc_hint.expected_write_size);
         if (!obs.exists) {
           ctx->mod_desc.create();
           t->touch(soid);
@@ -3744,6 +3775,8 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
     case CEPH_OSD_OP_WRITE:
       ++ctx->num_write;
       { // write
+        __u32 seq = oi.truncate_seq;
+       tracepoint(osd, do_osd_op_pre_write, soid.oid.name.c_str(), soid.snap.val, oi.size, seq, op.extent.offset, op.extent.length, op.extent.truncate_size, op.extent.truncate_seq);
        if (op.extent.length != osd_op.indata.length()) {
          result = -EINVAL;
          break;
@@ -3767,7 +3800,6 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
          }
        }
 
-        __u32 seq = oi.truncate_seq;
         if (seq && (seq > op.extent.truncate_seq) &&
             (op.extent.offset + op.extent.length > oi.size)) {
          // old write, arrived after trimtrunc
@@ -3818,6 +3850,8 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
     case CEPH_OSD_OP_WRITEFULL:
       ++ctx->num_write;
       { // write full object
+       tracepoint(osd, do_osd_op_pre_writefull, soid.oid.name.c_str(), soid.snap.val, oi.size, op.extent.offset, op.extent.length);
+
        if (op.extent.length != osd_op.indata.length()) {
          result = -EINVAL;
          break;
@@ -3879,10 +3913,12 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
 
     case CEPH_OSD_OP_ROLLBACK :
       ++ctx->num_write;
+      tracepoint(osd, do_osd_op_pre_rollback, soid.oid.name.c_str(), soid.snap.val);
       result = _rollback_to(ctx, op);
       break;
 
     case CEPH_OSD_OP_ZERO:
+      tracepoint(osd, do_osd_op_pre_zero, soid.oid.name.c_str(), soid.snap.val, op.extent.offset, op.extent.length);
       if (pool.info.require_rollback()) {
        result = -EOPNOTSUPP;
        break;
@@ -3908,6 +3944,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
     case CEPH_OSD_OP_CREATE:
       ++ctx->num_write;
       {
+       tracepoint(osd, do_osd_op_pre_create, soid.oid.name.c_str(), soid.snap.val);
         int flags = le32_to_cpu(op.flags);
        if (obs.exists && !oi.is_whiteout() &&
            (flags & CEPH_OSD_OP_FLAG_EXCL)) {
@@ -3950,6 +3987,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
       // falling through
 
     case CEPH_OSD_OP_TRUNCATE:
+      tracepoint(osd, do_osd_op_pre_truncate, soid.oid.name.c_str(), soid.snap.val, oi.size, oi.truncate_seq, op.extent.offset, op.extent.length, op.extent.truncate_size, op.extent.truncate_seq);
       if (pool.info.require_rollback()) {
        result = -EOPNOTSUPP;
        break;
@@ -3999,6 +4037,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
     
     case CEPH_OSD_OP_DELETE:
       ++ctx->num_write;
+      tracepoint(osd, do_osd_op_pre_delete, soid.oid.name.c_str(), soid.snap.val);
       if (ctx->obc->obs.oi.watchers.size()) {
        // Cannot delete an object with watchers
        result = -EBUSY;
@@ -4008,6 +4047,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
       break;
 
     case CEPH_OSD_OP_CLONERANGE:
+      tracepoint(osd, do_osd_op_pre_clonerange, soid.oid.name.c_str(), soid.snap.val, op.clonerange.offset, op.clonerange.length, op.clonerange.src_offset);
       ctx->mod_desc.mark_unrollbackable();
       if (pool.info.require_rollback()) {
        result = -EOPNOTSUPP;
@@ -4041,6 +4081,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
     case CEPH_OSD_OP_WATCH:
       ++ctx->num_write;
       {
+       tracepoint(osd, do_osd_op_pre_watch, soid.oid.name.c_str(), soid.snap.val, op.watch.cookie, op.watch.flag);
        if (!obs.exists) {
          result = -ENOENT;
          break;
@@ -4091,6 +4132,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
       {
        if (cct->_conf->osd_max_attr_size > 0 &&
            op.xattr.value_len > cct->_conf->osd_max_attr_size) {
+         tracepoint(osd, do_osd_op_pre_setxattr, soid.oid.name.c_str(), soid.snap.val, "???");
          result = -EFBIG;
          break;
        }
@@ -4108,6 +4150,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
        }
        string aname;
        bp.copy(op.xattr.name_len, aname);
+       tracepoint(osd, do_osd_op_pre_setxattr, soid.oid.name.c_str(), soid.snap.val, aname.c_str());
        string name = "_" + aname;
        if (pool.info.require_rollback()) {
          map<string, boost::optional<bufferlist> > to_set;
@@ -4134,6 +4177,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
       {
        string aname;
        bp.copy(op.xattr.name_len, aname);
+       tracepoint(osd, do_osd_op_pre_rmxattr, soid.oid.name.c_str(), soid.snap.val, aname.c_str());
        string name = "_" + aname;
        if (pool.info.require_rollback()) {
          map<string, boost::optional<bufferlist> > to_set;
@@ -4157,6 +4201,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
       // -- fancy writers --
     case CEPH_OSD_OP_APPEND:
       {
+       tracepoint(osd, do_osd_op_pre_append, soid.oid.name.c_str(), soid.snap.val, oi.size, oi.truncate_seq, op.extent.offset, op.extent.length, op.extent.truncate_size, op.extent.truncate_seq);
        // just do it inline; this works because we are happy to execute
        // fancy op on replicas as well.
        vector<OSDOp> nops(1);
@@ -4172,12 +4217,14 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
       break;
 
     case CEPH_OSD_OP_STARTSYNC:
+      tracepoint(osd, do_osd_op_pre_startsync, soid.oid.name.c_str(), soid.snap.val);
       t->nop();
       break;
 
 
       // -- trivial map --
     case CEPH_OSD_OP_TMAPGET:
+      tracepoint(osd, do_osd_op_pre_tmapget, soid.oid.name.c_str(), soid.snap.val);
       if (pool.info.require_rollback()) {
        result = -EOPNOTSUPP;
        break;
@@ -4195,6 +4242,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
       break;
 
     case CEPH_OSD_OP_TMAPPUT:
+      tracepoint(osd, do_osd_op_pre_tmapput, soid.oid.name.c_str(), soid.snap.val);
       if (pool.info.require_rollback()) {
        result = -EOPNOTSUPP;
        break;
@@ -4253,6 +4301,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
       break;
 
     case CEPH_OSD_OP_TMAPUP:
+      tracepoint(osd, do_osd_op_pre_tmapup, soid.oid.name.c_str(), soid.snap.val);
       if (pool.info.require_rollback()) {
        result = -EOPNOTSUPP;
        break;
@@ -4263,6 +4312,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
 
     case CEPH_OSD_OP_TMAP2OMAP:
       ++ctx->num_write;
+      tracepoint(osd, do_osd_op_pre_tmap2omap, soid.oid.name.c_str(), soid.snap.val);
       result = do_tmap2omap(ctx, op.tmap2omap.flags);
       break;
 
@@ -4278,8 +4328,10 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
        }
        catch (buffer::error& e) {
          result = -EINVAL;
+         tracepoint(osd, do_osd_op_pre_omapgetkeys, soid.oid.name.c_str(), soid.snap.val, "???", 0);
          goto fail;
        }
+       tracepoint(osd, do_osd_op_pre_omapgetkeys, soid.oid.name.c_str(), soid.snap.val, start_after.c_str(), max_return);
        set<string> out_set;
 
        if (!pool.info.require_rollback()) {
@@ -4313,8 +4365,10 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
        }
        catch (buffer::error& e) {
          result = -EINVAL;
+         tracepoint(osd, do_osd_op_pre_omapgetvals, soid.oid.name.c_str(), soid.snap.val, "???", 0, "???");
          goto fail;
        }
+       tracepoint(osd, do_osd_op_pre_omapgetvals, soid.oid.name.c_str(), soid.snap.val, start_after.c_str(), max_return, filter_prefix.c_str());
        map<string, bufferlist> out_set;
 
        if (!pool.info.require_rollback()) {
@@ -4342,6 +4396,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
       break;
 
     case CEPH_OSD_OP_OMAPGETHEADER:
+      tracepoint(osd, do_osd_op_pre_omapgetheader, soid.oid.name.c_str(), soid.snap.val);
       if (pool.info.require_rollback()) {
        // return empty header
        break;
@@ -4363,8 +4418,10 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
        }
        catch (buffer::error& e) {
          result = -EINVAL;
+         tracepoint(osd, do_osd_op_pre_omapgetvalsbykeys, soid.oid.name.c_str(), soid.snap.val, "???");
          goto fail;
        }
+       tracepoint(osd, do_osd_op_pre_omapgetvalsbykeys, soid.oid.name.c_str(), soid.snap.val, boost::algorithm::join(keys_to_get, ",").c_str());
        map<string, bufferlist> out;
        if (!pool.info.require_rollback()) {
          osd->store->omap_get_values(coll, soid, keys_to_get, &out);
@@ -4380,6 +4437,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
       {
        if (!obs.exists || oi.is_whiteout()) {
          result = -ENOENT;
+         tracepoint(osd, do_osd_op_pre_omap_cmp, soid.oid.name.c_str(), soid.snap.val, "???");
          break;
        }
        map<string, pair<bufferlist, int> > assertions;
@@ -4388,8 +4446,10 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
        }
        catch (buffer::error& e) {
          result = -EINVAL;
+         tracepoint(osd, do_osd_op_pre_omap_cmp, soid.oid.name.c_str(), soid.snap.val, "???");
          goto fail;
        }
+       tracepoint(osd, do_osd_op_pre_omap_cmp, soid.oid.name.c_str(), soid.snap.val, boost::algorithm::join(boost::adaptors::keys(assertions), ",").c_str());
        
        map<string, bufferlist> out;
 
@@ -4449,6 +4509,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
     case CEPH_OSD_OP_OMAPSETVALS:
       if (pool.info.require_rollback()) {
        result = -EOPNOTSUPP;
+       tracepoint(osd, do_osd_op_pre_omapsetvals, soid.oid.name.c_str(), soid.snap.val, "???");
        break;
       }
       ctx->mod_desc.mark_unrollbackable();
@@ -4465,8 +4526,10 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
        }
        catch (buffer::error& e) {
          result = -EINVAL;
+         tracepoint(osd, do_osd_op_pre_omapsetvals, soid.oid.name.c_str(), soid.snap.val, "???");
          goto fail;
        }
+       tracepoint(osd, do_osd_op_pre_omapsetvals, soid.oid.name.c_str(), soid.snap.val, boost::algorithm::join(boost::adaptors::keys(to_set), ",").c_str());
        dout(20) << "setting vals: " << dendl;
        for (map<string, bufferlist>::iterator i = to_set.begin();
             i != to_set.end();
@@ -4480,6 +4543,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
       break;
 
     case CEPH_OSD_OP_OMAPSETHEADER:
+      tracepoint(osd, do_osd_op_pre_omapsetheader, soid.oid.name.c_str(), soid.snap.val);
       if (pool.info.require_rollback()) {
        result = -EOPNOTSUPP;
        break;
@@ -4499,6 +4563,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
       break;
 
     case CEPH_OSD_OP_OMAPCLEAR:
+      tracepoint(osd, do_osd_op_pre_omapclear, soid.oid.name.c_str(), soid.snap.val);
       if (pool.info.require_rollback()) {
        result = -EOPNOTSUPP;
        break;
@@ -4520,6 +4585,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
     case CEPH_OSD_OP_OMAPRMKEYS:
       if (pool.info.require_rollback()) {
        result = -EOPNOTSUPP;
+       tracepoint(osd, do_osd_op_pre_omaprmkeys, soid.oid.name.c_str(), soid.snap.val, "???");
        break;
       }
       ctx->mod_desc.mark_unrollbackable();
@@ -4527,6 +4593,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
       {
        if (!obs.exists || oi.is_whiteout()) {
          result = -ENOENT;
+         tracepoint(osd, do_osd_op_pre_omaprmkeys, soid.oid.name.c_str(), soid.snap.val, "???");
          break;
        }
        t->touch(soid);
@@ -4536,8 +4603,10 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
        }
        catch (buffer::error& e) {
          result = -EINVAL;
+         tracepoint(osd, do_osd_op_pre_omaprmkeys, soid.oid.name.c_str(), soid.snap.val, "???");
          goto fail;
        }
+       tracepoint(osd, do_osd_op_pre_omaprmkeys, soid.oid.name.c_str(), soid.snap.val, boost::algorithm::join(to_rm, ",").c_str());
        t->omap_rmkeys(soid, to_rm);
        ctx->delta_stats.num_wr++;
       }
@@ -4546,6 +4615,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
 
     case CEPH_OSD_OP_COPY_GET_CLASSIC:
       ++ctx->num_read;
+      tracepoint(osd, do_osd_op_pre_copy_get_classic, soid.oid.name.c_str(), soid.snap.val);
       result = fill_in_copy_get(ctx, bp, osd_op, ctx->obc, true);
       if (result == -EINVAL)
        goto fail;
@@ -4553,6 +4623,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
 
     case CEPH_OSD_OP_COPY_GET:
       ++ctx->num_read;
+      tracepoint(osd, do_osd_op_pre_copy_get, soid.oid.name.c_str(), soid.snap.val);
       result = fill_in_copy_get(ctx, bp, osd_op, ctx->obc, false);
       if (result == -EINVAL)
        goto fail;
@@ -4571,8 +4642,30 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
        }
        catch (buffer::error& e) {
          result = -EINVAL;
+         tracepoint(osd,
+                    do_osd_op_pre_copy_from,
+                    soid.oid.name.c_str(),
+                    soid.snap.val,
+                    "???",
+                    0,
+                    "???",
+                    "???",
+                    0,
+                    src_snapid,
+                    src_version);
          goto fail;
        }
+       tracepoint(osd,
+                  do_osd_op_pre_copy_from,
+                  soid.oid.name.c_str(),
+                  soid.snap.val,
+                  src_name.name.c_str(),
+                  src_oloc.pool,
+                  src_oloc.key.c_str(),
+                  src_oloc.nspace.c_str(),
+                  src_oloc.hash,
+                  src_snapid,
+                  src_version);
        if (!ctx->copy_cb) {
          // start
          pg_t raw_pg;
@@ -4601,6 +4694,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
       break;
 
     default:
+      tracepoint(osd, do_osd_op_pre_unknown, soid.oid.name.c_str(), soid.snap.val, op.op, ceph_osd_op_name(op.op));
       dout(1) << "unrecognized osd op " << op.op
              << " " << ceph_osd_op_name(op.op)
              << dendl;
@@ -4611,6 +4705,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops)
 
   fail:
     osd_op.rval = result;
+    tracepoint(osd, do_osd_op_post, soid.oid.name.c_str(), soid.snap.val, op.op, ceph_osd_op_name(op.op), op.flags, result);
     if (result < 0 && (op.flags & CEPH_OSD_OP_FLAG_FAILOK))
       result = 0;
 

diff --git a/src/tracing/osd.tp b/src/tracing/osd.tp
index fed1b1c5f754ac804a87c85253a9abc79285188e..51f894a9d6c4cd82fca98f8d13cdf31fb8b96f47 100644 (file)
--- a/src/tracing/osd.tp
+++ b/src/tracing/osd.tp
@@ -72,3 +72,687 @@ TRACEPOINT_EVENT(osd, opwq_process_finish,
         ctf_integer(int32_t, inc, inc)
     )
 )
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        uint16_t, op,
+        const char*, opname,
+        uint32_t, flags),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_integer_hex(uint16_t, op, op)
+        ctf_string(opname, opname)
+        ctf_integer_hex(uint32_t, flags, flags)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_read,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        uint64_t, osize,
+        uint32_t, oseq,
+        uint64_t, offset,
+        uint64_t, length,
+        uint64_t, truncate_size,
+        uint32_t, truncate_seq),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_integer(uint64_t, osize, osize)
+        ctf_integer(uint32_t, oseq, oseq)
+        ctf_integer(uint64_t, offset, offset)
+        ctf_integer(uint64_t, length, length)
+        ctf_integer(uint64_t, truncate_size, truncate_size)
+        ctf_integer(uint32_t, truncate_seq, truncate_seq)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_mapext,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        uint64_t, offset,
+        uint64_t, length),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_integer(uint64_t, offset, offset)
+        ctf_integer(uint64_t, length, length)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_sparse_read,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        uint64_t, osize,
+        uint32_t, oseq,
+        uint64_t, offset,
+        uint64_t, length,
+        uint64_t, truncate_size,
+        uint32_t, truncate_seq),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_integer(uint64_t, osize, osize)
+        ctf_integer(uint32_t, oseq, oseq)
+        ctf_integer(uint64_t, offset, offset)
+        ctf_integer(uint64_t, length, length)
+        ctf_integer(uint64_t, truncate_size, truncate_size)
+        ctf_integer(uint32_t, truncate_seq, truncate_seq)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_call,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        const char*, class_name,
+        const char*, method_name),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_string(class_name, class_name)
+        ctf_string(method_name, method_name)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_stat,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_isdirty,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_undirty,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_try_flush,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_cache_flush,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_cache_evict,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_getxattr,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        const char*, aname),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_string(aname, aname)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_getxattrs,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_cmpxattr,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        const char*, aname),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_string(aname, aname)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_assert_ver,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        uint64_t, ver),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_integer(uint64_t, ver, ver)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_list_watchers,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_list_snaps,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_assert_src_version,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        uint64_t, ver),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_integer(uint64_t, ver, ver)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_notify,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        uint64_t, ver,
+        uint64_t, timeout),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_integer(uint64_t, ver, ver)
+        ctf_integer(uint64_t, timeout, timeout)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_notify_ack,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        uint64_t, notify_id,
+        uint64_t, watch_cookie,
+        const char*, watch_cookie_valid),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_integer(uint64_t, notify_id, notify_id)
+        ctf_integer(uint64_t, watch_cookie, watch_cookie)
+        ctf_string(watch_cookie_valid, watch_cookie_valid)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_setallochint,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        uint64_t, expected_object_size,
+        uint64_t, expected_write_size),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_integer(uint64_t, expected_object_size, expected_object_size)
+        ctf_integer(uint64_t, expected_write_size, expected_write_size)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_write,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        uint64_t, osize,
+        uint32_t, oseq,
+        uint64_t, offset,
+        uint64_t, length,
+        uint64_t, truncate_size,
+        uint32_t, truncate_seq),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_integer(uint64_t, osize, osize)
+        ctf_integer(uint32_t, oseq, oseq)
+        ctf_integer(uint64_t, offset, offset)
+        ctf_integer(uint64_t, length, length)
+        ctf_integer(uint64_t, truncate_size, truncate_size)
+        ctf_integer(uint32_t, truncate_seq, truncate_seq)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_writefull,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        uint64_t, osize,
+        uint64_t, offset,
+        uint64_t, length),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_integer(uint64_t, osize, osize)
+        ctf_integer(uint64_t, offset, offset)
+        ctf_integer(uint64_t, length, length)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_rollback,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_zero,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        uint64_t, offset,
+        uint64_t, length),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_integer(uint64_t, offset, offset)
+        ctf_integer(uint64_t, length, length)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_create,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_truncate,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        uint64_t, osize,
+        uint32_t, oseq,
+        uint64_t, offset,
+        uint64_t, length,
+        uint64_t, truncate_size,
+        uint32_t, truncate_seq),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_integer(uint64_t, osize, osize)
+        ctf_integer(uint32_t, oseq, oseq)
+        ctf_integer(uint64_t, offset, offset)
+        ctf_integer(uint64_t, length, length)
+        ctf_integer(uint64_t, truncate_size, truncate_size)
+        ctf_integer(uint32_t, truncate_seq, truncate_seq)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_delete,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_clonerange,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        uint64_t, offset,
+        uint64_t, length,
+        uint64_t, src_offset),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_integer(uint64_t, offset, offset)
+        ctf_integer(uint64_t, length, length)
+        ctf_integer(uint64_t, src_offset, src_offset)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_watch,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        uint64_t, cookie,
+        uint8_t, flag),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_integer(uint64_t, cookie, cookie)
+        ctf_integer(uint8_t, flag, flag)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_setxattr,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        const char*, aname),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_string(aname, aname)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_rmxattr,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        const char*, aname),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_string(aname, aname)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_append,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        uint64_t, osize,
+        uint32_t, oseq,
+        uint64_t, offset,
+        uint64_t, length,
+        uint64_t, truncate_size,
+        uint32_t, truncate_seq),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_integer(uint64_t, osize, osize)
+        ctf_integer(uint32_t, oseq, oseq)
+        ctf_integer(uint64_t, offset, offset)
+        ctf_integer(uint64_t, length, length)
+        ctf_integer(uint64_t, truncate_size, truncate_size)
+        ctf_integer(uint32_t, truncate_seq, truncate_seq)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_startsync,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_tmapget,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_tmapput,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_tmapup,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_tmap2omap,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_omapgetkeys,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        const char*, start_after,
+        uint64_t, max_return),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_string(start_after, start_after)
+        ctf_integer(uint64_t, max_return, max_return)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_omapgetvals,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        const char*, start_after,
+        uint64_t, max_return,
+        const char*, filter_prefix),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_string(start_after, start_after)
+        ctf_integer(uint64_t, max_return, max_return)
+        ctf_string(filter_prefix, filter_prefix)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_omapgetheader,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_omapgetvalsbykeys,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        const char*, keys),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_string(keys, keys)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_omap_cmp,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        const char*, keys),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_string(keys, keys)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_omapsetvals,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        const char*, keys),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_string(keys, keys)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_omapsetheader,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_omapclear,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_omaprmkeys,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        const char*, keys),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_string(keys, keys)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_copy_get_classic,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_copy_get,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_copy_from,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        const char*, src_name,
+        int64_t, src_pool,
+        const char*, src_key,
+        const char*, src_nspace,
+        int64_t, src_hash,
+        uint64_t, src_snapid,
+        uint64_t, src_version),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_string(src_name, src_name)
+        ctf_integer(int64_t, src_pool, src_pool)
+        ctf_string(src_key, src_key)
+        ctf_string(src_nspace, src_nspace)
+        ctf_integer(int64_t, src_hash, src_hash)
+        ctf_integer(uint64_t, src_snapid, src_snapid)
+        ctf_integer(uint64_t, src_version, src_version)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_pre_unknown,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        uint16_t, op,
+        const char*, opname),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_integer_hex(uint16_t, op, op)
+        ctf_string(opname, opname)
+    )
+)
+
+TRACEPOINT_EVENT(osd, do_osd_op_post,
+    TP_ARGS(
+        const char*, oid,
+        uint64_t, snap,
+        uint16_t, op,
+        const char*, opname,
+        uint32_t, flags,
+        int, result),
+    TP_FIELDS(
+        ctf_string(oid, oid)
+        ctf_integer(uint64_t, snap, snap)
+        ctf_integer_hex(uint16_t, op, op)
+        ctf_string(opname, opname)
+        ctf_integer_hex(uint32_t, flags, flags)
+        ctf_integer_hex(int, result, result)
+    )
+)