From: Jason Dillaman Date: Thu, 11 May 2017 15:30:51 +0000 (-0400) Subject: blkin: initial trace hooks for IO path X-Git-Tag: v12.1.0~10^2~67^2~1 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=8f65f61a505de3110066bbc7f63a9ff68bf87575;p=ceph.git blkin: initial trace hooks for IO path To collect blkin traced for RBD, set the "rbd blkin trace all" configuration parameter to true. Signed-off-by: Jason Dillaman --- diff --git a/src/librbd/ImageCtx.cc b/src/librbd/ImageCtx.cc index 8af0c5ef3706..74366f5c633c 100644 --- a/src/librbd/ImageCtx.cc +++ b/src/librbd/ImageCtx.cc @@ -198,7 +198,8 @@ struct C_InvalidateCache : public Context { operations(new Operations<>(*this)), exclusive_lock(nullptr), object_map(nullptr), io_work_queue(nullptr), op_work_queue(nullptr), - asok_hook(nullptr) + asok_hook(nullptr), + trace_endpoint("librbd") { md_ctx.dup(p); data_ctx.dup(p); @@ -269,6 +270,7 @@ struct C_InvalidateCache : public Context { pname += snap_name; } + trace_endpoint.copy_name(pname); perf_start(pname); if (cache) { diff --git a/src/librbd/ImageCtx.h b/src/librbd/ImageCtx.h index 96aee67f943b..499f1e2781fa 100644 --- a/src/librbd/ImageCtx.h +++ b/src/librbd/ImageCtx.h @@ -15,6 +15,7 @@ #include "common/Readahead.h" #include "common/RWLock.h" #include "common/snap_types.h" +#include "common/zipkin_trace.h" #include "include/buffer_fwd.h" #include "include/rbd/librbd.hpp" @@ -35,8 +36,6 @@ class PerfCounters; class ThreadPool; class SafeTimer; -namespace ZTracer { struct Trace; } - namespace librbd { class AsyncOperation; @@ -202,6 +201,8 @@ namespace librbd { exclusive_lock::Policy *exclusive_lock_policy = nullptr; journal::Policy *journal_policy = nullptr; + ZTracer::Endpoint trace_endpoint; + static bool _filter_metadata_confs(const string &prefix, std::map &configs, const map &pairs, map *res); diff --git a/src/librbd/LibrbdWriteback.cc b/src/librbd/LibrbdWriteback.cc index ed5e9d107012..d1dc08c31132 100644 --- a/src/librbd/LibrbdWriteback.cc +++ b/src/librbd/LibrbdWriteback.cc @@ -101,17 +101,19 @@ namespace librbd { uint64_t off; bufferlist bl; SnapContext snapc; - Context *req_comp; uint64_t journal_tid; - bool request_sent; + ZTracer::Trace trace; + Context *req_comp; + bool request_sent = false; C_WriteJournalCommit(ImageCtx *_image_ctx, const std::string &_oid, uint64_t _object_no, uint64_t _off, const bufferlist &_bl, const SnapContext& _snapc, - Context *_req_comp, uint64_t _journal_tid) + uint64_t _journal_tid, + const ZTracer::Trace &trace, Context *_req_comp) : image_ctx(_image_ctx), oid(_oid), object_no(_object_no), off(_off), - bl(_bl), snapc(_snapc), req_comp(_req_comp), journal_tid(_journal_tid), - request_sent(false) { + bl(_bl), snapc(_snapc), journal_tid(_journal_tid), + trace(trace), req_comp(_req_comp) { CephContext *cct = image_ctx->cct; ldout(cct, 20) << this << " C_WriteJournalCommit: " << "delaying write until journal tid " @@ -164,7 +166,7 @@ namespace librbd { request_sent = true; auto req = new io::ObjectWriteRequest(image_ctx, oid, object_no, off, - bl, snapc, this, 0); + bl, snapc, 0, trace, this); req->send(); } }; @@ -264,7 +266,7 @@ namespace librbd { { ZTracer::Trace trace; if (parent_trace.valid()) { - trace.init("", nullptr, &parent_trace); + trace.init("", &m_ictx->trace_endpoint, &parent_trace); trace.copy_name("writeback " + oid.name); trace.event("start"); } @@ -281,12 +283,12 @@ namespace librbd { assert(journal_tid == 0 || m_ictx->journal != NULL); if (journal_tid != 0) { m_ictx->journal->flush_event( - journal_tid, new C_WriteJournalCommit(m_ictx, oid.name, object_no, off, - bl, snapc, req_comp, - journal_tid)); + journal_tid, new C_WriteJournalCommit( + m_ictx, oid.name, object_no, off, bl, snapc, journal_tid, trace, + req_comp)); } else { - auto req = new io::ObjectWriteRequest(m_ictx, oid.name, object_no, - off, bl, snapc, req_comp, 0); + auto req = new io::ObjectWriteRequest( + m_ictx, oid.name, object_no, off, bl, snapc, 0, trace, req_comp); req->send(); } return ++m_tid; diff --git a/src/librbd/Utils.h b/src/librbd/Utils.h index 9a30860531ec..f75d65c43def 100644 --- a/src/librbd/Utils.h +++ b/src/librbd/Utils.h @@ -7,6 +7,7 @@ #include "include/rados/librados.hpp" #include "include/rbd_types.h" #include "include/Context.h" +#include "common/zipkin_trace.h" #include #include @@ -192,6 +193,16 @@ bool calc_sparse_extent(const bufferptr &bp, size_t *write_offset, size_t *write_length, size_t *offset); + +template +inline ZTracer::Trace create_trace(const I &image_ctx, const char *trace_name, + const ZTracer::Trace &parent_trace) { + if (parent_trace.valid()) { + return ZTracer::Trace(trace_name, &image_ctx.trace_endpoint, &parent_trace); + } + return ZTracer::Trace(); +} + } // namespace util } // namespace librbd diff --git a/src/librbd/cache/ImageWriteback.cc b/src/librbd/cache/ImageWriteback.cc index 83c3b5bb14be..cff7a531db29 100644 --- a/src/librbd/cache/ImageWriteback.cc +++ b/src/librbd/cache/ImageWriteback.cc @@ -30,7 +30,7 @@ void ImageWriteback::aio_read(Extents &&image_extents, bufferlist *bl, auto aio_comp = io::AioCompletion::create_and_start(on_finish, &m_image_ctx, io::AIO_TYPE_READ); io::ImageReadRequest req(m_image_ctx, aio_comp, std::move(image_extents), - io::ReadResult{bl}, fadvise_flags); + io::ReadResult{bl}, fadvise_flags, {}); req.set_bypass_image_cache(); req.send(); } @@ -46,14 +46,15 @@ void ImageWriteback::aio_write(Extents &&image_extents, auto aio_comp = io::AioCompletion::create_and_start(on_finish, &m_image_ctx, io::AIO_TYPE_WRITE); io::ImageWriteRequest req(m_image_ctx, aio_comp, std::move(image_extents), - std::move(bl), fadvise_flags); + std::move(bl), fadvise_flags, {}); req.set_bypass_image_cache(); req.send(); } template void ImageWriteback::aio_discard(uint64_t offset, uint64_t length, - bool skip_partial_discard, Context *on_finish) { + bool skip_partial_discard, + Context *on_finish) { CephContext *cct = m_image_ctx.cct; ldout(cct, 20) << "offset=" << offset << ", " << "length=" << length << ", " @@ -62,7 +63,7 @@ void ImageWriteback::aio_discard(uint64_t offset, uint64_t length, auto aio_comp = io::AioCompletion::create_and_start(on_finish, &m_image_ctx, io::AIO_TYPE_DISCARD); io::ImageDiscardRequest req(m_image_ctx, aio_comp, offset, length, - skip_partial_discard); + skip_partial_discard, {}); req.set_bypass_image_cache(); req.send(); } @@ -74,7 +75,7 @@ void ImageWriteback::aio_flush(Context *on_finish) { auto aio_comp = io::AioCompletion::create_and_start(on_finish, &m_image_ctx, io::AIO_TYPE_FLUSH); - io::ImageFlushRequest req(m_image_ctx, aio_comp); + io::ImageFlushRequest req(m_image_ctx, aio_comp, {}); req.set_bypass_image_cache(); req.send(); } @@ -92,7 +93,7 @@ void ImageWriteback::aio_writesame(uint64_t offset, uint64_t length, auto aio_comp = io::AioCompletion::create_and_start(on_finish, &m_image_ctx, io::AIO_TYPE_WRITESAME); io::ImageWriteSameRequest req(m_image_ctx, aio_comp, offset, length, - std::move(bl), fadvise_flags); + std::move(bl), fadvise_flags, {}); req.set_bypass_image_cache(); req.send(); } diff --git a/src/librbd/internal.cc b/src/librbd/internal.cc index 0c5a90bc0c30..b790b3539f76 100644 --- a/src/librbd/internal.cc +++ b/src/librbd/internal.cc @@ -1854,7 +1854,8 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) { m_dest->io_work_queue->aio_write(comp, m_offset + write_offset, write_length, std::move(*write_bl), - LIBRADOS_OP_FLAG_FADVISE_DONTNEED); + LIBRADOS_OP_FLAG_FADVISE_DONTNEED, + std::move(read_trace)); write_offset = offset; write_length = 0; } @@ -1864,6 +1865,8 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) { gather_ctx->activate(); } + ZTracer::Trace read_trace; + private: SimpleThrottle *m_throttle; ImageCtx *m_dest; @@ -1903,10 +1906,16 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) { } } + ZTracer::Trace trace; + if (cct->_conf->rbd_blkin_trace_all) { + trace.init("copy", &src->trace_endpoint); + } + RWLock::RLocker owner_lock(src->owner_lock); SimpleThrottle throttle(src->concurrent_management_ops, false); uint64_t period = src->get_stripe_period(); - unsigned fadvise_flags = LIBRADOS_OP_FLAG_FADVISE_SEQUENTIAL | LIBRADOS_OP_FLAG_FADVISE_NOCACHE; + unsigned fadvise_flags = LIBRADOS_OP_FLAG_FADVISE_SEQUENTIAL | + LIBRADOS_OP_FLAG_FADVISE_NOCACHE; for (uint64_t offset = 0; offset < src_size; offset += period) { if (throttle.pending_error()) { return throttle.wait_for_ret(); @@ -1914,11 +1923,16 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) { uint64_t len = min(period, src_size - offset); bufferlist *bl = new bufferlist(); - Context *ctx = new C_CopyRead(&throttle, dest, offset, bl, sparse_size); - auto comp = io::AioCompletion::create_and_start(ctx, src, - io::AIO_TYPE_READ); - io::ImageRequest<>::aio_read(src, comp, {{offset, len}}, - io::ReadResult{bl}, fadvise_flags); + auto ctx = new C_CopyRead(&throttle, dest, offset, bl, sparse_size); + auto comp = io::AioCompletion::create_and_start( + ctx, src, io::AIO_TYPE_READ); + + io::ImageReadRequest<> req(*src, comp, {{offset, len}}, + io::ReadResult{bl}, fadvise_flags, + std::move(trace)); + ctx->read_trace = req.get_trace(); + + req.send(); prog_ctx.update_progress(offset, src_size); } @@ -2133,6 +2147,11 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) { uint64_t period = ictx->get_stripe_period(); uint64_t left = mylen; + ZTracer::Trace trace; + if (ictx->cct->_conf->rbd_blkin_trace_all) { + trace.init("read_iterate", &ictx->trace_endpoint); + } + RWLock::RLocker owner_locker(ictx->owner_lock); start_time = ceph_clock_now(); while (left > 0) { @@ -2145,7 +2164,7 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) { auto c = io::AioCompletion::create_and_start(&ctx, ictx, io::AIO_TYPE_READ); io::ImageRequest<>::aio_read(ictx, c, {{off, read_len}}, - io::ReadResult{&bl}, 0); + io::ReadResult{&bl}, 0, std::move(trace)); int ret = ctx.wait(); if (ret < 0) { diff --git a/src/librbd/io/CopyupRequest.cc b/src/librbd/io/CopyupRequest.cc index 6ec900f46a3d..395ee7762071 100644 --- a/src/librbd/io/CopyupRequest.cc +++ b/src/librbd/io/CopyupRequest.cc @@ -81,9 +81,12 @@ private: CopyupRequest::CopyupRequest(ImageCtx *ictx, const std::string &oid, - uint64_t objectno, Extents &&image_extents) + uint64_t objectno, Extents &&image_extents, + const ZTracer::Trace &parent_trace) : m_ictx(ictx), m_oid(oid), m_object_no(objectno), - m_image_extents(image_extents), m_state(STATE_READ_FROM_PARENT) + m_image_extents(image_extents), + m_trace(util::create_trace(*m_ictx, "copy-up", parent_trace)), + m_state(STATE_READ_FROM_PARENT) { m_async_op.start_op(*m_ictx); } @@ -151,7 +154,9 @@ bool CopyupRequest::send_copyup() { r = rados.ioctx_create2(m_ictx->data_ctx.get_id(), m_data_ctx); assert(r == 0); - r = m_data_ctx.aio_operate(m_oid, comp, ©up_op, 0, snaps); + r = m_data_ctx.aio_operate( + m_oid, comp, ©up_op, 0, snaps, + (m_trace.valid() ? m_trace.get_info() : nullptr)); assert(r == 0); comp->release(); } @@ -174,7 +179,9 @@ bool CopyupRequest::send_copyup() { snaps.insert(snaps.end(), snapc.snaps.begin(), snapc.snaps.end()); librados::AioCompletion *comp = util::create_rados_callback(this); - r = m_ictx->data_ctx.aio_operate(m_oid, comp, &write_op); + r = m_ictx->data_ctx.aio_operate( + m_oid, comp, &write_op, snapc.seq, snaps, + (m_trace.valid() ? m_trace.get_info() : nullptr)); assert(r == 0); comp->release(); } @@ -204,7 +211,7 @@ void CopyupRequest::send() << ", extents " << m_image_extents << dendl; ImageRequest<>::aio_read(m_ictx->parent, comp, std::move(m_image_extents), - ReadResult{&m_copyup_data}, 0); + ReadResult{&m_copyup_data}, 0, m_trace); } void CopyupRequest::complete(int r) diff --git a/src/librbd/io/CopyupRequest.h b/src/librbd/io/CopyupRequest.h index d2902029c293..0a5b205e92e7 100644 --- a/src/librbd/io/CopyupRequest.h +++ b/src/librbd/io/CopyupRequest.h @@ -8,12 +8,15 @@ #include "include/int_types.h" #include "include/rados/librados.hpp" #include "include/buffer.h" +#include "common/zipkin_trace.h" #include "librbd/io/Types.h" #include #include #include +namespace ZTracer { struct Trace; } + namespace librbd { struct ImageCtx; @@ -26,7 +29,7 @@ template class ObjectRequest; class CopyupRequest { public: CopyupRequest(ImageCtx *ictx, const std::string &oid, uint64_t objectno, - Extents &&image_extents); + Extents &&image_extents, const ZTracer::Trace &parent_trace); ~CopyupRequest(); void append_request(ObjectRequest *req); @@ -77,6 +80,8 @@ private: std::string m_oid; uint64_t m_object_no; Extents m_image_extents; + ZTracer::Trace m_trace; + State m_state; ceph::bufferlist m_copyup_data; std::vector *> m_pending_requests; diff --git a/src/librbd/io/ImageRequest.cc b/src/librbd/io/ImageRequest.cc index b33f536b6c99..80c7208a1440 100644 --- a/src/librbd/io/ImageRequest.cc +++ b/src/librbd/io/ImageRequest.cc @@ -111,41 +111,47 @@ private: template void ImageRequest::aio_read(I *ictx, AioCompletion *c, Extents &&image_extents, - ReadResult &&read_result, int op_flags) { + ReadResult &&read_result, int op_flags, + const ZTracer::Trace &parent_trace) { ImageReadRequest req(*ictx, c, std::move(image_extents), - std::move(read_result), op_flags); + std::move(read_result), op_flags, parent_trace); req.send(); } template void ImageRequest::aio_write(I *ictx, AioCompletion *c, Extents &&image_extents, bufferlist &&bl, - int op_flags) { + int op_flags, + const ZTracer::Trace &parent_trace) { ImageWriteRequest req(*ictx, c, std::move(image_extents), std::move(bl), - op_flags); + op_flags, parent_trace); req.send(); } template void ImageRequest::aio_discard(I *ictx, AioCompletion *c, uint64_t off, uint64_t len, - bool skip_partial_discard) { - ImageDiscardRequest req(*ictx, c, off, len, skip_partial_discard); + bool skip_partial_discard, + const ZTracer::Trace &parent_trace) { + ImageDiscardRequest req(*ictx, c, off, len, skip_partial_discard, + parent_trace); req.send(); } template -void ImageRequest::aio_flush(I *ictx, AioCompletion *c) { - ImageFlushRequest req(*ictx, c); +void ImageRequest::aio_flush(I *ictx, AioCompletion *c, + const ZTracer::Trace &parent_trace) { + ImageFlushRequest req(*ictx, c, parent_trace); req.send(); } template void ImageRequest::aio_writesame(I *ictx, AioCompletion *c, uint64_t off, uint64_t len, - bufferlist &&bl, - int op_flags) { - ImageWriteSameRequest req(*ictx, c, off, len, std::move(bl), op_flags); + bufferlist &&bl, int op_flags, + const ZTracer::Trace &parent_trace) { + ImageWriteSameRequest req(*ictx, c, off, len, std::move(bl), op_flags, + parent_trace); req.send(); } @@ -204,9 +210,10 @@ void ImageRequest::fail(int r) { template ImageReadRequest::ImageReadRequest(I &image_ctx, AioCompletion *aio_comp, Extents &&image_extents, - ReadResult &&read_result, - int op_flags) - : ImageRequest(image_ctx, aio_comp, std::move(image_extents)), + ReadResult &&read_result, int op_flags, + const ZTracer::Trace &parent_trace) + : ImageRequest(image_ctx, aio_comp, std::move(image_extents), "read", + parent_trace), m_op_flags(op_flags) { aio_comp->read_result = std::move(read_result); } @@ -279,17 +286,17 @@ void ImageReadRequest::send_request() { aio_comp); ObjectReadRequest *req = ObjectReadRequest::create( &image_ctx, extent.oid.name, extent.objectno, extent.offset, - extent.length, extent.buffer_extents, snap_id, true, req_comp, - m_op_flags); + extent.length, extent.buffer_extents, snap_id, true, m_op_flags, + this->m_trace, req_comp); req_comp->request = req; if (image_ctx.object_cacher) { C_ObjectCacheRead *cache_comp = new C_ObjectCacheRead(image_ctx, req); - image_ctx.aio_read_from_cache(extent.oid, extent.objectno, - &req->data(), extent.length, - extent.offset, cache_comp, m_op_flags, - nullptr); + image_ctx.aio_read_from_cache( + extent.oid, extent.objectno, &req->data(), extent.length, + extent.offset, cache_comp, m_op_flags, + (this->m_trace.valid() ? &this->m_trace : nullptr)); } else { req->send(); } @@ -470,9 +477,10 @@ void ImageWriteRequest::send_object_cache_requests( AioCompletion *aio_comp = this->m_aio_comp; C_AioRequest *req_comp = new C_AioRequest(aio_comp); - image_ctx.write_to_cache(object_extent.oid, bl, object_extent.length, - object_extent.offset, req_comp, m_op_flags, - journal_tid, nullptr); + image_ctx.write_to_cache( + object_extent.oid, bl, object_extent.length, object_extent.offset, + req_comp, m_op_flags, journal_tid, + (this->m_trace.valid() ? &this->m_trace : nullptr)); } } @@ -500,7 +508,7 @@ ObjectRequestHandle *ImageWriteRequest::create_object_request( assemble_extent(object_extent, &bl); ObjectRequest *req = ObjectRequest::create_write( &image_ctx, object_extent.oid.name, object_extent.objectno, - object_extent.offset, bl, snapc, on_finish, m_op_flags); + object_extent.offset, bl, snapc, m_op_flags, this->m_trace, on_finish); return req; } @@ -601,16 +609,17 @@ ObjectRequestHandle *ImageDiscardRequest::create_object_request( if (object_extent.length == image_ctx.layout.object_size) { req = ObjectRequest::create_remove( &image_ctx, object_extent.oid.name, object_extent.objectno, snapc, - on_finish); + this->m_trace, on_finish); } else if (object_extent.offset + object_extent.length == image_ctx.layout.object_size) { req = ObjectRequest::create_truncate( &image_ctx, object_extent.oid.name, object_extent.objectno, - object_extent.offset, snapc, on_finish); + object_extent.offset, snapc, this->m_trace, on_finish); } else { req = ObjectRequest::create_zero( &image_ctx, object_extent.oid.name, object_extent.objectno, - object_extent.offset, object_extent.length, snapc, on_finish); + object_extent.offset, object_extent.length, snapc, + this->m_trace, on_finish); } return req; } @@ -775,9 +784,10 @@ void ImageWriteSameRequest::send_object_cache_requests( AioCompletion *aio_comp = this->m_aio_comp; C_AioRequest *req_comp = new C_AioRequest(aio_comp); - image_ctx.write_to_cache(object_extent.oid, bl, object_extent.length, - object_extent.offset, req_comp, m_op_flags, - journal_tid, nullptr); + image_ctx.write_to_cache( + object_extent.oid, bl, object_extent.length, object_extent.offset, + req_comp, m_op_flags, journal_tid, + (this->m_trace.valid() ? &this->m_trace : nullptr)); } } @@ -808,13 +818,12 @@ ObjectRequestHandle *ImageWriteSameRequest::create_object_request( req = ObjectRequest::create_writesame( &image_ctx, object_extent.oid.name, object_extent.objectno, object_extent.offset, object_extent.length, - bl, snapc, on_finish, m_op_flags); + bl, snapc, m_op_flags, this->m_trace, on_finish); return req; } req = ObjectRequest::create_write( &image_ctx, object_extent.oid.name, object_extent.objectno, - object_extent.offset, - bl, snapc, on_finish, m_op_flags); + object_extent.offset, bl, snapc, m_op_flags, this->m_trace, on_finish); return req; } diff --git a/src/librbd/io/ImageRequest.h b/src/librbd/io/ImageRequest.h index 6ae7c289c577..21b88b098cf5 100644 --- a/src/librbd/io/ImageRequest.h +++ b/src/librbd/io/ImageRequest.h @@ -7,7 +7,9 @@ #include "include/int_types.h" #include "include/buffer_fwd.h" #include "common/snap_types.h" +#include "common/zipkin_trace.h" #include "osd/osd_types.h" +#include "librbd/Utils.h" #include "librbd/io/Types.h" #include #include @@ -27,18 +29,24 @@ class ImageRequest { public: typedef std::vector > Extents; - virtual ~ImageRequest() {} + virtual ~ImageRequest() { + m_trace.event("finish"); + } static void aio_read(ImageCtxT *ictx, AioCompletion *c, Extents &&image_extents, ReadResult &&read_result, - int op_flags); + int op_flags, const ZTracer::Trace &parent_trace); static void aio_write(ImageCtxT *ictx, AioCompletion *c, - Extents &&image_extents, bufferlist &&bl, int op_flags); + Extents &&image_extents, bufferlist &&bl, int op_flags, + const ZTracer::Trace &parent_trace); static void aio_discard(ImageCtxT *ictx, AioCompletion *c, uint64_t off, - uint64_t len, bool skip_partial_discard); - static void aio_flush(ImageCtxT *ictx, AioCompletion *c); + uint64_t len, bool skip_partial_discard, + const ZTracer::Trace &parent_trace); + static void aio_flush(ImageCtxT *ictx, AioCompletion *c, + const ZTracer::Trace &parent_trace); static void aio_writesame(ImageCtxT *ictx, AioCompletion *c, uint64_t off, - uint64_t len, bufferlist &&bl, int op_flags); + uint64_t len, bufferlist &&bl, int op_flags, + const ZTracer::Trace &parent_trace); virtual bool is_write_op() const { return false; @@ -53,19 +61,28 @@ public: m_bypass_image_cache = true; } + inline const ZTracer::Trace &get_trace() const { + return m_trace; + } + protected: typedef std::list ObjectRequests; ImageCtxT &m_image_ctx; AioCompletion *m_aio_comp; Extents m_image_extents; + ZTracer::Trace m_trace; bool m_bypass_image_cache = false; ImageRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp, - Extents &&image_extents) + Extents &&image_extents, const char *trace_name, + const ZTracer::Trace &parent_trace) : m_image_ctx(image_ctx), m_aio_comp(aio_comp), - m_image_extents(image_extents) { + m_image_extents(std::move(image_extents)), + m_trace(util::create_trace(image_ctx, trace_name, parent_trace)) { + m_trace.event("start"); } + virtual int clip_request(); virtual void send_request() = 0; @@ -82,7 +99,7 @@ public: ImageReadRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp, Extents &&image_extents, ReadResult &&read_result, - int op_flags); + int op_flags, const ZTracer::Trace &parent_trace); protected: int clip_request() override; @@ -120,8 +137,10 @@ protected: typedef std::vector ObjectExtents; AbstractImageWriteRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp, - Extents &&image_extents) - : ImageRequest(image_ctx, aio_comp, std::move(image_extents)), + Extents &&image_extents, const char *trace_name, + const ZTracer::Trace &parent_trace) + : ImageRequest(image_ctx, aio_comp, std::move(image_extents), + trace_name, parent_trace), m_synchronous(false) { } @@ -156,9 +175,10 @@ public: using typename ImageRequest::Extents; ImageWriteRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp, - Extents &&image_extents, bufferlist &&bl, int op_flags) - : AbstractImageWriteRequest(image_ctx, aio_comp, - std::move(image_extents)), + Extents &&image_extents, bufferlist &&bl, int op_flags, + const ZTracer::Trace &parent_trace) + : AbstractImageWriteRequest( + image_ctx, aio_comp, std::move(image_extents), "write", parent_trace), m_bl(std::move(bl)), m_op_flags(op_flags) { } @@ -201,8 +221,10 @@ template class ImageDiscardRequest : public AbstractImageWriteRequest { public: ImageDiscardRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp, - uint64_t off, uint64_t len, bool skip_partial_discard) - : AbstractImageWriteRequest(image_ctx, aio_comp, {{off, len}}), + uint64_t off, uint64_t len, bool skip_partial_discard, + const ZTracer::Trace &parent_trace) + : AbstractImageWriteRequest( + image_ctx, aio_comp, {{off, len}}, "discard", parent_trace), m_skip_partial_discard(skip_partial_discard) { } @@ -239,8 +261,9 @@ private: template class ImageFlushRequest : public ImageRequest { public: - ImageFlushRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp) - : ImageRequest(image_ctx, aio_comp, {}) { + ImageFlushRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp, + const ZTracer::Trace &parent_trace) + : ImageRequest(image_ctx, aio_comp, {}, "flush", parent_trace) { } bool is_write_op() const override { @@ -269,8 +292,9 @@ class ImageWriteSameRequest : public AbstractImageWriteRequest { public: ImageWriteSameRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp, uint64_t off, uint64_t len, bufferlist &&bl, - int op_flags) - : AbstractImageWriteRequest(image_ctx, aio_comp, {{off, len}}), + int op_flags, const ZTracer::Trace &parent_trace) + : AbstractImageWriteRequest( + image_ctx, aio_comp, {{off, len}}, "writesame", parent_trace), m_data_bl(std::move(bl)), m_op_flags(op_flags) { } diff --git a/src/librbd/io/ImageRequestWQ.cc b/src/librbd/io/ImageRequestWQ.cc index d7c9fa352477..2758790eb087 100644 --- a/src/librbd/io/ImageRequestWQ.cc +++ b/src/librbd/io/ImageRequestWQ.cc @@ -3,6 +3,7 @@ #include "librbd/io/ImageRequestWQ.h" #include "common/errno.h" +#include "common/zipkin_trace.h" #include "librbd/ExclusiveLock.h" #include "librbd/ImageCtx.h" #include "librbd/ImageState.h" @@ -122,8 +123,14 @@ ssize_t ImageRequestWQ::writesame(uint64_t off, uint64_t len, bufferlist &&bl, void ImageRequestWQ::aio_read(AioCompletion *c, uint64_t off, uint64_t len, ReadResult &&read_result, int op_flags, bool native_async) { - c->init_time(&m_image_ctx, AIO_TYPE_READ); CephContext *cct = m_image_ctx.cct; + ZTracer::Trace trace; + if (cct->_conf->rbd_blkin_trace_all) { + trace.init("wq: read", &m_image_ctx.trace_endpoint); + trace.event("start"); + } + + c->init_time(&m_image_ctx, AIO_TYPE_READ); ldout(cct, 20) << "ictx=" << &m_image_ctx << ", " << "completion=" << c << ", off=" << off << ", " << "len=" << len << ", " << "flags=" << op_flags << dendl; @@ -149,20 +156,27 @@ void ImageRequestWQ::aio_read(AioCompletion *c, uint64_t off, uint64_t len, if (m_image_ctx.non_blocking_aio || writes_blocked() || !writes_empty() || lock_required) { queue(new ImageReadRequest<>(m_image_ctx, c, {{off, len}}, - std::move(read_result), op_flags)); + std::move(read_result), op_flags, trace)); } else { c->start_op(); ImageRequest<>::aio_read(&m_image_ctx, c, {{off, len}}, - std::move(read_result), op_flags); + std::move(read_result), op_flags, trace); finish_in_flight_op(); } + trace.event("finish"); } void ImageRequestWQ::aio_write(AioCompletion *c, uint64_t off, uint64_t len, bufferlist &&bl, int op_flags, bool native_async) { - c->init_time(&m_image_ctx, AIO_TYPE_WRITE); CephContext *cct = m_image_ctx.cct; + ZTracer::Trace trace; + if (cct->_conf->rbd_blkin_trace_all) { + trace.init("wq: write", &m_image_ctx.trace_endpoint); + trace.event("init"); + } + + c->init_time(&m_image_ctx, AIO_TYPE_WRITE); ldout(cct, 20) << "ictx=" << &m_image_ctx << ", " << "completion=" << c << ", off=" << off << ", " << "len=" << len << ", flags=" << op_flags << dendl; @@ -178,20 +192,27 @@ void ImageRequestWQ::aio_write(AioCompletion *c, uint64_t off, uint64_t len, RWLock::RLocker owner_locker(m_image_ctx.owner_lock); if (m_image_ctx.non_blocking_aio || writes_blocked()) { queue(new ImageWriteRequest<>(m_image_ctx, c, {{off, len}}, - std::move(bl), op_flags)); + std::move(bl), op_flags, trace)); } else { c->start_op(); ImageRequest<>::aio_write(&m_image_ctx, c, {{off, len}}, - std::move(bl), op_flags); + std::move(bl), op_flags, trace); finish_in_flight_op(); } + trace.event("finish"); } void ImageRequestWQ::aio_discard(AioCompletion *c, uint64_t off, uint64_t len, bool skip_partial_discard, bool native_async) { - c->init_time(&m_image_ctx, AIO_TYPE_DISCARD); CephContext *cct = m_image_ctx.cct; + ZTracer::Trace trace; + if (cct->_conf->rbd_blkin_trace_all) { + trace.init("wq: discard", &m_image_ctx.trace_endpoint); + trace.event("init"); + } + + c->init_time(&m_image_ctx, AIO_TYPE_DISCARD); ldout(cct, 20) << "ictx=" << &m_image_ctx << ", " << "completion=" << c << ", off=" << off << ", len=" << len << dendl; @@ -206,17 +227,26 @@ void ImageRequestWQ::aio_discard(AioCompletion *c, uint64_t off, RWLock::RLocker owner_locker(m_image_ctx.owner_lock); if (m_image_ctx.non_blocking_aio || writes_blocked()) { - queue(new ImageDiscardRequest<>(m_image_ctx, c, off, len, skip_partial_discard)); + queue(new ImageDiscardRequest<>(m_image_ctx, c, off, len, + skip_partial_discard, trace)); } else { c->start_op(); - ImageRequest<>::aio_discard(&m_image_ctx, c, off, len, skip_partial_discard); + ImageRequest<>::aio_discard(&m_image_ctx, c, off, len, + skip_partial_discard, trace); finish_in_flight_op(); } + trace.event("finish"); } void ImageRequestWQ::aio_flush(AioCompletion *c, bool native_async) { - c->init_time(&m_image_ctx, AIO_TYPE_FLUSH); CephContext *cct = m_image_ctx.cct; + ZTracer::Trace trace; + if (cct->_conf->rbd_blkin_trace_all) { + trace.init("wq: flush", &m_image_ctx.trace_endpoint); + trace.event("init"); + } + + c->init_time(&m_image_ctx, AIO_TYPE_FLUSH); ldout(cct, 20) << "ictx=" << &m_image_ctx << ", " << "completion=" << c << dendl; @@ -230,18 +260,25 @@ void ImageRequestWQ::aio_flush(AioCompletion *c, bool native_async) { RWLock::RLocker owner_locker(m_image_ctx.owner_lock); if (m_image_ctx.non_blocking_aio || writes_blocked() || !writes_empty()) { - queue(new ImageFlushRequest<>(m_image_ctx, c)); + queue(new ImageFlushRequest<>(m_image_ctx, c, trace)); } else { - ImageRequest<>::aio_flush(&m_image_ctx, c); + ImageRequest<>::aio_flush(&m_image_ctx, c, trace); finish_in_flight_op(); } + trace.event("finish"); } void ImageRequestWQ::aio_writesame(AioCompletion *c, uint64_t off, uint64_t len, bufferlist &&bl, int op_flags, bool native_async) { - c->init_time(&m_image_ctx, AIO_TYPE_WRITESAME); CephContext *cct = m_image_ctx.cct; + ZTracer::Trace trace; + if (cct->_conf->rbd_blkin_trace_all) { + trace.init("wq: writesame", &m_image_ctx.trace_endpoint); + trace.event("init"); + } + + c->init_time(&m_image_ctx, AIO_TYPE_WRITESAME); ldout(cct, 20) << "ictx=" << &m_image_ctx << ", " << "completion=" << c << ", off=" << off << ", " << "len=" << len << ", data_len = " << bl.length() << ", " @@ -258,13 +295,14 @@ void ImageRequestWQ::aio_writesame(AioCompletion *c, uint64_t off, uint64_t len, RWLock::RLocker owner_locker(m_image_ctx.owner_lock); if (m_image_ctx.non_blocking_aio || writes_blocked()) { queue(new ImageWriteSameRequest<>(m_image_ctx, c, off, len, std::move(bl), - op_flags)); + op_flags, trace)); } else { c->start_op(); ImageRequest<>::aio_writesame(&m_image_ctx, c, off, len, std::move(bl), - op_flags); + op_flags, trace); finish_in_flight_op(); } + trace.event("finish"); } void ImageRequestWQ::shut_down(Context *on_shutdown) { diff --git a/src/librbd/io/ObjectRequest.cc b/src/librbd/io/ObjectRequest.cc index 54a3a8b2315a..59e984a4ae40 100644 --- a/src/librbd/io/ObjectRequest.cc +++ b/src/librbd/io/ObjectRequest.cc @@ -35,9 +35,10 @@ ObjectRequest* ObjectRequest::create_remove(I *ictx, const std::string &oid, uint64_t object_no, const ::SnapContext &snapc, + const ZTracer::Trace &parent_trace, Context *completion) { return new ObjectRemoveRequest(util::get_image_ctx(ictx), oid, object_no, - snapc, completion); + snapc, parent_trace, completion); } template @@ -45,9 +46,10 @@ ObjectRequest* ObjectRequest::create_truncate(I *ictx, const std::string &oid, uint64_t object_no, uint64_t object_off, const ::SnapContext &snapc, - Context *completion) { + const ZTracer::Trace &parent_trace, + Context *completion) { return new ObjectTruncateRequest(util::get_image_ctx(ictx), oid, object_no, - object_off, snapc, completion); + object_off, snapc, parent_trace, completion); } template @@ -55,10 +57,12 @@ ObjectRequest* ObjectRequest::create_write(I *ictx, const std::string &oid, uint64_t object_no, uint64_t object_off, const ceph::bufferlist &data, - const ::SnapContext &snapc, - Context *completion, int op_flags) { + const ::SnapContext &snapc, int op_flags, + const ZTracer::Trace &parent_trace, + Context *completion) { return new ObjectWriteRequest(util::get_image_ctx(ictx), oid, object_no, - object_off, data, snapc, completion, op_flags); + object_off, data, snapc, op_flags, parent_trace, + completion); } template @@ -67,9 +71,11 @@ ObjectRequest::create_zero(I *ictx, const std::string &oid, uint64_t object_no, uint64_t object_off, uint64_t object_len, const ::SnapContext &snapc, + const ZTracer::Trace &parent_trace, Context *completion) { return new ObjectZeroRequest(util::get_image_ctx(ictx), oid, object_no, - object_off, object_len, snapc, completion); + object_off, object_len, snapc, parent_trace, + completion); } template @@ -78,21 +84,29 @@ ObjectRequest::create_writesame(I *ictx, const std::string &oid, uint64_t object_no, uint64_t object_off, uint64_t object_len, const ceph::bufferlist &data, - const ::SnapContext &snapc, - Context *completion, int op_flags) { + const ::SnapContext &snapc, int op_flags, + const ZTracer::Trace &parent_trace, + Context *completion) { return new ObjectWriteSameRequest(util::get_image_ctx(ictx), oid, object_no, object_off, object_len, data, snapc, - completion, op_flags); + op_flags, parent_trace, completion); } template ObjectRequest::ObjectRequest(ImageCtx *ictx, const std::string &oid, uint64_t objectno, uint64_t off, uint64_t len, librados::snap_t snap_id, - Context *completion, bool hide_enoent) + bool hide_enoent, const char *trace_name, + const ZTracer::Trace &trace, + Context *completion) : m_ictx(ictx), m_oid(oid), m_object_no(objectno), m_object_off(off), m_object_len(len), m_snap_id(snap_id), m_completion(completion), - m_hide_enoent(hide_enoent) { + m_hide_enoent(hide_enoent), + m_trace(util::create_trace(*ictx, "", trace)) { + if (m_trace.valid()) { + m_trace.copy_name(trace_name + std::string(" ") + oid); + m_trace.event("start"); + } Striper::extent_to_file(m_ictx->cct, &m_ictx->layout, m_object_no, 0, m_ictx->layout.object_size, m_parent_extents); @@ -159,9 +173,11 @@ ObjectReadRequest::ObjectReadRequest(I *ictx, const std::string &oid, uint64_t objectno, uint64_t offset, uint64_t len, Extents& be, librados::snap_t snap_id, bool sparse, - Context *completion, int op_flags) + int op_flags, + const ZTracer::Trace &parent_trace, + Context *completion) : ObjectRequest(util::get_image_ctx(ictx), oid, objectno, offset, len, - snap_id, completion, false), + snap_id, false, "read", parent_trace, completion), m_buffer_extents(be), m_tried_parent(false), m_sparse(sparse), m_op_flags(op_flags), m_state(LIBRBD_AIO_READ_FLAT) { guard_read(); @@ -289,8 +305,9 @@ void ObjectReadRequest::send() { librados::AioCompletion *rados_completion = util::create_rados_callback(this); - int r = image_ctx->data_ctx.aio_operate(this->m_oid, rados_completion, &op, - flags, nullptr); + int r = image_ctx->data_ctx.aio_operate( + this->m_oid, rados_completion, &op, flags, nullptr, + (this->m_trace.valid() ? this->m_trace.get_info() : nullptr)); assert(r == 0); rados_completion->release(); @@ -320,7 +337,7 @@ void ObjectReadRequest::send_copyup() // create and kick off a CopyupRequest CopyupRequest *new_req = new CopyupRequest( image_ctx, this->m_oid, this->m_object_no, - std::move(this->m_parent_extents)); + std::move(this->m_parent_extents), this->m_trace); this->m_parent_extents.clear(); image_ctx->copyup_list[this->m_object_no] = new_req; @@ -339,7 +356,7 @@ void ObjectReadRequest::read_from_parent(Extents&& parent_extents) << " extents " << parent_extents << dendl; ImageRequest<>::aio_read(image_ctx->parent, parent_completion, std::move(parent_extents), - ReadResult{&m_read_data}, 0); + ReadResult{&m_read_data}, 0, this->m_trace); } /** write **/ @@ -350,10 +367,12 @@ AbstractObjectWriteRequest::AbstractObjectWriteRequest(ImageCtx *ictx, uint64_t object_off, uint64_t len, const ::SnapContext &snapc, - Context *completion, - bool hide_enoent) + bool hide_enoent, + const char *trace_name, + const ZTracer::Trace &parent_trace, + Context *completion) : ObjectRequest(ictx, oid, object_no, object_off, len, CEPH_NOSNAP, - completion, hide_enoent), + hide_enoent, trace_name, parent_trace, completion), m_state(LIBRBD_AIO_WRITE_FLAT), m_snap_seq(snapc.seq.val) { m_snaps.insert(m_snaps.end(), snapc.snaps.begin(), snapc.snaps.end()); @@ -527,7 +546,8 @@ void AbstractObjectWriteRequest::send_copyup() if (it == m_ictx->copyup_list.end()) { CopyupRequest *new_req = new CopyupRequest(m_ictx, m_oid, m_object_no, - std::move(m_parent_extents)); + std::move(m_parent_extents), + this->m_trace); m_parent_extents.clear(); // make sure to wait on this CopyupRequest @@ -553,8 +573,9 @@ void AbstractObjectWriteRequest::send_write_op() librados::AioCompletion *rados_completion = util::create_rados_callback(this); - int r = m_ictx->data_ctx.aio_operate(m_oid, rados_completion, &m_write, - m_snap_seq, m_snaps); + int r = m_ictx->data_ctx.aio_operate( + m_oid, rados_completion, &m_write, m_snap_seq, m_snaps, + (this->m_trace.valid() ? this->m_trace.get_info() : nullptr)); assert(r == 0); rados_completion->release(); } diff --git a/src/librbd/io/ObjectRequest.h b/src/librbd/io/ObjectRequest.h index 7f0037265196..85529a193563 100644 --- a/src/librbd/io/ObjectRequest.h +++ b/src/librbd/io/ObjectRequest.h @@ -5,13 +5,12 @@ #define CEPH_LIBRBD_IO_OBJECT_REQUEST_H #include "include/int_types.h" - -#include - -#include "common/snap_types.h" #include "include/buffer.h" #include "include/rados/librados.hpp" +#include "common/snap_types.h" +#include "common/zipkin_trace.h" #include "librbd/ObjectMap.h" +#include class Context; @@ -50,23 +49,27 @@ public: const std::string &oid, uint64_t object_no, const ::SnapContext &snapc, + const ZTracer::Trace &parent_trace, Context *completion); static ObjectRequest* create_truncate(ImageCtxT *ictx, const std::string &oid, uint64_t object_no, uint64_t object_off, const ::SnapContext &snapc, + const ZTracer::Trace &parent_trace, Context *completion); static ObjectRequest* create_write(ImageCtxT *ictx, const std::string &oid, uint64_t object_no, uint64_t object_off, const ceph::bufferlist &data, - const ::SnapContext &snapc, - Context *completion, int op_flags); + const ::SnapContext &snapc, int op_flags, + const ZTracer::Trace &parent_trace, + Context *completion); static ObjectRequest* create_zero(ImageCtxT *ictx, const std::string &oid, uint64_t object_no, uint64_t object_off, uint64_t object_len, const ::SnapContext &snapc, + const ZTracer::Trace &parent_trace, Context *completion); static ObjectRequest* create_writesame(ImageCtxT *ictx, const std::string &oid, @@ -75,13 +78,18 @@ public: uint64_t object_len, const ceph::bufferlist &data, const ::SnapContext &snapc, - Context *completion, int op_flags); + int op_flags, + const ZTracer::Trace &parent_trace, + Context *completion); ObjectRequest(ImageCtx *ictx, const std::string &oid, uint64_t objectno, uint64_t off, uint64_t len, - librados::snap_t snap_id, - Context *completion, bool hide_enoent); - ~ObjectRequest() override {} + librados::snap_t snap_id, bool hide_enoent, + const char *trace_name, const ZTracer::Trace &parent_trace, + Context *completion); + ~ObjectRequest() override { + m_trace.event("finish"); + } virtual void add_copyup_ops(librados::ObjectWriteOperation *wr, bool set_hints) { @@ -113,6 +121,7 @@ protected: Context *m_completion; Extents m_parent_extents; bool m_hide_enoent; + ZTracer::Trace m_trace; private: bool m_has_parent = false; @@ -128,16 +137,19 @@ public: uint64_t objectno, uint64_t offset, uint64_t len, Extents &buffer_extents, librados::snap_t snap_id, bool sparse, - Context *completion, int op_flags) { + int op_flags, + const ZTracer::Trace &parent_trace, + Context *completion) { return new ObjectReadRequest(ictx, oid, objectno, offset, len, - buffer_extents, snap_id, sparse, completion, - op_flags); + buffer_extents, snap_id, sparse, op_flags, + parent_trace, completion); } ObjectReadRequest(ImageCtxT *ictx, const std::string &oid, uint64_t objectno, uint64_t offset, uint64_t len, Extents& buffer_extents, librados::snap_t snap_id, - bool sparse, Context *completion, int op_flags); + bool sparse, int op_flags, + const ZTracer::Trace &parent_trace, Context *completion); bool should_complete(int r) override; void send() override; @@ -209,7 +221,9 @@ public: AbstractObjectWriteRequest(ImageCtx *ictx, const std::string &oid, uint64_t object_no, uint64_t object_off, uint64_t len, const ::SnapContext &snapc, - Context *completion, bool hide_enoent); + bool hide_enoent, const char *trace_name, + const ZTracer::Trace &parent_trace, + Context *completion); void add_copyup_ops(librados::ObjectWriteOperation *wr, bool set_hints) override @@ -294,10 +308,11 @@ class ObjectWriteRequest : public AbstractObjectWriteRequest { public: ObjectWriteRequest(ImageCtx *ictx, const std::string &oid, uint64_t object_no, uint64_t object_off, const ceph::bufferlist &data, - const ::SnapContext &snapc, Context *completion, - int op_flags) + const ::SnapContext &snapc, int op_flags, + const ZTracer::Trace &parent_trace, Context *completion) : AbstractObjectWriteRequest(ictx, oid, object_no, object_off, - data.length(), snapc, completion, false), + data.length(), snapc, false, "write", + parent_trace, completion), m_write_data(data), m_op_flags(op_flags) { } @@ -329,9 +344,9 @@ class ObjectRemoveRequest : public AbstractObjectWriteRequest { public: ObjectRemoveRequest(ImageCtx *ictx, const std::string &oid, uint64_t object_no, const ::SnapContext &snapc, - Context *completion) - : AbstractObjectWriteRequest(ictx, oid, object_no, 0, 0, snapc, completion, - true), + const ZTracer::Trace &parent_trace, Context *completion) + : AbstractObjectWriteRequest(ictx, oid, object_no, 0, 0, snapc, true, + "remote", parent_trace, completion), m_object_state(OBJECT_NONEXISTENT) { } @@ -382,10 +397,10 @@ public: // update is needed. pre update is decided as usual (by checking // the state of the object in the map). ObjectTrimRequest(ImageCtx *ictx, const std::string &oid, uint64_t object_no, - const ::SnapContext &snapc, Context *completion, - bool post_object_map_update) - : AbstractObjectWriteRequest(ictx, oid, object_no, 0, 0, snapc, completion, - true), + const ::SnapContext &snapc, bool post_object_map_update, + Context *completion) + : AbstractObjectWriteRequest(ictx, oid, object_no, 0, 0, snapc, true, + "trim", {}, completion), m_post_object_map_update(post_object_map_update) { } @@ -416,9 +431,10 @@ class ObjectTruncateRequest : public AbstractObjectWriteRequest { public: ObjectTruncateRequest(ImageCtx *ictx, const std::string &oid, uint64_t object_no, uint64_t object_off, - const ::SnapContext &snapc, Context *completion) + const ::SnapContext &snapc, + const ZTracer::Trace &parent_trace, Context *completion) : AbstractObjectWriteRequest(ictx, oid, object_no, object_off, 0, snapc, - completion, true) { + true, "truncate", parent_trace, completion) { } const char* get_op_type() const override { @@ -446,9 +462,11 @@ class ObjectZeroRequest : public AbstractObjectWriteRequest { public: ObjectZeroRequest(ImageCtx *ictx, const std::string &oid, uint64_t object_no, uint64_t object_off, uint64_t object_len, - const ::SnapContext &snapc, Context *completion) + const ::SnapContext &snapc, + const ZTracer::Trace &parent_trace, Context *completion) : AbstractObjectWriteRequest(ictx, oid, object_no, object_off, object_len, - snapc, completion, true) { + snapc, true, "zero", parent_trace, + completion) { } const char* get_op_type() const override { @@ -469,13 +487,15 @@ protected: class ObjectWriteSameRequest : public AbstractObjectWriteRequest { public: - ObjectWriteSameRequest(ImageCtx *ictx, const std::string &oid, uint64_t object_no, - uint64_t object_off, uint64_t object_len, - const ceph::bufferlist &data, - const ::SnapContext &snapc, Context *completion, - int op_flags) + ObjectWriteSameRequest(ImageCtx *ictx, const std::string &oid, + uint64_t object_no, uint64_t object_off, + uint64_t object_len, const ceph::bufferlist &data, + const ::SnapContext &snapc, int op_flags, + const ZTracer::Trace &parent_trace, + Context *completion) : AbstractObjectWriteRequest(ictx, oid, object_no, object_off, - object_len, snapc, completion, false), + object_len, snapc, false, "writesame", + parent_trace, completion), m_write_data(data), m_op_flags(op_flags) { } diff --git a/src/librbd/journal/Replay.cc b/src/librbd/journal/Replay.cc index 624b213b8f66..2d408d5b8eba 100644 --- a/src/librbd/journal/Replay.cc +++ b/src/librbd/journal/Replay.cc @@ -249,7 +249,7 @@ void Replay::shut_down(bool cancel_ops, Context *on_finish) { // execute the following outside of lock scope if (flush_comp != nullptr) { RWLock::RLocker owner_locker(m_image_ctx.owner_lock); - io::ImageRequest::aio_flush(&m_image_ctx, flush_comp); + io::ImageRequest::aio_flush(&m_image_ctx, flush_comp, {}); } if (on_finish != nullptr) { on_finish->complete(0); @@ -266,7 +266,7 @@ void Replay::flush(Context *on_finish) { } RWLock::RLocker owner_locker(m_image_ctx.owner_lock); - io::ImageRequest::aio_flush(&m_image_ctx, aio_comp); + io::ImageRequest::aio_flush(&m_image_ctx, aio_comp, {}); } template @@ -319,13 +319,14 @@ void Replay::handle_event(const journal::AioDiscardEvent &event, io::AIO_TYPE_DISCARD, &flush_required); io::ImageRequest::aio_discard(&m_image_ctx, aio_comp, event.offset, - event.length, event.skip_partial_discard); + event.length, event.skip_partial_discard, + {}); if (flush_required) { m_lock.Lock(); auto flush_comp = create_aio_flush_completion(nullptr); m_lock.Unlock(); - io::ImageRequest::aio_flush(&m_image_ctx, flush_comp); + io::ImageRequest::aio_flush(&m_image_ctx, flush_comp, {}); } } @@ -342,13 +343,13 @@ void Replay::handle_event(const journal::AioWriteEvent &event, &flush_required); io::ImageRequest::aio_write(&m_image_ctx, aio_comp, {{event.offset, event.length}}, - std::move(data), 0); + std::move(data), 0, {}); if (flush_required) { m_lock.Lock(); auto flush_comp = create_aio_flush_completion(nullptr); m_lock.Unlock(); - io::ImageRequest::aio_flush(&m_image_ctx, flush_comp); + io::ImageRequest::aio_flush(&m_image_ctx, flush_comp, {}); } } @@ -363,7 +364,7 @@ void Replay::handle_event(const journal::AioFlushEvent &event, Mutex::Locker locker(m_lock); aio_comp = create_aio_flush_completion(on_safe); } - io::ImageRequest::aio_flush(&m_image_ctx, aio_comp); + io::ImageRequest::aio_flush(&m_image_ctx, aio_comp, {}); on_ready->complete(0); } @@ -380,13 +381,13 @@ void Replay::handle_event(const journal::AioWriteSameEvent &event, io::AIO_TYPE_WRITESAME, &flush_required); io::ImageRequest::aio_writesame(&m_image_ctx, aio_comp, event.offset, - event.length, std::move(data), 0); + event.length, std::move(data), 0, {}); if (flush_required) { m_lock.Lock(); auto flush_comp = create_aio_flush_completion(nullptr); m_lock.Unlock(); - io::ImageRequest::aio_flush(&m_image_ctx, flush_comp); + io::ImageRequest::aio_flush(&m_image_ctx, flush_comp, {}); } } diff --git a/src/librbd/operation/FlattenRequest.cc b/src/librbd/operation/FlattenRequest.cc index 2cfa1ad1c13a..e01dc2bc67b7 100644 --- a/src/librbd/operation/FlattenRequest.cc +++ b/src/librbd/operation/FlattenRequest.cc @@ -42,7 +42,7 @@ public: bufferlist bl; string oid = image_ctx.get_object_name(m_object_no); auto req = new io::ObjectWriteRequest(&image_ctx, oid, m_object_no, 0, - bl, m_snapc, this, 0); + bl, m_snapc, 0, {}, this); if (!req->has_parent()) { // stop early if the parent went away - it just means // another flatten finished first or the image was resized diff --git a/src/librbd/operation/TrimRequest.cc b/src/librbd/operation/TrimRequest.cc index 5c59e3c16a78..60b0c79f65d2 100644 --- a/src/librbd/operation/TrimRequest.cc +++ b/src/librbd/operation/TrimRequest.cc @@ -46,7 +46,7 @@ public: ldout(image_ctx.cct, 10) << "removing (with copyup) " << oid << dendl; auto req = new io::ObjectTrimRequest(&image_ctx, oid, m_object_no, - m_snapc, this, false); + m_snapc, false, this); req->send(); return 0; } @@ -416,10 +416,10 @@ void TrimRequest::send_clean_boundary() { io::ObjectRequest<> *req; if (p->offset == 0) { req = new io::ObjectTrimRequest(&image_ctx, p->oid.name, p->objectno, - snapc, req_comp, true); + snapc, true, req_comp); } else { req = new io::ObjectTruncateRequest(&image_ctx, p->oid.name, p->objectno, - p->offset, snapc, req_comp); + p->offset, snapc, {}, req_comp); } req->send(); } diff --git a/src/test/librbd/io/test_mock_ImageRequest.cc b/src/test/librbd/io/test_mock_ImageRequest.cc index 6cac1de9313a..7a11c2c6ab1c 100644 --- a/src/test/librbd/io/test_mock_ImageRequest.cc +++ b/src/test/librbd/io/test_mock_ImageRequest.cc @@ -38,6 +38,7 @@ struct ObjectRequest : public ObjectRequestHandle { const std::string &oid, uint64_t object_no, const ::SnapContext &snapc, + const ZTracer::Trace &parent_trace, Context *completion) { assert(s_instance != nullptr); s_instance->on_finish = completion; @@ -49,6 +50,7 @@ struct ObjectRequest : public ObjectRequestHandle { uint64_t object_no, uint64_t object_off, const ::SnapContext &snapc, + const ZTracer::Trace &parent_trace, Context *completion) { assert(s_instance != nullptr); s_instance->on_finish = completion; @@ -60,8 +62,9 @@ struct ObjectRequest : public ObjectRequestHandle { uint64_t object_no, uint64_t object_off, const ceph::bufferlist &data, - const ::SnapContext &snapc, - Context *completion, int op_flags) { + const ::SnapContext &snapc, int op_flags, + const ZTracer::Trace &parent_trace, + Context *completion) { assert(s_instance != nullptr); s_instance->on_finish = completion; return s_instance; @@ -72,6 +75,7 @@ struct ObjectRequest : public ObjectRequestHandle { uint64_t object_no, uint64_t object_off, uint64_t object_len, const ::SnapContext &snapc, + const ZTracer::Trace &parent_trace, Context *completion) { assert(s_instance != nullptr); s_instance->on_finish = completion; @@ -85,7 +89,9 @@ struct ObjectRequest : public ObjectRequestHandle { uint64_t object_len, const ceph::bufferlist &data, const ::SnapContext &snapc, - Context *completion, int op_flags) { + int op_flags, + const ZTracer::Trace &parent_trace, + Context *completion) { assert(s_instance != nullptr); s_instance->on_finish = completion; return s_instance; @@ -115,7 +121,9 @@ struct ObjectReadRequest : public ObjectRequeston_finish = completion; return s_instance; @@ -224,7 +232,7 @@ TEST_F(TestMockIoImageRequest, AioWriteJournalAppendDisabled) { bufferlist bl; bl.append("1"); MockImageWriteRequest mock_aio_image_write(mock_image_ctx, aio_comp, - {{0, 1}}, std::move(bl), 0); + {{0, 1}}, std::move(bl), 0, {}); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); mock_aio_image_write.send(); @@ -253,7 +261,9 @@ TEST_F(TestMockIoImageRequest, AioDiscardJournalAppendDisabled) { AioCompletion *aio_comp = AioCompletion::create_and_start( &aio_comp_ctx, ictx, AIO_TYPE_DISCARD); MockImageDiscardRequest mock_aio_image_discard(mock_image_ctx, aio_comp, - 0, 1, ictx->skip_partial_discard); + 0, 1, + ictx->skip_partial_discard, + {}); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); mock_aio_image_discard.send(); @@ -279,7 +289,7 @@ TEST_F(TestMockIoImageRequest, AioFlushJournalAppendDisabled) { C_SaferCond aio_comp_ctx; AioCompletion *aio_comp = AioCompletion::create_and_start( &aio_comp_ctx, ictx, AIO_TYPE_FLUSH); - MockImageFlushRequest mock_aio_image_flush(mock_image_ctx, aio_comp); + MockImageFlushRequest mock_aio_image_flush(mock_image_ctx, aio_comp, {}); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); mock_aio_image_flush.send(); @@ -315,7 +325,8 @@ TEST_F(TestMockIoImageRequest, AioWriteSameJournalAppendDisabled) { bufferlist bl; bl.append("1"); MockImageWriteSameRequest mock_aio_image_writesame(mock_image_ctx, aio_comp, - 0, 1, std::move(bl), 0); + 0, 1, std::move(bl), 0, + {}); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); mock_aio_image_writesame.send(); diff --git a/src/test/librbd/journal/test_mock_Replay.cc b/src/test/librbd/journal/test_mock_Replay.cc index aade74c1205f..e13a156ee056 100644 --- a/src/test/librbd/journal/test_mock_Replay.cc +++ b/src/test/librbd/journal/test_mock_Replay.cc @@ -32,7 +32,7 @@ struct ImageRequest { const bufferlist &bl, int op_flags)); static void aio_write(MockReplayImageCtx *ictx, AioCompletion *c, Extents &&image_extents, bufferlist &&bl, - int op_flags) { + int op_flags, const ZTracer::Trace &parent_trace) { assert(s_instance != nullptr); s_instance->aio_write(c, image_extents, bl, op_flags); } @@ -40,13 +40,16 @@ struct ImageRequest { MOCK_METHOD4(aio_discard, void(AioCompletion *c, uint64_t off, uint64_t len, bool skip_partial_discard)); static void aio_discard(MockReplayImageCtx *ictx, AioCompletion *c, - uint64_t off, uint64_t len, bool skip_partial_discard) { + uint64_t off, uint64_t len, + bool skip_partial_discard, + const ZTracer::Trace &parent_trace) { assert(s_instance != nullptr); s_instance->aio_discard(c, off, len, skip_partial_discard); } MOCK_METHOD1(aio_flush, void(AioCompletion *c)); - static void aio_flush(MockReplayImageCtx *ictx, AioCompletion *c) { + static void aio_flush(MockReplayImageCtx *ictx, AioCompletion *c, + const ZTracer::Trace &parent_trace) { assert(s_instance != nullptr); s_instance->aio_flush(c); } @@ -55,7 +58,7 @@ struct ImageRequest { const bufferlist &bl, int op_flags)); static void aio_writesame(MockReplayImageCtx *ictx, AioCompletion *c, uint64_t off, uint64_t len, bufferlist &&bl, - int op_flags) { + int op_flags, const ZTracer::Trace &parent_trace) { assert(s_instance != nullptr); s_instance->aio_writesame(c, off, len, bl, op_flags); } diff --git a/src/test/librbd/mock/MockImageCtx.h b/src/test/librbd/mock/MockImageCtx.h index 4f1e7054edcd..84383f91300f 100644 --- a/src/test/librbd/mock/MockImageCtx.h +++ b/src/test/librbd/mock/MockImageCtx.h @@ -87,6 +87,7 @@ struct MockImageCtx { state(new MockImageState()), image_watcher(NULL), object_map(NULL), exclusive_lock(NULL), journal(NULL), + trace_endpoint(image_ctx.trace_endpoint), concurrent_management_ops(image_ctx.concurrent_management_ops), blacklist_on_break_lock(image_ctx.blacklist_on_break_lock), blacklist_expire_seconds(image_ctx.blacklist_expire_seconds), @@ -273,6 +274,8 @@ struct MockImageCtx { MockExclusiveLock *exclusive_lock; MockJournal *journal; + ZTracer::Endpoint trace_endpoint; + int concurrent_management_ops; bool blacklist_on_break_lock; uint32_t blacklist_expire_seconds; diff --git a/src/test/librbd/test_mock_Journal.cc b/src/test/librbd/test_mock_Journal.cc index c7a6ea304170..50b59aac645e 100644 --- a/src/test/librbd/test_mock_Journal.cc +++ b/src/test/librbd/test_mock_Journal.cc @@ -1019,7 +1019,7 @@ TEST_F(TestMockJournal, EventCommitError) { C_SaferCond object_request_ctx; auto object_request = new io::ObjectRemoveRequest( - ictx, "oid", 0, {}, &object_request_ctx); + ictx, "oid", 0, {}, {}, &object_request_ctx); ::journal::MockFuture mock_future; Context *on_journal_safe; @@ -1060,7 +1060,7 @@ TEST_F(TestMockJournal, EventCommitErrorWithPendingWriteback) { C_SaferCond object_request_ctx; auto object_request = new io::ObjectRemoveRequest( - ictx, "oid", 0, {}, &object_request_ctx); + ictx, "oid", 0, {}, {}, &object_request_ctx); ::journal::MockFuture mock_future; Context *on_journal_safe;