From fb45d6056d4fd11a7434835700d3dc36957aea5a Mon Sep 17 00:00:00 2001 From: Adam Crume Date: Wed, 18 Jun 2014 11:01:19 -0700 Subject: [PATCH] lttng: Trace ReplicatedPG::do_osd_ops Signed-off-by: Adam Crume --- src/osd/ReplicatedPG.cc | 99 +++++- src/tracing/osd.tp | 684 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 781 insertions(+), 2 deletions(-) diff --git a/src/osd/ReplicatedPG.cc b/src/osd/ReplicatedPG.cc index a1fc2dd2cc580..f23ef7526956f 100644 --- a/src/osd/ReplicatedPG.cc +++ b/src/osd/ReplicatedPG.cc @@ -15,6 +15,8 @@ * */ +#include +#include #include "boost/tuple/tuple.hpp" #include "PG.h" #include "ReplicatedPG.h" @@ -2987,7 +2989,13 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& ops) for (vector::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(); @@ -3058,6 +3066,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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) && @@ -3108,6 +3117,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -3128,6 +3138,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -3227,8 +3238,10 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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); @@ -3274,6 +3287,8 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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); @@ -3290,6 +3305,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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++; @@ -3300,6 +3316,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -3312,6 +3329,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -3338,6 +3356,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -3373,6 +3392,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -3400,6 +3420,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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, @@ -3418,6 +3439,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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 out; result = getattrs_maybe_cache( ctx->obc, @@ -3438,6 +3460,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -3509,6 +3532,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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) @@ -3521,6 +3545,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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, watch_info_t>::const_iterator oi_iter; @@ -3547,6 +3572,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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) { @@ -3626,6 +3652,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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) @@ -3649,6 +3676,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -3668,9 +3696,11 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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 @@ -3683,6 +3713,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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); @@ -3704,6 +3735,8 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -3727,7 +3760,6 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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 @@ -3778,6 +3810,8 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -3839,10 +3873,12 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -3868,6 +3904,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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)) { @@ -3910,6 +3947,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -3959,6 +3997,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -3968,6 +4007,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -4001,6 +4041,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -4051,6 +4092,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; } @@ -4068,6 +4110,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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 > to_set; @@ -4094,6 +4137,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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 > to_set; @@ -4117,6 +4161,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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 nops(1); @@ -4132,12 +4177,14 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -4155,6 +4202,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -4213,6 +4261,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -4223,6 +4272,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -4238,8 +4288,10 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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 out_set; if (!pool.info.require_rollback()) { @@ -4273,8 +4325,10 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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 out_set; if (!pool.info.require_rollback()) { @@ -4302,6 +4356,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -4323,8 +4378,10 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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 out; if (!pool.info.require_rollback()) { osd->store->omap_get_values(coll, soid, keys_to_get, &out); @@ -4340,6 +4397,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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 > assertions; @@ -4348,8 +4406,10 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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 out; @@ -4409,6 +4469,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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(); @@ -4425,8 +4486,10 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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::iterator i = to_set.begin(); i != to_set.end(); @@ -4440,6 +4503,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -4459,6 +4523,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -4480,6 +4545,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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(); @@ -4487,6 +4553,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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); @@ -4496,8 +4563,10 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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++; } @@ -4506,6 +4575,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -4513,6 +4583,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -4531,8 +4602,30 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -4561,6 +4654,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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; @@ -4571,6 +4665,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector& 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 fed1b1c5f754a..51f894a9d6c4c 100644 --- 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) + ) +) -- 2.39.5