namespace librbd {
namespace cache {
+using librbd::util::data_object_name;
+
namespace {
typedef std::vector<ObjectExtent> ObjectExtents;
template <typename I>
bool ObjectCacherObjectDispatch<I>::read(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, librados::snap_t snap_id, int op_flags,
- const ZTracer::Trace &parent_trace, ceph::bufferlist* read_data,
- io::ExtentMap* extent_map, int* object_dispatch_flags,
- io::DispatchResult* dispatch_result, Context** on_finish,
- Context* on_dispatched) {
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ librados::snap_t snap_id, int op_flags, const ZTracer::Trace &parent_trace,
+ ceph::bufferlist* read_data, io::ExtentMap* extent_map,
+ int* object_dispatch_flags, io::DispatchResult* dispatch_result,
+ Context** on_finish, Context* on_dispatched) {
// IO chained in reverse order
auto cct = m_image_ctx->cct;
ldout(cct, 20) << "object_no=" << object_no << " " << object_off << "~"
auto rd = m_object_cacher->prepare_read(snap_id, read_data, op_flags);
m_image_ctx->image_lock.put_read();
- ObjectExtent extent(oid, object_no, object_off, object_len, 0);
+ ObjectExtent extent(data_object_name(m_image_ctx, object_no), object_no,
+ object_off, object_len, 0);
extent.oloc.pool = m_image_ctx->data_ctx.get_id();
extent.buffer_extents.push_back({0, object_len});
rd->extents.push_back(extent);
template <typename I>
bool ObjectCacherObjectDispatch<I>::discard(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, const ::SnapContext &snapc, int discard_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ const ::SnapContext &snapc, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
<< object_len << dendl;
ObjectExtents object_extents;
- object_extents.emplace_back(oid, object_no, object_off, object_len, 0);
+ object_extents.emplace_back(data_object_name(m_image_ctx, object_no),
+ object_no, object_off, object_len, 0);
// discard the cache state after changes are committed to disk (and to
// prevent races w/ readahead)
template <typename I>
bool ObjectCacherObjectDispatch<I>::write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
+ const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
snapc, data, ceph::real_time::min(), op_flags, *journal_tid);
m_image_ctx->image_lock.put_read();
- ObjectExtent extent(oid, 0, object_off, data.length(), 0);
+ ObjectExtent extent(data_object_name(m_image_ctx, object_no),
+ object_no, object_off, data.length(), 0);
extent.oloc.pool = m_image_ctx->data_ctx.get_id();
extent.buffer_extents.push_back({0, data.length()});
wr->extents.push_back(extent);
template <typename I>
bool ObjectCacherObjectDispatch<I>::write_same(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, io::Extents&& buffer_extents, ceph::bufferlist&& data,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ io::Extents&& buffer_extents, ceph::bufferlist&& data,
const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
<< object_len << dendl;
// ObjectCacher doesn't support write-same so convert to regular write
- ObjectExtent extent(oid, 0, object_off, object_len, 0);
+ ObjectExtent extent(data_object_name(m_image_ctx, object_no), object_no,
+ object_off, object_len, 0);
extent.buffer_extents = std::move(buffer_extents);
bufferlist ws_data;
io::util::assemble_write_same_extent(extent, data, &ws_data, true);
- return write(oid, object_no, object_off, std::move(ws_data), snapc,
- op_flags, parent_trace, object_dispatch_flags, journal_tid,
+ return write(object_no, object_off, std::move(ws_data), snapc, op_flags,
+ parent_trace, object_dispatch_flags, journal_tid,
dispatch_result, on_finish, on_dispatched);
}
template <typename I>
bool ObjectCacherObjectDispatch<I>::compare_and_write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& cmp_data, ceph::bufferlist&& write_data,
- const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
+ ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
io::DispatchResult* dispatch_result, Context** on_finish,
*dispatch_result = io::DISPATCH_RESULT_CONTINUE;
ObjectExtents object_extents;
- object_extents.emplace_back(oid, object_no, object_off, cmp_data.length(),
- 0);
+ object_extents.emplace_back(data_object_name(m_image_ctx, object_no),
+ object_no, object_off, cmp_data.length(), 0);
Mutex::Locker cache_locker(m_cache_lock);
m_object_cacher->flush_set(m_object_set, object_extents, &trace,
void shut_down(Context* on_finish) override;
bool read(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, librados::snap_t snap_id, int op_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ librados::snap_t snap_id, int op_flags,
const ZTracer::Trace &parent_trace, ceph::bufferlist* read_data,
io::ExtentMap* extent_map, int* object_dispatch_flags,
io::DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool discard(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, const ::SnapContext &snapc, int discard_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ const ::SnapContext &snapc, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
+ const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool write_same(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, io::Extents&& buffer_extents,
- ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ io::Extents&& buffer_extents, ceph::bufferlist&& data,
+ const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool compare_and_write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& cmp_data, ceph::bufferlist&& write_data,
- const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
+ ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
io::DispatchResult* dispatch_result, Context** on_finish,
aio_comp, off, len, {{0, len}});
auto req = io::ObjectDispatchSpec::create_read(
- m_ictx, io::OBJECT_DISPATCH_LAYER_CACHE, oid.name, object_no, off, len,
- snapid, op_flags, trace, &req_comp->bl, &req_comp->extent_map, req_comp);
+ m_ictx, io::OBJECT_DISPATCH_LAYER_CACHE, object_no, off, len, snapid,
+ op_flags, trace, &req_comp->bl, &req_comp->extent_map, req_comp);
req->send();
}
ctx = util::create_async_context_callback(*m_ictx, ctx);
auto req = io::ObjectDispatchSpec::create_write(
- m_ictx, io::OBJECT_DISPATCH_LAYER_CACHE, oid.name, object_no, off,
- std::move(bl_copy), snapc, 0, journal_tid, trace, ctx);
+ m_ictx, io::OBJECT_DISPATCH_LAYER_CACHE, object_no, off, std::move(bl_copy),
+ snapc, 0, journal_tid, trace, ctx);
req->object_dispatch_flags = (
io::OBJECT_DISPATCH_FLAG_FLUSH |
io::OBJECT_DISPATCH_FLAG_WILL_RETRY_ON_ERROR);
namespace librbd {
namespace cache {
+using librbd::util::data_object_name;
+
template <typename I>
WriteAroundObjectDispatch<I>::WriteAroundObjectDispatch(
I* image_ctx, size_t max_dirty, bool writethrough_until_flush)
template <typename I>
bool WriteAroundObjectDispatch<I>::read(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, librados::snap_t snap_id, int op_flags,
- const ZTracer::Trace &parent_trace, ceph::bufferlist* read_data,
- io::ExtentMap* extent_map, int* object_dispatch_flags,
- io::DispatchResult* dispatch_result, Context** on_finish,
- Context* on_dispatched) {
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ librados::snap_t snap_id, int op_flags, const ZTracer::Trace &parent_trace,
+ ceph::bufferlist* read_data, io::ExtentMap* extent_map,
+ int* object_dispatch_flags, io::DispatchResult* dispatch_result,
+ Context** on_finish, Context* on_dispatched) {
return dispatch_unoptimized_io(object_no, object_off, object_len,
dispatch_result, on_dispatched);
}
template <typename I>
bool WriteAroundObjectDispatch<I>::discard(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, const ::SnapContext &snapc, int discard_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ const ::SnapContext &snapc, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << "object_no=" << object_no << " " << object_off << "~"
- << object_len << dendl;
+ ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
+ << object_off << "~" << object_len << dendl;
return dispatch_io(object_no, object_off, object_len, 0, dispatch_result,
on_finish, on_dispatched);
template <typename I>
bool WriteAroundObjectDispatch<I>::write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
+ const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context**on_finish, Context* on_dispatched) {
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << "object_no=" << object_no << " " << object_off << "~"
- << data.length() << dendl;
+ ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
+ << object_off << "~" << data.length() << dendl;
return dispatch_io(object_no, object_off, data.length(), op_flags,
dispatch_result, on_finish, on_dispatched);
template <typename I>
bool WriteAroundObjectDispatch<I>::write_same(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, io::Extents&& buffer_extents, ceph::bufferlist&& data,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ io::Extents&& buffer_extents, ceph::bufferlist&& data,
const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context**on_finish, Context* on_dispatched) {
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << "object_no=" << object_no << " " << object_off << "~"
- << object_len << dendl;
+ ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
+ << object_off << "~" << object_len << dendl;
return dispatch_io(object_no, object_off, object_len, 0, dispatch_result,
on_finish, on_dispatched);
template <typename I>
bool WriteAroundObjectDispatch<I>::compare_and_write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& cmp_data, ceph::bufferlist&& write_data,
- const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
+ ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
io::DispatchResult* dispatch_result, Context** on_finish,
void shut_down(Context* on_finish) override;
bool read(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, librados::snap_t snap_id, int op_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ librados::snap_t snap_id, int op_flags,
const ZTracer::Trace &parent_trace, ceph::bufferlist* read_data,
io::ExtentMap* extent_map, int* object_dispatch_flags,
io::DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool discard(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, const ::SnapContext &snapc, int discard_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ const ::SnapContext &snapc, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context**on_finish, Context* on_dispatched) override;
bool write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
+ const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context**on_finish, Context* on_dispatched) override;
bool write_same(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, io::Extents&& buffer_extents,
- ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ io::Extents&& buffer_extents, ceph::bufferlist&& data,
+ const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context**on_finish, Context* on_dispatched) override;
bool compare_and_write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& cmp_data, ceph::bufferlist&& write_data,
- const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
+ ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
io::DispatchResult* dispatch_result, Context** on_finish,
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
-#define dout_prefix *_dout << "librbd::io::CopyupRequest: " << this \
- << " " << __func__ << ": "
+#define dout_prefix *_dout << "librbd::io::CopyupRequest: " << this \
+ << " " << __func__ << ": " \
+ << data_object_name(m_image_ctx, m_object_no) << " "
namespace librbd {
namespace io {
+using librbd::util::data_object_name;
+
namespace {
template <typename I>
} // anonymous namespace
template <typename I>
-CopyupRequest<I>::CopyupRequest(I *ictx, const std::string &oid,
- uint64_t objectno, Extents &&image_extents,
+CopyupRequest<I>::CopyupRequest(I *ictx, uint64_t objectno,
+ Extents &&image_extents,
const ZTracer::Trace &parent_trace)
- : m_image_ctx(ictx), m_oid(oid), m_object_no(objectno),
- m_image_extents(image_extents),
+ : m_image_ctx(ictx), m_object_no(objectno), m_image_extents(image_extents),
m_trace(util::create_trace(*m_image_ctx, "copy-up", parent_trace)),
m_lock("CopyupRequest", false, false)
{
Mutex::Locker locker(m_lock);
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << "oid=" << m_oid << ", "
- << "object_request=" << req << ", "
+ ldout(cct, 20) << "object_request=" << req << ", "
<< "append=" << m_append_request_permitted << dendl;
if (m_append_request_permitted) {
m_pending_requests.push_back(req);
&CopyupRequest<I>::handle_read_from_parent>(
this, util::get_image_ctx(m_image_ctx->parent), AIO_TYPE_READ);
- ldout(cct, 20) << "oid=" << m_oid << ", "
- << "completion=" << comp << ", "
+ ldout(cct, 20) << "completion=" << comp << ", "
<< "extents=" << m_image_extents
<< dendl;
if (m_image_ctx->enable_sparse_copyup) {
template <typename I>
void CopyupRequest<I>::handle_read_from_parent(int r) {
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << "oid=" << m_oid << ", r=" << r << dendl;
+ ldout(cct, 20) << "r=" << r << dendl;
m_image_ctx->image_lock.get_read();
m_lock.Lock();
m_flatten = is_copyup_required() ? true : m_image_ctx->migration_info.flatten;
m_lock.Unlock();
- ldout(cct, 20) << "oid=" << m_oid << ", flatten=" << m_flatten << dendl;
+ ldout(cct, 20) << "flatten=" << m_flatten << dendl;
auto ctx = util::create_context_callback<
CopyupRequest<I>, &CopyupRequest<I>::handle_deep_copy>(this);
template <typename I>
void CopyupRequest<I>::handle_deep_copy(int r) {
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << "oid=" << m_oid << ", r=" << r << dendl;
+ ldout(cct, 20) << "r=" << r << dendl;
m_image_ctx->image_lock.get_read();
m_lock.Lock();
}
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << "oid=" << m_oid << dendl;
+ ldout(cct, 20) << dendl;
bool copy_on_read = m_pending_requests.empty();
uint8_t head_object_map_state = OBJECT_EXISTS;
template <typename I>
void CopyupRequest<I>::handle_update_object_maps(int r) {
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << "oid=" << m_oid << ", r=" << r << dendl;
+ ldout(cct, 20) << "r=" << r << dendl;
if (r < 0) {
lderr(m_image_ctx->cct) << "failed to update object map: "
return;
}
- ldout(cct, 20) << "oid=" << m_oid << dendl;
+ ldout(cct, 20) << dendl;
bool copy_on_read = m_pending_requests.empty();
bool deep_copyup = !snapc.snaps.empty() && !m_copyup_is_zero;
m_lock.Unlock();
// issue librados ops at the end to simplify test cases
+ std::string oid(data_object_name(m_image_ctx, m_object_no));
std::vector<librados::snap_t> snaps;
if (copyup_op.size() > 0) {
// send only the copyup request with a blank snapshot context so that
auto comp = util::create_rados_callback<
CopyupRequest<I>, &CopyupRequest<I>::handle_copyup>(this);
r = m_image_ctx->data_ctx.aio_operate(
- m_oid, comp, ©up_op, 0, snaps,
+ oid, comp, ©up_op, 0, snaps,
(m_trace.valid() ? m_trace.get_info() : nullptr));
ceph_assert(r == 0);
comp->release();
auto comp = util::create_rados_callback<
CopyupRequest<I>, &CopyupRequest<I>::handle_copyup>(this);
r = m_image_ctx->data_ctx.aio_operate(
- m_oid, comp, &write_op, snapc.seq, snaps,
+ oid, comp, &write_op, snapc.seq, snaps,
(m_trace.valid() ? m_trace.get_info() : nullptr));
ceph_assert(r == 0);
comp->release();
pending_copyups = --m_pending_copyups;
}
- ldout(cct, 20) << "oid=" << m_oid << ", " << "r=" << r << ", "
+ ldout(cct, 20) << "r=" << r << ", "
<< "pending=" << pending_copyups << dendl;
if (r < 0 && r != -ENOENT) {
template <typename I>
void CopyupRequest<I>::finish(int r) {
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << "oid=" << m_oid << ", r=" << r << dendl;
+ ldout(cct, 20) << "r=" << r << dendl;
complete_requests(true, r);
delete this;
template <typename ImageCtxT = librbd::ImageCtx>
class CopyupRequest {
public:
- static CopyupRequest* create(ImageCtxT *ictx, const std::string &oid,
- uint64_t objectno, Extents &&image_extents,
+ static CopyupRequest* create(ImageCtxT *ictx, uint64_t objectno,
+ Extents &&image_extents,
const ZTracer::Trace &parent_trace) {
- return new CopyupRequest(ictx, oid, objectno, std::move(image_extents),
+ return new CopyupRequest(ictx, objectno, std::move(image_extents),
parent_trace);
}
- CopyupRequest(ImageCtxT *ictx, const std::string &oid, uint64_t objectno,
- Extents &&image_extents, const ZTracer::Trace &parent_trace);
+ CopyupRequest(ImageCtxT *ictx, uint64_t objectno, Extents &&image_extents,
+ const ZTracer::Trace &parent_trace);
~CopyupRequest();
void append_request(AbstractObjectWriteRequest<ImageCtxT> *req);
typedef std::vector<AbstractObjectWriteRequest<ImageCtxT> *> WriteRequests;
ImageCtxT *m_image_ctx;
- std::string m_oid;
uint64_t m_object_no;
Extents m_image_extents;
ZTracer::Trace m_trace;
object_extent.offset,
object_extent.length);
auto req = io::ObjectDispatchSpec::create_read(
- ictx, io::OBJECT_DISPATCH_LAYER_NONE, object_extent.oid.name,
- object_extent.objectno, object_extent.offset, object_extent.length,
- snap_id, 0, {}, &req_comp->read_data, &req_comp->extent_map,
- req_comp);
+ ictx, io::OBJECT_DISPATCH_LAYER_NONE, object_extent.objectno,
+ object_extent.offset, object_extent.length, snap_id, 0, {},
+ &req_comp->read_data, &req_comp->extent_map, req_comp);
req->send();
}
}
aio_comp, extent.offset, extent.length,
std::move(extent.buffer_extents));
auto req = ObjectDispatchSpec::create_read(
- &image_ctx, OBJECT_DISPATCH_LAYER_NONE, extent.oid.name,
- extent.objectno, extent.offset, extent.length, snap_id, m_op_flags,
- this->m_trace, &req_comp->bl, &req_comp->extent_map, req_comp);
+ &image_ctx, OBJECT_DISPATCH_LAYER_NONE, extent.objectno, extent.offset,
+ extent.length, snap_id, m_op_flags, this->m_trace, &req_comp->bl,
+ &req_comp->extent_map, req_comp);
req->send();
}
}
bufferlist bl;
assemble_extent(object_extent, &bl);
auto req = ObjectDispatchSpec::create_write(
- &image_ctx, OBJECT_DISPATCH_LAYER_NONE, object_extent.oid.name,
- object_extent.objectno, object_extent.offset, std::move(bl), snapc,
- m_op_flags, journal_tid, this->m_trace, on_finish);
+ &image_ctx, OBJECT_DISPATCH_LAYER_NONE, object_extent.objectno,
+ object_extent.offset, std::move(bl), snapc, m_op_flags, journal_tid,
+ this->m_trace, on_finish);
return req;
}
uint64_t journal_tid, Context *on_finish) {
I &image_ctx = this->m_image_ctx;
auto req = ObjectDispatchSpec::create_discard(
- &image_ctx, OBJECT_DISPATCH_LAYER_NONE, object_extent.oid.name,
- object_extent.objectno, object_extent.offset, object_extent.length, snapc,
+ &image_ctx, OBJECT_DISPATCH_LAYER_NONE, object_extent.objectno,
+ object_extent.offset, object_extent.length, snapc,
OBJECT_DISCARD_FLAG_DISABLE_CLONE_REMOVE, journal_tid, this->m_trace,
on_finish);
return req;
Extents buffer_extents{object_extent.buffer_extents};
req = ObjectDispatchSpec::create_write_same(
- &image_ctx, OBJECT_DISPATCH_LAYER_NONE, object_extent.oid.name,
- object_extent.objectno, object_extent.offset, object_extent.length,
- std::move(buffer_extents), std::move(bl), snapc, m_op_flags, journal_tid,
+ &image_ctx, OBJECT_DISPATCH_LAYER_NONE, object_extent.objectno,
+ object_extent.offset, object_extent.length, std::move(buffer_extents),
+ std::move(bl), snapc, m_op_flags, journal_tid,
this->m_trace, on_finish);
return req;
}
req = ObjectDispatchSpec::create_write(
- &image_ctx, OBJECT_DISPATCH_LAYER_NONE, object_extent.oid.name,
- object_extent.objectno, object_extent.offset, std::move(bl), snapc,
- m_op_flags, journal_tid, this->m_trace, on_finish);
+ &image_ctx, OBJECT_DISPATCH_LAYER_NONE, object_extent.objectno,
+ object_extent.offset, std::move(bl), snapc, m_op_flags, journal_tid,
+ this->m_trace, on_finish);
return req;
}
bufferlist bl;
assemble_extent(object_extent, &bl);
auto req = ObjectDispatchSpec::create_compare_and_write(
- &image_ctx, OBJECT_DISPATCH_LAYER_NONE, object_extent.oid.name,
- object_extent.objectno, object_extent.offset, std::move(m_cmp_bl),
- std::move(bl), snapc, m_mismatch_offset, m_op_flags, journal_tid,
- this->m_trace, on_finish);
+ &image_ctx, OBJECT_DISPATCH_LAYER_NONE, object_extent.objectno,
+ object_extent.offset, std::move(m_cmp_bl), std::move(bl), snapc,
+ m_mismatch_offset, m_op_flags, journal_tid, this->m_trace, on_finish);
return req;
}
#include "common/dout.h"
#include "common/WorkQueue.h"
#include "librbd/ImageCtx.h"
+#include "librbd/Utils.h"
#include "librbd/io/ObjectRequest.h"
#define dout_subsys ceph_subsys_rbd
namespace librbd {
namespace io {
+using librbd::util::data_object_name;
+
template <typename I>
ObjectDispatch<I>::ObjectDispatch(I* image_ctx)
: m_image_ctx(image_ctx) {
template <typename I>
bool ObjectDispatch<I>::read(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, librados::snap_t snap_id, int op_flags,
- const ZTracer::Trace &parent_trace, ceph::bufferlist* read_data,
- ExtentMap* extent_map, int* object_dispatch_flags,
- DispatchResult* dispatch_result, Context** on_finish,
- Context* on_dispatched) {
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ librados::snap_t snap_id, int op_flags, const ZTracer::Trace &parent_trace,
+ ceph::bufferlist* read_data, ExtentMap* extent_map,
+ int* object_dispatch_flags, DispatchResult* dispatch_result,
+ Context** on_finish, Context* on_dispatched) {
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << oid << " " << object_off << "~" << object_len << dendl;
+ ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
+ << object_off << "~" << object_len << dendl;
*dispatch_result = DISPATCH_RESULT_COMPLETE;
- auto req = new ObjectReadRequest<I>(m_image_ctx, oid, object_no, object_off,
+ auto req = new ObjectReadRequest<I>(m_image_ctx, object_no, object_off,
object_len, snap_id, op_flags,
parent_trace, read_data, extent_map,
on_dispatched);
template <typename I>
bool ObjectDispatch<I>::discard(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, const ::SnapContext &snapc, int discard_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ const ::SnapContext &snapc, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << oid << " " << object_off << "~" << object_len << dendl;
+ ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
+ << object_off << "~" << object_len << dendl;
*dispatch_result = DISPATCH_RESULT_COMPLETE;
- auto req = new ObjectDiscardRequest<I>(m_image_ctx, oid, object_no,
- object_off, object_len, snapc,
- discard_flags, parent_trace,
- on_dispatched);
+ auto req = new ObjectDiscardRequest<I>(m_image_ctx, object_no, object_off,
+ object_len, snapc, discard_flags,
+ parent_trace, on_dispatched);
req->send();
return true;
}
template <typename I>
bool ObjectDispatch<I>::write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
+ const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << oid << " " << object_off << "~" << data.length() << dendl;
+ ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
+ << object_off << "~" << data.length() << dendl;
*dispatch_result = DISPATCH_RESULT_COMPLETE;
- auto req = new ObjectWriteRequest<I>(m_image_ctx, oid, object_no, object_off,
+ auto req = new ObjectWriteRequest<I>(m_image_ctx, object_no, object_off,
std::move(data), snapc, op_flags,
parent_trace, on_dispatched);
req->send();
template <typename I>
bool ObjectDispatch<I>::write_same(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, Extents&& buffer_extents, ceph::bufferlist&& data,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ Extents&& buffer_extents, ceph::bufferlist&& data,
const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << oid << " " << object_off << "~" << object_len << dendl;
+ ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
+ << object_off << "~" << object_len << dendl;
*dispatch_result = DISPATCH_RESULT_COMPLETE;
- auto req = new ObjectWriteSameRequest<I>(m_image_ctx, oid, object_no,
+ auto req = new ObjectWriteSameRequest<I>(m_image_ctx, object_no,
object_off, object_len,
std::move(data), snapc, op_flags,
parent_trace, on_dispatched);
template <typename I>
bool ObjectDispatch<I>::compare_and_write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& cmp_data, ceph::bufferlist&& write_data,
- const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
+ ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << oid << " " << object_off << "~" << write_data.length()
- << dendl;
+ ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
+ << object_off << "~" << write_data.length() << dendl;
*dispatch_result = DISPATCH_RESULT_COMPLETE;
- auto req = new ObjectCompareAndWriteRequest<I>(m_image_ctx, oid, object_no,
+ auto req = new ObjectCompareAndWriteRequest<I>(m_image_ctx, object_no,
object_off,
std::move(cmp_data),
std::move(write_data), snapc,
void shut_down(Context* on_finish) override;
bool read(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, librados::snap_t snap_id, int op_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ librados::snap_t snap_id, int op_flags,
const ZTracer::Trace &parent_trace, ceph::bufferlist* read_data,
ExtentMap* extent_map, int* object_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool discard(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, const ::SnapContext &snapc, int discard_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ const ::SnapContext &snapc, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
+ const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool write_same(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, Extents&& buffer_extents, ceph::bufferlist&& data,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ Extents&& buffer_extents, ceph::bufferlist&& data,
const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool compare_and_write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& cmp_data, ceph::bufferlist&& write_data,
- const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
+ ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
DispatchResult* dispatch_result, Context** on_finish,
virtual void shut_down(Context* on_finish) = 0;
virtual bool read(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, librados::snap_t snap_id, int op_flags,
- const ZTracer::Trace &parent_trace, ceph::bufferlist* read_data,
- ExtentMap* extent_map, int* object_dispatch_flags,
- DispatchResult* dispatch_result, Context** on_finish,
- Context* on_dispatched) = 0;
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ librados::snap_t snap_id, int op_flags,const ZTracer::Trace &parent_trace,
+ ceph::bufferlist* read_data, ExtentMap* extent_map,
+ int* object_dispatch_flags, DispatchResult* dispatch_result,
+ Context** on_finish, Context* on_dispatched) = 0;
virtual bool discard(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, const ::SnapContext &snapc, int discard_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ const ::SnapContext &snapc, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context**on_finish, Context* on_dispatched) = 0;
virtual bool write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
+ const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context**on_finish, Context* on_dispatched) = 0;
virtual bool write_same(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, Extents&& buffer_extents, ceph::bufferlist&& data,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ Extents&& buffer_extents, ceph::bufferlist&& data,
const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context**on_finish, Context* on_dispatched) = 0;
virtual bool compare_and_write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& cmp_data, ceph::bufferlist&& write_data,
- const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
+ ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
DispatchResult* dispatch_result, Context** on_finish,
public:
struct RequestBase {
- std::string oid;
uint64_t object_no;
uint64_t object_off;
- RequestBase(const std::string& oid, uint64_t object_no, uint64_t object_off)
- : oid(oid), object_no(object_no), object_off(object_off) {
+ RequestBase(uint64_t object_no, uint64_t object_off)
+ : object_no(object_no), object_off(object_off) {
}
};
ceph::bufferlist* read_data;
ExtentMap* extent_map;
- ReadRequest(const std::string& oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, librados::snap_t snap_id,
- ceph::bufferlist* read_data, ExtentMap* extent_map)
- : RequestBase(oid, object_no, object_off),
+ ReadRequest(uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ librados::snap_t snap_id, ceph::bufferlist* read_data,
+ ExtentMap* extent_map)
+ : RequestBase(object_no, object_off),
object_len(object_len), snap_id(snap_id), read_data(read_data),
extent_map(extent_map) {
}
::SnapContext snapc;
uint64_t journal_tid;
- WriteRequestBase(const std::string& oid, uint64_t object_no,
- uint64_t object_off, const ::SnapContext& snapc,
- uint64_t journal_tid)
- : RequestBase(oid, object_no, object_off), snapc(snapc),
+ WriteRequestBase(uint64_t object_no, uint64_t object_off,
+ const ::SnapContext& snapc, uint64_t journal_tid)
+ : RequestBase(object_no, object_off), snapc(snapc),
journal_tid(journal_tid) {
}
};
uint64_t object_len;
int discard_flags;
- DiscardRequest(const std::string& oid, uint64_t object_no,
- uint64_t object_off, uint64_t object_len,
+ DiscardRequest(uint64_t object_no, uint64_t object_off, uint64_t object_len,
int discard_flags, const ::SnapContext& snapc,
uint64_t journal_tid)
- : WriteRequestBase(oid, object_no, object_off, snapc, journal_tid),
+ : WriteRequestBase(object_no, object_off, snapc, journal_tid),
object_len(object_len), discard_flags(discard_flags) {
}
};
struct WriteRequest : public WriteRequestBase {
ceph::bufferlist data;
- WriteRequest(const std::string& oid, uint64_t object_no,
- uint64_t object_off, ceph::bufferlist&& data,
- const ::SnapContext& snapc, uint64_t journal_tid)
- : WriteRequestBase(oid, object_no, object_off, snapc, journal_tid),
+ WriteRequest(uint64_t object_no, uint64_t object_off,
+ ceph::bufferlist&& data, const ::SnapContext& snapc,
+ uint64_t journal_tid)
+ : WriteRequestBase(object_no, object_off, snapc, journal_tid),
data(std::move(data)) {
}
};
Extents buffer_extents;
ceph::bufferlist data;
- WriteSameRequest(const std::string& oid, uint64_t object_no,
- uint64_t object_off, uint64_t object_len,
- Extents&& buffer_extents, ceph::bufferlist&& data,
- const ::SnapContext& snapc, uint64_t journal_tid)
- : WriteRequestBase(oid, object_no, object_off, snapc, journal_tid),
+ WriteSameRequest(uint64_t object_no, uint64_t object_off,
+ uint64_t object_len, Extents&& buffer_extents,
+ ceph::bufferlist&& data, const ::SnapContext& snapc,
+ uint64_t journal_tid)
+ : WriteRequestBase(object_no, object_off, snapc, journal_tid),
object_len(object_len), buffer_extents(std::move(buffer_extents)),
data(std::move(data)) {
}
ceph::bufferlist data;
uint64_t* mismatch_offset;
- CompareAndWriteRequest(const std::string& oid, uint64_t object_no,
- uint64_t object_off, ceph::bufferlist&& cmp_data,
- ceph::bufferlist&& data, uint64_t* mismatch_offset,
+ CompareAndWriteRequest(uint64_t object_no, uint64_t object_off,
+ ceph::bufferlist&& cmp_data, ceph::bufferlist&& data,
+ uint64_t* mismatch_offset,
const ::SnapContext& snapc, uint64_t journal_tid)
- : WriteRequestBase(oid, object_no, object_off, snapc, journal_tid),
+ : WriteRequestBase(object_no, object_off, snapc, journal_tid),
cmp_data(std::move(cmp_data)), data(std::move(data)),
mismatch_offset(mismatch_offset) {
}
template <typename ImageCtxT>
static ObjectDispatchSpec* create_read(
ImageCtxT* image_ctx, ObjectDispatchLayer object_dispatch_layer,
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, librados::snap_t snap_id, int op_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ librados::snap_t snap_id, int op_flags,
const ZTracer::Trace &parent_trace, ceph::bufferlist* read_data,
ExtentMap* extent_map, Context* on_finish) {
return new ObjectDispatchSpec(image_ctx->io_object_dispatcher,
object_dispatch_layer,
- ReadRequest{oid, object_no, object_off,
+ ReadRequest{object_no, object_off,
object_len, snap_id, read_data,
extent_map},
op_flags, parent_trace, on_finish);
template <typename ImageCtxT>
static ObjectDispatchSpec* create_discard(
ImageCtxT* image_ctx, ObjectDispatchLayer object_dispatch_layer,
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, const ::SnapContext &snapc, int discard_flags,
- uint64_t journal_tid, const ZTracer::Trace &parent_trace,
- Context *on_finish) {
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ const ::SnapContext &snapc, int discard_flags, uint64_t journal_tid,
+ const ZTracer::Trace &parent_trace, Context *on_finish) {
return new ObjectDispatchSpec(image_ctx->io_object_dispatcher,
object_dispatch_layer,
- DiscardRequest{oid, object_no, object_off,
+ DiscardRequest{object_no, object_off,
object_len, discard_flags,
snapc, journal_tid},
0, parent_trace, on_finish);
template <typename ImageCtxT>
static ObjectDispatchSpec* create_write(
ImageCtxT* image_ctx, ObjectDispatchLayer object_dispatch_layer,
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
- uint64_t journal_tid, const ZTracer::Trace &parent_trace,
- Context *on_finish) {
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
+ const ::SnapContext &snapc, int op_flags, uint64_t journal_tid,
+ const ZTracer::Trace &parent_trace, Context *on_finish) {
return new ObjectDispatchSpec(image_ctx->io_object_dispatcher,
object_dispatch_layer,
- WriteRequest{oid, object_no, object_off,
+ WriteRequest{object_no, object_off,
std::move(data), snapc,
journal_tid},
op_flags, parent_trace, on_finish);
template <typename ImageCtxT>
static ObjectDispatchSpec* create_write_same(
ImageCtxT* image_ctx, ObjectDispatchLayer object_dispatch_layer,
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, Extents&& buffer_extents,
- ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
- uint64_t journal_tid, const ZTracer::Trace &parent_trace,
- Context *on_finish) {
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ Extents&& buffer_extents, ceph::bufferlist&& data,
+ const ::SnapContext &snapc, int op_flags, uint64_t journal_tid,
+ const ZTracer::Trace &parent_trace, Context *on_finish) {
return new ObjectDispatchSpec(image_ctx->io_object_dispatcher,
object_dispatch_layer,
- WriteSameRequest{oid, object_no, object_off,
+ WriteSameRequest{object_no, object_off,
object_len,
std::move(buffer_extents),
std::move(data), snapc,
template <typename ImageCtxT>
static ObjectDispatchSpec* create_compare_and_write(
ImageCtxT* image_ctx, ObjectDispatchLayer object_dispatch_layer,
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& cmp_data, ceph::bufferlist&& write_data,
- const ::SnapContext &snapc, uint64_t *mismatch_offset, int op_flags,
- uint64_t journal_tid, const ZTracer::Trace &parent_trace,
- Context *on_finish) {
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
+ ceph::bufferlist&& write_data, const ::SnapContext &snapc,
+ uint64_t *mismatch_offset, int op_flags, uint64_t journal_tid,
+ const ZTracer::Trace &parent_trace, Context *on_finish) {
return new ObjectDispatchSpec(image_ctx->io_object_dispatcher,
object_dispatch_layer,
- CompareAndWriteRequest{oid, object_no,
+ CompareAndWriteRequest{object_no,
object_off,
std::move(cmp_data),
std::move(write_data),
bool operator()(ObjectDispatchSpec::ReadRequest& read) const {
return object_dispatch->read(
- read.oid, read.object_no, read.object_off, read.object_len, read.snap_id,
+ read.object_no, read.object_off, read.object_len, read.snap_id,
object_dispatch_spec->op_flags, object_dispatch_spec->parent_trace,
read.read_data, read.extent_map,
&object_dispatch_spec->object_dispatch_flags,
bool operator()(ObjectDispatchSpec::DiscardRequest& discard) const {
return object_dispatch->discard(
- discard.oid, discard.object_no, discard.object_off, discard.object_len,
- discard.snapc, discard.discard_flags, object_dispatch_spec->parent_trace,
+ discard.object_no, discard.object_off, discard.object_len, discard.snapc,
+ discard.discard_flags, object_dispatch_spec->parent_trace,
&object_dispatch_spec->object_dispatch_flags, &discard.journal_tid,
&object_dispatch_spec->dispatch_result,
&object_dispatch_spec->dispatcher_ctx.on_finish,
bool operator()(ObjectDispatchSpec::WriteRequest& write) const {
return object_dispatch->write(
- write.oid, write.object_no, write.object_off, std::move(write.data),
- write.snapc, object_dispatch_spec->op_flags,
- object_dispatch_spec->parent_trace,
+ write.object_no, write.object_off, std::move(write.data), write.snapc,
+ object_dispatch_spec->op_flags, object_dispatch_spec->parent_trace,
&object_dispatch_spec->object_dispatch_flags, &write.journal_tid,
&object_dispatch_spec->dispatch_result,
&object_dispatch_spec->dispatcher_ctx.on_finish,
bool operator()(ObjectDispatchSpec::WriteSameRequest& write_same) const {
return object_dispatch->write_same(
- write_same.oid, write_same.object_no, write_same.object_off,
- write_same.object_len, std::move(write_same.buffer_extents),
- std::move(write_same.data), write_same.snapc,
- object_dispatch_spec->op_flags, object_dispatch_spec->parent_trace,
+ write_same.object_no, write_same.object_off, write_same.object_len,
+ std::move(write_same.buffer_extents), std::move(write_same.data),
+ write_same.snapc, object_dispatch_spec->op_flags,
+ object_dispatch_spec->parent_trace,
&object_dispatch_spec->object_dispatch_flags, &write_same.journal_tid,
&object_dispatch_spec->dispatch_result,
&object_dispatch_spec->dispatcher_ctx.on_finish,
bool operator()(
ObjectDispatchSpec::CompareAndWriteRequest& compare_and_write) const {
return object_dispatch->compare_and_write(
- compare_and_write.oid, compare_and_write.object_no,
- compare_and_write.object_off, std::move(compare_and_write.cmp_data),
- std::move(compare_and_write.data), compare_and_write.snapc,
- object_dispatch_spec->op_flags, object_dispatch_spec->parent_trace,
- compare_and_write.mismatch_offset,
+ compare_and_write.object_no, compare_and_write.object_off,
+ std::move(compare_and_write.cmp_data), std::move(compare_and_write.data),
+ compare_and_write.snapc, object_dispatch_spec->op_flags,
+ object_dispatch_spec->parent_trace, compare_and_write.mismatch_offset,
&object_dispatch_spec->object_dispatch_flags,
&compare_and_write.journal_tid,
&object_dispatch_spec->dispatch_result,
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
-#define dout_prefix *_dout << "librbd::io::ObjectRequest: " << this \
- << " " << __func__ << ": "
+#define dout_prefix *_dout << "librbd::io::ObjectRequest: " << this \
+ << " " << __func__ << ": " \
+ << data_object_name(this->m_ictx, \
+ this->m_object_no) << " "
namespace librbd {
namespace io {
+using librbd::util::data_object_name;
+
namespace {
template <typename I>
template <typename I>
ObjectRequest<I>*
-ObjectRequest<I>::create_write(I *ictx, const std::string &oid,
- uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags,
- const ZTracer::Trace &parent_trace,
- Context *completion) {
- return new ObjectWriteRequest<I>(ictx, oid, object_no, object_off,
+ObjectRequest<I>::create_write(
+ I *ictx, uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
+ const ::SnapContext &snapc, int op_flags,
+ const ZTracer::Trace &parent_trace, Context *completion) {
+ return new ObjectWriteRequest<I>(ictx, object_no, object_off,
std::move(data), snapc, op_flags,
parent_trace, completion);
}
template <typename I>
ObjectRequest<I>*
-ObjectRequest<I>::create_discard(I *ictx, const std::string &oid,
- uint64_t object_no, uint64_t object_off,
- uint64_t object_len,
- const ::SnapContext &snapc,
- int discard_flags,
- const ZTracer::Trace &parent_trace,
- Context *completion) {
- return new ObjectDiscardRequest<I>(ictx, oid, object_no, object_off,
+ObjectRequest<I>::create_discard(
+ I *ictx, uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ const ::SnapContext &snapc, int discard_flags,
+ const ZTracer::Trace &parent_trace, Context *completion) {
+ return new ObjectDiscardRequest<I>(ictx, object_no, object_off,
object_len, snapc, discard_flags,
parent_trace, completion);
}
template <typename I>
ObjectRequest<I>*
-ObjectRequest<I>::create_write_same(I *ictx, const std::string &oid,
- uint64_t object_no, uint64_t object_off,
- uint64_t object_len,
- ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags,
- const ZTracer::Trace &parent_trace,
- Context *completion) {
- return new ObjectWriteSameRequest<I>(ictx, oid, object_no, object_off,
+ObjectRequest<I>::create_write_same(
+ I *ictx, uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ const ZTracer::Trace &parent_trace, Context *completion) {
+ return new ObjectWriteSameRequest<I>(ictx, object_no, object_off,
object_len, std::move(data), snapc,
op_flags, parent_trace, completion);
}
template <typename I>
ObjectRequest<I>*
-ObjectRequest<I>::create_compare_and_write(I *ictx, const std::string &oid,
- uint64_t object_no,
- uint64_t object_off,
- ceph::bufferlist&& cmp_data,
- ceph::bufferlist&& write_data,
- const ::SnapContext &snapc,
- uint64_t *mismatch_offset,
- int op_flags,
- const ZTracer::Trace &parent_trace,
- Context *completion) {
- return new ObjectCompareAndWriteRequest<I>(ictx, oid, object_no, object_off,
+ObjectRequest<I>::create_compare_and_write(
+ I *ictx, uint64_t object_no, uint64_t object_off,
+ ceph::bufferlist&& cmp_data, ceph::bufferlist&& write_data,
+ const ::SnapContext &snapc, uint64_t *mismatch_offset, int op_flags,
+ const ZTracer::Trace &parent_trace, Context *completion) {
+ return new ObjectCompareAndWriteRequest<I>(ictx, object_no, object_off,
std::move(cmp_data),
std::move(write_data), snapc,
mismatch_offset, op_flags,
}
template <typename I>
-ObjectRequest<I>::ObjectRequest(I *ictx, const std::string &oid,
- uint64_t objectno, uint64_t off,
- uint64_t len, librados::snap_t snap_id,
- const char *trace_name,
- const ZTracer::Trace &trace,
- Context *completion)
- : m_ictx(ictx), m_oid(oid), m_object_no(objectno), m_object_off(off),
+ObjectRequest<I>::ObjectRequest(
+ I *ictx, uint64_t objectno, uint64_t off, uint64_t len,
+ librados::snap_t snap_id, const char *trace_name,
+ const ZTracer::Trace &trace, Context *completion)
+ : m_ictx(ictx), m_object_no(objectno), m_object_off(off),
m_object_len(len), m_snap_id(snap_id), m_completion(completion),
m_trace(util::create_trace(*ictx, "", trace)) {
if (m_trace.valid()) {
- m_trace.copy_name(trace_name + std::string(" ") + oid);
+ m_trace.copy_name(trace_name + std::string(" ") +
+ data_object_name(ictx, objectno));
m_trace.event("start");
}
}
/** read **/
template <typename I>
-ObjectReadRequest<I>::ObjectReadRequest(I *ictx, const std::string &oid,
- uint64_t objectno, uint64_t offset,
- uint64_t len, librados::snap_t snap_id,
- int op_flags,
- const ZTracer::Trace &parent_trace,
- bufferlist* read_data,
- ExtentMap* extent_map,
- Context *completion)
- : ObjectRequest<I>(ictx, oid, objectno, offset, len, snap_id, "read",
+ObjectReadRequest<I>::ObjectReadRequest(
+ I *ictx, uint64_t objectno, uint64_t offset, uint64_t len,
+ librados::snap_t snap_id, int op_flags, const ZTracer::Trace &parent_trace,
+ bufferlist* read_data, ExtentMap* extent_map, Context *completion)
+ : ObjectRequest<I>(ictx, objectno, offset, len, snap_id, "read",
parent_trace, completion),
m_op_flags(op_flags), m_read_data(read_data), m_extent_map(extent_map) {
}
ObjectReadRequest<I>, &ObjectReadRequest<I>::handle_read_object>(this);
int flags = image_ctx->get_read_flags(this->m_snap_id);
int r = image_ctx->data_ctx.aio_operate(
- this->m_oid, rados_completion, &op, flags, nullptr,
+ data_object_name(this->m_ictx, this->m_object_no), rados_completion, &op,
+ flags, nullptr,
(this->m_trace.valid() ? this->m_trace.get_info() : nullptr));
ceph_assert(r == 0);
if (it == image_ctx->copyup_list.end()) {
// create and kick off a CopyupRequest
auto new_req = CopyupRequest<I>::create(
- image_ctx, this->m_oid, this->m_object_no, std::move(parent_extents),
- this->m_trace);
+ image_ctx, this->m_object_no, std::move(parent_extents), this->m_trace);
image_ctx->copyup_list[this->m_object_no] = new_req;
image_ctx->copyup_list_lock.Unlock();
template <typename I>
AbstractObjectWriteRequest<I>::AbstractObjectWriteRequest(
- I *ictx, const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t len, const ::SnapContext &snapc, const char *trace_name,
+ I *ictx, uint64_t object_no, uint64_t object_off, uint64_t len,
+ const ::SnapContext &snapc, const char *trace_name,
const ZTracer::Trace &parent_trace, Context *completion)
- : ObjectRequest<I>(ictx, oid, object_no, object_off, len, CEPH_NOSNAP,
- trace_name, parent_trace, completion),
+ : ObjectRequest<I>(ictx, object_no, object_off, len, CEPH_NOSNAP, trace_name,
+ parent_trace, completion),
m_snap_seq(snapc.seq.val)
{
m_snaps.insert(m_snaps.end(), snapc.snaps.begin(), snapc.snaps.end());
template <typename I>
void AbstractObjectWriteRequest<I>::send() {
I *image_ctx = this->m_ictx;
- ldout(image_ctx->cct, 20) << this->get_op_type() << " " << this->m_oid << " "
+ ldout(image_ctx->cct, 20) << this->get_op_type() << " "
<< this->m_object_off << "~" << this->m_object_len
<< dendl;
{
}
uint8_t new_state = this->get_pre_write_object_map_state();
- ldout(image_ctx->cct, 20) << this->m_oid << " " << this->m_object_off
- << "~" << this->m_object_len << dendl;
+ ldout(image_ctx->cct, 20) << this->m_object_off << "~" << this->m_object_len
+ << dendl;
if (image_ctx->object_map->template aio_update<
AbstractObjectWriteRequest<I>,
AbstractObjectWriteRequest<I>,
&AbstractObjectWriteRequest<I>::handle_write_object>(this);
int r = image_ctx->data_ctx.aio_operate(
- this->m_oid, rados_completion, &write, m_snap_seq, m_snaps,
+ data_object_name(this->m_ictx, this->m_object_no), rados_completion,
+ &write, m_snap_seq, m_snaps,
(this->m_trace.valid() ? this->m_trace.get_info() : nullptr));
ceph_assert(r == 0);
rados_completion->release();
auto it = image_ctx->copyup_list.find(this->m_object_no);
if (it == image_ctx->copyup_list.end()) {
auto new_req = CopyupRequest<I>::create(
- image_ctx, this->m_oid, this->m_object_no,
- std::move(this->m_parent_extents), this->m_trace);
+ image_ctx, this->m_object_no, std::move(this->m_parent_extents),
+ this->m_trace);
this->m_parent_extents.clear();
// make sure to wait on this CopyupRequest
class ObjectRequest {
public:
static ObjectRequest* create_write(
- ImageCtxT *ictx, const std::string &oid, uint64_t object_no,
- uint64_t object_off, ceph::bufferlist&& data, const ::SnapContext &snapc,
- int op_flags, const ZTracer::Trace &parent_trace, Context *completion);
+ ImageCtxT *ictx, uint64_t object_no, uint64_t object_off,
+ ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ const ZTracer::Trace &parent_trace, Context *completion);
static ObjectRequest* create_discard(
- ImageCtxT *ictx, const std::string &oid, uint64_t object_no,
- uint64_t object_off, uint64_t object_len, const ::SnapContext &snapc,
- int discard_flags, const ZTracer::Trace &parent_trace,
- Context *completion);
- static ObjectRequest* create_write_same(
- ImageCtxT *ictx, const std::string &oid, uint64_t object_no,
- uint64_t object_off, uint64_t object_len, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags,
+ ImageCtxT *ictx, uint64_t object_no, uint64_t object_off,
+ uint64_t object_len, const ::SnapContext &snapc, int discard_flags,
const ZTracer::Trace &parent_trace, Context *completion);
+ static ObjectRequest* create_write_same(
+ ImageCtxT *ictx, uint64_t object_no, uint64_t object_off,
+ uint64_t object_len, ceph::bufferlist&& data, const ::SnapContext &snapc,
+ int op_flags, const ZTracer::Trace &parent_trace, Context *completion);
static ObjectRequest* create_compare_and_write(
- ImageCtxT *ictx, const std::string &oid, uint64_t object_no,
- uint64_t object_off, ceph::bufferlist&& cmp_data,
- ceph::bufferlist&& write_data, const ::SnapContext &snapc,
- uint64_t *mismatch_offset, int op_flags,
+ ImageCtxT *ictx, uint64_t object_no, uint64_t object_off,
+ ceph::bufferlist&& cmp_data, ceph::bufferlist&& write_data,
+ const ::SnapContext &snapc, uint64_t *mismatch_offset, int op_flags,
const ZTracer::Trace &parent_trace, Context *completion);
- ObjectRequest(ImageCtxT *ictx, const std::string &oid,
- uint64_t objectno, uint64_t off, uint64_t len,
+ ObjectRequest(ImageCtxT *ictx, uint64_t objectno, uint64_t off, uint64_t len,
librados::snap_t snap_id, const char *trace_name,
const ZTracer::Trace &parent_trace, Context *completion);
virtual ~ObjectRequest() {
bool compute_parent_extents(Extents *parent_extents, bool read_request);
ImageCtxT *m_ictx;
- std::string m_oid;
uint64_t m_object_no, m_object_off, m_object_len;
librados::snap_t m_snap_id;
Context *m_completion;
public:
typedef std::map<uint64_t, uint64_t> ExtentMap;
- static ObjectReadRequest* create(ImageCtxT *ictx, const std::string &oid,
- uint64_t objectno, uint64_t offset,
- uint64_t len, librados::snap_t snap_id,
- int op_flags,
- const ZTracer::Trace &parent_trace,
- ceph::bufferlist* read_data,
- ExtentMap* extent_map, Context *completion) {
- return new ObjectReadRequest(ictx, oid, objectno, offset, len,
+ static ObjectReadRequest* create(
+ ImageCtxT *ictx, uint64_t objectno, uint64_t offset, uint64_t len,
+ librados::snap_t snap_id, int op_flags,
+ const ZTracer::Trace &parent_trace, ceph::bufferlist* read_data,
+ ExtentMap* extent_map, Context *completion) {
+ return new ObjectReadRequest(ictx, objectno, offset, len,
snap_id, op_flags, parent_trace, read_data,
extent_map, completion);
}
- ObjectReadRequest(ImageCtxT *ictx, const std::string &oid,
- uint64_t objectno, uint64_t offset, uint64_t len,
- librados::snap_t snap_id, int op_flags,
- const ZTracer::Trace &parent_trace,
- ceph::bufferlist* read_data, ExtentMap* extent_map,
- Context *completion);
+ ObjectReadRequest(
+ ImageCtxT *ictx, uint64_t objectno, uint64_t offset, uint64_t len,
+ librados::snap_t snap_id, int op_flags,
+ const ZTracer::Trace &parent_trace, ceph::bufferlist* read_data,
+ ExtentMap* extent_map, Context *completion);
void send() override;
template <typename ImageCtxT = ImageCtx>
class AbstractObjectWriteRequest : public ObjectRequest<ImageCtxT> {
public:
- AbstractObjectWriteRequest(ImageCtxT *ictx, const std::string &oid,
- uint64_t object_no, uint64_t object_off,
- uint64_t len, const ::SnapContext &snapc,
- const char *trace_name,
- const ZTracer::Trace &parent_trace,
- Context *completion);
+ AbstractObjectWriteRequest(
+ ImageCtxT *ictx, uint64_t object_no, uint64_t object_off, uint64_t len,
+ const ::SnapContext &snapc, const char *trace_name,
+ const ZTracer::Trace &parent_trace, Context *completion);
virtual bool is_empty_write_op() const {
return false;
template <typename ImageCtxT = ImageCtx>
class ObjectWriteRequest : public AbstractObjectWriteRequest<ImageCtxT> {
public:
- ObjectWriteRequest(ImageCtxT *ictx, const std::string &oid,
- uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& data, const ::SnapContext &snapc,
- int op_flags, const ZTracer::Trace &parent_trace,
- Context *completion)
- : AbstractObjectWriteRequest<ImageCtxT>(ictx, oid, object_no, object_off,
+ ObjectWriteRequest(
+ ImageCtxT *ictx, uint64_t object_no, uint64_t object_off,
+ ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ const ZTracer::Trace &parent_trace, Context *completion)
+ : AbstractObjectWriteRequest<ImageCtxT>(ictx, object_no, object_off,
data.length(), snapc, "write",
parent_trace, completion),
m_write_data(std::move(data)), m_op_flags(op_flags) {
template <typename ImageCtxT = ImageCtx>
class ObjectDiscardRequest : public AbstractObjectWriteRequest<ImageCtxT> {
public:
- ObjectDiscardRequest(ImageCtxT *ictx, const std::string &oid,
- uint64_t object_no, uint64_t object_off,
- uint64_t object_len, const ::SnapContext &snapc,
- int discard_flags, const ZTracer::Trace &parent_trace,
- Context *completion)
- : AbstractObjectWriteRequest<ImageCtxT>(ictx, oid, object_no, object_off,
+ ObjectDiscardRequest(
+ ImageCtxT *ictx, uint64_t object_no, uint64_t object_off,
+ uint64_t object_len, const ::SnapContext &snapc, int discard_flags,
+ const ZTracer::Trace &parent_trace, Context *completion)
+ : AbstractObjectWriteRequest<ImageCtxT>(ictx, object_no, object_off,
object_len, snapc, "discard",
parent_trace, completion),
m_discard_flags(discard_flags) {
template <typename ImageCtxT = ImageCtx>
class ObjectWriteSameRequest : public AbstractObjectWriteRequest<ImageCtxT> {
public:
- ObjectWriteSameRequest(ImageCtxT *ictx, const std::string &oid,
- uint64_t object_no, uint64_t object_off,
- uint64_t object_len, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags,
- const ZTracer::Trace &parent_trace,
- Context *completion)
- : AbstractObjectWriteRequest<ImageCtxT>(ictx, oid, object_no, object_off,
+ ObjectWriteSameRequest(
+ ImageCtxT *ictx, uint64_t object_no, uint64_t object_off,
+ uint64_t object_len, ceph::bufferlist&& data, const ::SnapContext &snapc,
+ int op_flags, const ZTracer::Trace &parent_trace, Context *completion)
+ : AbstractObjectWriteRequest<ImageCtxT>(ictx, object_no, object_off,
object_len, snapc, "writesame",
parent_trace, completion),
m_write_data(std::move(data)), m_op_flags(op_flags) {
template <typename ImageCtxT = ImageCtx>
class ObjectCompareAndWriteRequest : public AbstractObjectWriteRequest<ImageCtxT> {
public:
- ObjectCompareAndWriteRequest(ImageCtxT *ictx, const std::string &oid,
- uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& cmp_bl,
- ceph::bufferlist&& write_bl,
- const ::SnapContext &snapc,
- uint64_t *mismatch_offset, int op_flags,
- const ZTracer::Trace &parent_trace,
- Context *completion)
- : AbstractObjectWriteRequest<ImageCtxT>(ictx, oid, object_no, object_off,
+ ObjectCompareAndWriteRequest(
+ ImageCtxT *ictx, uint64_t object_no, uint64_t object_off,
+ ceph::bufferlist&& cmp_bl, ceph::bufferlist&& write_bl,
+ const ::SnapContext &snapc, uint64_t *mismatch_offset, int op_flags,
+ const ZTracer::Trace &parent_trace, Context *completion)
+ : AbstractObjectWriteRequest<ImageCtxT>(ictx, object_no, object_off,
cmp_bl.length(), snapc,
"compare_and_write", parent_trace,
completion),
namespace io {
using namespace boost::accumulators;
+using librbd::util::data_object_name;
static const int LATENCY_STATS_WINDOW_SIZE = 10;
auto req = io::ObjectDispatchSpec::create_write(
image_ctx, io::OBJECT_DISPATCH_LAYER_SCHEDULER,
- image_ctx->get_object_name(m_object_no), m_object_no, offset,
- std::move(merged_requests.data), m_snapc, m_op_flags, 0, {}, ctx);
+ m_object_no, offset, std::move(merged_requests.data), m_snapc,
+ m_op_flags, 0, {}, ctx);
req->object_dispatch_flags = m_object_dispatch_flags;
req->send();
template <typename I>
bool SimpleSchedulerObjectDispatch<I>::read(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, librados::snap_t snap_id, int op_flags,
- const ZTracer::Trace &parent_trace, ceph::bufferlist* read_data,
- io::ExtentMap* extent_map, int* object_dispatch_flags,
- io::DispatchResult* dispatch_result, Context** on_finish,
- Context* on_dispatched) {
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ librados::snap_t snap_id, int op_flags, const ZTracer::Trace &parent_trace,
+ ceph::bufferlist* read_data, io::ExtentMap* extent_map,
+ int* object_dispatch_flags, io::DispatchResult* dispatch_result,
+ Context** on_finish, Context* on_dispatched) {
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << "object_no=" << object_no << " " << object_off << "~"
- << object_len << dendl;
+ ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
+ << object_off << "~" << object_len << dendl;
Mutex::Locker locker(m_lock);
if (intersects(object_no, object_off, object_len)) {
template <typename I>
bool SimpleSchedulerObjectDispatch<I>::discard(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, const ::SnapContext &snapc, int discard_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ const ::SnapContext &snapc, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << "object_no=" << object_no << " " << object_off << "~"
- << object_len << dendl;
+ ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
+ << object_off << "~" << object_len << dendl;
Mutex::Locker locker(m_lock);
dispatch_delayed_requests(object_no);
template <typename I>
bool SimpleSchedulerObjectDispatch<I>::write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
+ const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << "object_no=" << object_no << " " << object_off << "~"
- << data.length() << dendl;
+ ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
+ << object_off << "~" << data.length() << dendl;
Mutex::Locker locker(m_lock);
if (try_delay_write(object_no, object_off, std::move(data), snapc, op_flags,
template <typename I>
bool SimpleSchedulerObjectDispatch<I>::write_same(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, io::Extents&& buffer_extents, ceph::bufferlist&& data,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ io::Extents&& buffer_extents, ceph::bufferlist&& data,
const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << "object_no=" << object_no << " " << object_off << "~"
- << object_len << dendl;
+ ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
+ << object_off << "~" << object_len << dendl;
Mutex::Locker locker(m_lock);
dispatch_delayed_requests(object_no);
template <typename I>
bool SimpleSchedulerObjectDispatch<I>::compare_and_write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& cmp_data, ceph::bufferlist&& write_data,
- const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
+ ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
io::DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << "object_no=" << object_no << " " << object_off << "~"
- << cmp_data.length() << dendl;
+ ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
+ << object_off << "~" << cmp_data.length() << dendl;
Mutex::Locker locker(m_lock);
dispatch_delayed_requests(object_no);
void shut_down(Context* on_finish) override;
bool read(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, librados::snap_t snap_id, int op_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ librados::snap_t snap_id, int op_flags,
const ZTracer::Trace &parent_trace, ceph::bufferlist* read_data,
io::ExtentMap* extent_map, int* object_dispatch_flags,
io::DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool discard(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, const ::SnapContext &snapc, int discard_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ const ::SnapContext &snapc, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
+ const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool write_same(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, io::Extents&& buffer_extents,
- ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ io::Extents&& buffer_extents, ceph::bufferlist&& data,
+ const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool compare_and_write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& cmp_data, ceph::bufferlist&& write_data,
- const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
+ ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
io::DispatchResult* dispatch_result, Context** on_finish,
#include "osdc/Striper.h"
#include "librbd/ImageCtx.h"
#include "librbd/Journal.h"
+#include "librbd/Utils.h"
#include "librbd/io/ObjectDispatchSpec.h"
#include "librbd/io/ObjectDispatcher.h"
namespace librbd {
namespace journal {
+using librbd::util::data_object_name;
+
namespace {
template <typename I>
template <typename I>
bool ObjectDispatch<I>::discard(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, const ::SnapContext &snapc, int discard_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ const ::SnapContext &snapc, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
}
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << oid << " " << object_off << "~" << object_len << dendl;
+ ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
+ << object_off << "~" << object_len << dendl;
*on_finish = new C_CommitIOEvent<I>(m_image_ctx, m_journal, object_no,
object_off, object_len, *journal_tid,
template <typename I>
bool ObjectDispatch<I>::write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
+ const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
}
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << oid << " " << object_off << "~" << data.length() << dendl;
+ ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
+ << object_off << "~" << data.length() << dendl;
*on_finish = new C_CommitIOEvent<I>(m_image_ctx, m_journal, object_no,
object_off, data.length(), *journal_tid,
template <typename I>
bool ObjectDispatch<I>::write_same(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, io::Extents&& buffer_extents, ceph::bufferlist&& data,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ io::Extents&& buffer_extents, ceph::bufferlist&& data,
const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
}
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << oid << " " << object_off << "~" << object_len << dendl;
+ ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
+ << object_off << "~" << object_len << dendl;
*on_finish = new C_CommitIOEvent<I>(m_image_ctx, m_journal, object_no,
object_off, object_len, *journal_tid,
template <typename I>
bool ObjectDispatch<I>::compare_and_write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& cmp_data, ceph::bufferlist&& write_data,
- const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
+ ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
io::DispatchResult* dispatch_result, Context** on_finish,
}
auto cct = m_image_ctx->cct;
- ldout(cct, 20) << oid << " " << object_off << "~" << write_data.length()
+ ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
+ << object_off << "~" << write_data.length()
<< dendl;
*on_finish = new C_CommitIOEvent<I>(m_image_ctx, m_journal, object_no,
void shut_down(Context* on_finish) override;
bool read(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, librados::snap_t snap_id, int op_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ librados::snap_t snap_id, int op_flags,
const ZTracer::Trace &parent_trace, ceph::bufferlist* read_data,
io::ExtentMap* extent_map, int* object_dispatch_flags,
io::DispatchResult* dispatch_result, Context** on_finish,
}
bool discard(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, const ::SnapContext &snapc, int discard_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ const ::SnapContext &snapc, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
+ const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool write_same(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, io::Extents&& buffer_extents,
- ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ io::Extents&& buffer_extents, ceph::bufferlist&& data,
+ const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool compare_and_write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& cmp_data, ceph::bufferlist&& write_data,
- const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
+ ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
io::DispatchResult* dispatch_result, Context** on_finish,
}
bufferlist bl;
- string oid = image_ctx.get_object_name(m_object_no);
- auto req = new io::ObjectWriteRequest<I>(&image_ctx, oid, m_object_no, 0,
+ auto req = new io::ObjectWriteRequest<I>(&image_ctx, m_object_no, 0,
std::move(bl), m_snapc, 0, {},
this);
if (!req->has_parent()) {
if (is_within_overlap_bounds()) {
bufferlist bl;
- string oid = image_ctx.get_object_name(m_object_no);
- auto req = new io::ObjectWriteRequest<I>(&image_ctx, oid, m_object_no, 0,
+ auto req = new io::ObjectWriteRequest<I>(&image_ctx, m_object_no, 0,
std::move(bl), m_snapc, 0, {},
ctx);
ldout(image_ctx.cct, 10) << "removing (with copyup) " << oid << dendl;
auto object_dispatch_spec = io::ObjectDispatchSpec::create_discard(
- &image_ctx, io::OBJECT_DISPATCH_LAYER_NONE, oid, m_object_no, 0,
+ &image_ctx, io::OBJECT_DISPATCH_LAYER_NONE, m_object_no, 0,
image_ctx.layout.object_size, m_snapc,
io::OBJECT_DISCARD_FLAG_DISABLE_OBJECT_MAP_UPDATE, 0, {}, this);
object_dispatch_spec->send();
}
auto object_dispatch_spec = io::ObjectDispatchSpec::create_discard(
- &image_ctx, io::OBJECT_DISPATCH_LAYER_NONE, p->oid.name, p->objectno,
- p->offset, p->length, snapc, 0, 0, {}, req_comp);
+ &image_ctx, io::OBJECT_DISPATCH_LAYER_NONE, p->objectno, p->offset,
+ p->length, snapc, 0, 0, {}, req_comp);
object_dispatch_spec->send();
}
completion->finish_adding_requests();
MockContext finish_ctx;
MockContext dispatch_ctx;
Context* finish_ctx_ptr = &finish_ctx;
- ASSERT_FALSE(object_dispatch.write("oid", 0, 0, std::move(data), {}, 0, {},
+ ASSERT_FALSE(object_dispatch.write(0, 0, std::move(data), {}, 0, {},
nullptr, nullptr, &dispatch_result,
&finish_ctx_ptr, &dispatch_ctx));
ASSERT_EQ(finish_ctx_ptr, &finish_ctx);
MockContext finish_ctx;
MockContext dispatch_ctx;
Context* finish_ctx_ptr = &finish_ctx;
- ASSERT_FALSE(object_dispatch.write("oid", 0, 0, std::move(data), {}, 0, {},
+ ASSERT_FALSE(object_dispatch.write(0, 0, std::move(data), {}, 0, {},
nullptr, nullptr, &dispatch_result,
&finish_ctx_ptr, &dispatch_ctx));
ASSERT_EQ(finish_ctx_ptr, &finish_ctx);
expect_context_complete(dispatch_ctx, 0);
expect_context_complete(finish_ctx, 0);
- ASSERT_TRUE(object_dispatch.write("oid", 0, 0, std::move(data), {}, 0, {},
+ ASSERT_TRUE(object_dispatch.write(0, 0, std::move(data), {}, 0, {},
nullptr, nullptr, &dispatch_result,
&finish_ctx_ptr, &dispatch_ctx));
ASSERT_EQ(io::DISPATCH_RESULT_CONTINUE, dispatch_result);
expect_context_complete(dispatch_ctx, 0);
expect_context_complete(finish_ctx, 0);
- ASSERT_TRUE(object_dispatch.write("oid", 0, 0, std::move(data), {}, 0, {},
+ ASSERT_TRUE(object_dispatch.write(0, 0, std::move(data), {}, 0, {},
nullptr, nullptr, &dispatch_result,
&finish_ctx_ptr, &dispatch_ctx));
ASSERT_EQ(io::DISPATCH_RESULT_CONTINUE, dispatch_result);
expect_context_complete(dispatch_ctx1, 0);
expect_context_complete(finish_ctx1, 0);
- ASSERT_TRUE(object_dispatch.write("oid", 0, 0, std::move(data), {}, 0, {},
+ ASSERT_TRUE(object_dispatch.write(0, 0, std::move(data), {}, 0, {},
nullptr, nullptr, &dispatch_result,
&finish_ctx_ptr1, &dispatch_ctx1));
ASSERT_EQ(io::DISPATCH_RESULT_CONTINUE, dispatch_result);
expect_context_complete(dispatch_ctx2, 0);
expect_context_complete(finish_ctx2, 0);
- ASSERT_TRUE(object_dispatch.write("oid", 0, 4096, std::move(data), {}, 0, {},
+ ASSERT_TRUE(object_dispatch.write(0, 4096, std::move(data), {}, 0, {},
nullptr, nullptr, &dispatch_result,
&finish_ctx_ptr2, &dispatch_ctx2));
ASSERT_EQ(io::DISPATCH_RESULT_CONTINUE, dispatch_result);
MockContext dispatch_ctx3;
Context* finish_ctx_ptr3 = &finish_ctx3;
- ASSERT_TRUE(object_dispatch.write("oid", 0, 1024, std::move(data), {}, 0,
+ ASSERT_TRUE(object_dispatch.write(0, 1024, std::move(data), {}, 0,
{}, nullptr, nullptr, &dispatch_result,
&finish_ctx_ptr3, &dispatch_ctx3));
ASSERT_EQ(io::DISPATCH_RESULT_CONTINUE, dispatch_result);
expect_context_complete(dispatch_ctx1, 0);
expect_context_complete(finish_ctx1, 0);
- ASSERT_TRUE(object_dispatch.write("oid", 0, 0, std::move(data), {}, 0, {},
+ ASSERT_TRUE(object_dispatch.write(0, 0, std::move(data), {}, 0, {},
nullptr, nullptr, &dispatch_result,
&finish_ctx_ptr1, &dispatch_ctx1));
ASSERT_EQ(io::DISPATCH_RESULT_CONTINUE, dispatch_result);
MockContext dispatch_ctx2;
Context* finish_ctx_ptr2 = &finish_ctx2;
- ASSERT_TRUE(object_dispatch.write("oid", 0, 8192, std::move(data), {}, 0, {},
+ ASSERT_TRUE(object_dispatch.write(0, 8192, std::move(data), {}, 0, {},
nullptr, nullptr, &dispatch_result,
&finish_ctx_ptr2, &dispatch_ctx2));
ASSERT_EQ(io::DISPATCH_RESULT_CONTINUE, dispatch_result);
expect_context_complete(dispatch_ctx1, 0);
expect_context_complete(finish_ctx1, 0);
- ASSERT_TRUE(object_dispatch.write("oid", 0, 0, std::move(data), {}, 0, {},
+ ASSERT_TRUE(object_dispatch.write(0, 0, std::move(data), {}, 0, {},
nullptr, nullptr, &dispatch_result,
&finish_ctx_ptr1, &dispatch_ctx1));
ASSERT_EQ(io::DISPATCH_RESULT_CONTINUE, dispatch_result);
expect_context_complete(dispatch_ctx2, 0);
expect_context_complete(finish_ctx2, 0);
- ASSERT_TRUE(object_dispatch.write("oid", 0, 4096, std::move(data), {}, 0, {},
+ ASSERT_TRUE(object_dispatch.write(0, 4096, std::move(data), {}, 0, {},
nullptr, nullptr, &dispatch_result,
&finish_ctx_ptr2, &dispatch_ctx2));
ASSERT_EQ(io::DISPATCH_RESULT_CONTINUE, dispatch_result);
MockContext dispatch_ctx3;
Context* finish_ctx_ptr3 = &finish_ctx3;
- ASSERT_TRUE(object_dispatch.write("oid", 0, 0, std::move(data), {}, 0,
+ ASSERT_TRUE(object_dispatch.write(0, 0, std::move(data), {}, 0,
{}, nullptr, nullptr, &dispatch_result,
&finish_ctx_ptr3, &dispatch_ctx3));
ASSERT_EQ(io::DISPATCH_RESULT_CONTINUE, dispatch_result);
expect_context_complete(dispatch_ctx1, 0);
expect_context_complete(finish_ctx1, 0);
- ASSERT_TRUE(object_dispatch.write("oid", 0, 0, std::move(data), {}, 0, {},
+ ASSERT_TRUE(object_dispatch.write(0, 0, std::move(data), {}, 0, {},
nullptr, nullptr, &dispatch_result,
&finish_ctx_ptr1, &dispatch_ctx1));
ASSERT_EQ(io::DISPATCH_RESULT_CONTINUE, dispatch_result);
expect_context_complete(dispatch_ctx1, 0);
expect_context_complete(finish_ctx1, 0);
- ASSERT_TRUE(object_dispatch.write("oid", 0, 0, std::move(data), {}, 0, {},
+ ASSERT_TRUE(object_dispatch.write(0, 0, std::move(data), {}, 0, {},
nullptr, nullptr, &dispatch_result,
&finish_ctx_ptr1, &dispatch_ctx1));
ASSERT_EQ(io::DISPATCH_RESULT_CONTINUE, dispatch_result);
MockContext dispatch_ctx2;
Context* finish_ctx_ptr2 = &finish_ctx2;
- ASSERT_TRUE(object_dispatch.write("oid", 0, 8192, std::move(data), {}, 0, {},
+ ASSERT_TRUE(object_dispatch.write(0, 8192, std::move(data), {}, 0, {},
nullptr, nullptr, &dispatch_result,
&finish_ctx_ptr2, &dispatch_ctx2));
ASSERT_EQ(io::DISPATCH_RESULT_CONTINUE, dispatch_result);
expect_context_complete(dispatch_ctx1, 0);
expect_context_complete(finish_ctx1, 0);
- ASSERT_TRUE(object_dispatch.write("oid", 0, 0, std::move(data), {}, 0, {},
+ ASSERT_TRUE(object_dispatch.write(0, 0, std::move(data), {}, 0, {},
nullptr, nullptr, &dispatch_result,
&finish_ctx_ptr1, &dispatch_ctx1));
ASSERT_EQ(io::DISPATCH_RESULT_CONTINUE, dispatch_result);
MockContext dispatch_ctx;
Context* finish_ctx_ptr = &finish_ctx;
- ASSERT_FALSE(object_dispatch.compare_and_write("oid", 0, 0, std::move(data),
+ ASSERT_FALSE(object_dispatch.compare_and_write(0, 0, std::move(data),
std::move(data), {}, 0, {},
nullptr, nullptr, nullptr,
&dispatch_result,
expect_context_complete(dispatch_ctx1, 0);
expect_context_complete(finish_ctx1, 0);
- ASSERT_TRUE(object_dispatch.write("oid", 0, 0, std::move(data), {}, 0, {},
+ ASSERT_TRUE(object_dispatch.write(0, 0, std::move(data), {}, 0, {},
nullptr, nullptr, &dispatch_result,
&finish_ctx_ptr1, &dispatch_ctx1));
ASSERT_EQ(io::DISPATCH_RESULT_CONTINUE, dispatch_result);
MockContext finish_ctx2;
MockContext dispatch_ctx2;
Context* finish_ctx_ptr2 = &finish_ctx2;
- ASSERT_TRUE(object_dispatch.compare_and_write("oid", 0, 0, std::move(data),
+ ASSERT_TRUE(object_dispatch.compare_and_write(0, 0, std::move(data),
std::move(data), {}, 0, {},
nullptr, nullptr, nullptr,
&dispatch_result,
expect_context_complete(dispatch_ctx1, 0);
expect_context_complete(finish_ctx1, 0);
- ASSERT_TRUE(object_dispatch.write("oid", 0, 0, std::move(data), {}, 0, {},
+ ASSERT_TRUE(object_dispatch.write(0, 0, std::move(data), {}, 0, {},
nullptr, nullptr, &dispatch_result,
&finish_ctx_ptr1, &dispatch_ctx1));
ASSERT_EQ(io::DISPATCH_RESULT_CONTINUE, dispatch_result);
MockContext finish_ctx2;
MockContext dispatch_ctx2;
Context* finish_ctx_ptr2 = &finish_ctx2;
- ASSERT_TRUE(object_dispatch.write("oid", 0, 4096, std::move(data), {}, 0, {},
+ ASSERT_TRUE(object_dispatch.write(0, 4096, std::move(data), {}, 0, {},
nullptr, nullptr, &dispatch_result,
&finish_ctx_ptr2, &dispatch_ctx2));
ASSERT_EQ(io::DISPATCH_RESULT_CONTINUE, dispatch_result);
MockContext finish_ctx3;
MockContext dispatch_ctx3;
Context* finish_ctx_ptr3 = &finish_ctx3;
- ASSERT_TRUE(object_dispatch.compare_and_write("oid", 0, 0, std::move(data),
+ ASSERT_TRUE(object_dispatch.compare_and_write(0, 0, std::move(data),
std::move(data), {}, 0, {},
nullptr, nullptr, nullptr,
&dispatch_result,
MockContext finish_ctx;
MockContext dispatch_ctx;
Context* finish_ctx_ptr = &finish_ctx;
- ASSERT_FALSE(object_dispatch.write("oid", 0, 0, std::move(data), {},
+ ASSERT_FALSE(object_dispatch.write(0, 0, std::move(data), {},
LIBRADOS_OP_FLAG_FADVISE_FUA, {},
nullptr, nullptr, &dispatch_result,
&finish_ctx_ptr, &dispatch_ctx));
0);
expect_add_copyup_ops(mock_write_request);
- expect_sparse_copyup(mock_image_ctx, CEPH_NOSNAP, "oid", {{0, 4096}}, data,
- 0);
- expect_write(mock_image_ctx, CEPH_NOSNAP, "oid", 0);
+ expect_sparse_copyup(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0),
+ {{0, 4096}}, data, 0);
+ expect_write(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0), 0);
- auto req = new MockCopyupRequest(&mock_image_ctx, "oid", 0,
+ auto req = new MockCopyupRequest(&mock_image_ctx, 0,
{{0, 4096}}, {});
mock_image_ctx.copyup_list[0] = req;
req->append_request(&mock_write_request);
0);
expect_add_copyup_ops(mock_write_request);
- expect_sparse_copyup(mock_image_ctx, 0, "oid", {{0, 4096}}, data, 0);
- expect_write(mock_image_ctx, CEPH_NOSNAP, "oid", 0);
+ expect_sparse_copyup(mock_image_ctx, 0, ictx->get_object_name(0), {{0, 4096}},
+ data, 0);
+ expect_write(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0), 0);
- auto req = new MockCopyupRequest(&mock_image_ctx, "oid", 0,
+ auto req = new MockCopyupRequest(&mock_image_ctx, 0,
{{0, 4096}}, {});
mock_image_ctx.copyup_list[0] = req;
req->append_request(&mock_write_request);
expect_object_map_update(mock_image_ctx, CEPH_NOSNAP, 0, OBJECT_EXISTS, true,
0);
- expect_sparse_copyup(mock_image_ctx, CEPH_NOSNAP, "oid", {{0, 4096}}, data,
- 0);
+ expect_sparse_copyup(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0),
+ {{0, 4096}}, data, 0);
- auto req = new MockCopyupRequest(&mock_image_ctx, "oid", 0,
+ auto req = new MockCopyupRequest(&mock_image_ctx, 0,
{{0, 4096}}, {});
mock_image_ctx.copyup_list[0] = req;
req->send();
expect_object_map_update(mock_image_ctx, CEPH_NOSNAP, 0, OBJECT_EXISTS_CLEAN,
true, 0);
- expect_sparse_copyup(mock_image_ctx, 0, "oid", {{0, 4096}}, data, 0);
+ expect_sparse_copyup(mock_image_ctx, 0, ictx->get_object_name(0), {{0, 4096}},
+ data, 0);
- auto req = new MockCopyupRequest(&mock_image_ctx, "oid", 0,
+ auto req = new MockCopyupRequest(&mock_image_ctx, 0,
{{0, 4096}}, {});
mock_image_ctx.copyup_list[0] = req;
req->send();
0);
expect_add_copyup_ops(mock_write_request);
- expect_sparse_copyup(mock_image_ctx, CEPH_NOSNAP, "oid", {}, "", 0);
- expect_write(mock_image_ctx, CEPH_NOSNAP, "oid", 0);
+ expect_sparse_copyup(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0),
+ {}, "", 0);
+ expect_write(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0), 0);
- auto req = new MockCopyupRequest(&mock_image_ctx, "oid", 0,
+ auto req = new MockCopyupRequest(&mock_image_ctx, 0,
{{0, 4096}}, {});
mock_image_ctx.copyup_list[0] = req;
req->append_request(&mock_write_request);
expect_object_map_update(mock_image_ctx, CEPH_NOSNAP, 0, OBJECT_EXISTS, true,
0);
- expect_sparse_copyup(mock_image_ctx, CEPH_NOSNAP, "oid", {}, "", 0);
+ expect_sparse_copyup(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0),
+ {}, "", 0);
- auto req = new MockCopyupRequest(&mock_image_ctx, "oid", 0,
+ auto req = new MockCopyupRequest(&mock_image_ctx, 0,
{{0, 4096}}, {});
mock_image_ctx.copyup_list[0] = req;
req->send();
0);
expect_add_copyup_ops(mock_write_request);
- expect_sparse_copyup(mock_image_ctx, CEPH_NOSNAP, "oid", {}, "", 0);
- expect_write(mock_image_ctx, CEPH_NOSNAP, "oid", 0);
+ expect_sparse_copyup(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0),
+ {}, "", 0);
+ expect_write(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0), 0);
- auto req = new MockCopyupRequest(&mock_image_ctx, "oid", 0,
+ auto req = new MockCopyupRequest(&mock_image_ctx, 0,
{{0, 4096}}, {});
mock_image_ctx.copyup_list[0] = req;
req->append_request(&mock_write_request);
0);
expect_add_copyup_ops(mock_write_request);
- expect_sparse_copyup(mock_image_ctx, CEPH_NOSNAP, "oid", {}, "", 0);
- expect_write(mock_image_ctx, CEPH_NOSNAP, "oid", 0);
+ expect_sparse_copyup(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0),
+ {}, "", 0);
+ expect_write(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0), 0);
- auto req = new MockCopyupRequest(&mock_image_ctx, "oid", 0,
+ auto req = new MockCopyupRequest(&mock_image_ctx, 0,
{{0, 4096}}, {});
mock_image_ctx.copyup_list[0] = req;
req->append_request(&mock_write_request);
0);
expect_add_copyup_ops(mock_write_request);
- expect_sparse_copyup(mock_image_ctx, CEPH_NOSNAP, "oid", {}, "", 0);
- expect_write(mock_image_ctx, CEPH_NOSNAP, "oid", 0);
+ expect_sparse_copyup(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0),
+ {}, "", 0);
+ expect_write(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0), 0);
- auto req = new MockCopyupRequest(&mock_image_ctx, "oid", 0,
+ auto req = new MockCopyupRequest(&mock_image_ctx, 0,
{{0, 4096}}, {});
mock_image_ctx.copyup_list[0] = req;
req->append_request(&mock_write_request);
expect_object_map_update(mock_image_ctx, CEPH_NOSNAP, 0, OBJECT_EXISTS, true,
0);
- expect_sparse_copyup(mock_image_ctx, CEPH_NOSNAP, "oid", {}, "", 0);
+ expect_sparse_copyup(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0),
+ {}, "", 0);
- auto req = new MockCopyupRequest(&mock_image_ctx, "oid", 0,
+ auto req = new MockCopyupRequest(&mock_image_ctx, 0,
{{0, 4096}}, {});
mock_image_ctx.copyup_list[0] = req;
req->send();
MockAbstractObjectWriteRequest mock_write_request;
expect_is_empty_write_op(mock_write_request, true);
- auto req = new MockCopyupRequest(&mock_image_ctx, "oid", 0,
+ auto req = new MockCopyupRequest(&mock_image_ctx, 0,
{{0, 4096}}, {});
mock_image_ctx.copyup_list[0] = req;
req->append_request(&mock_write_request);
expect_object_map_update(mock_image_ctx, CEPH_NOSNAP, 0, OBJECT_EXISTS, true,
0);
- auto req = new MockCopyupRequest(&mock_image_ctx, "oid", 0,
+ auto req = new MockCopyupRequest(&mock_image_ctx, 0,
{{0, 4096}}, {});
expect_add_copyup_ops(mock_write_request1);
- expect_sparse_copyup(mock_image_ctx, CEPH_NOSNAP, "oid", {{0, 4096}}, data,
- 0);
+ expect_sparse_copyup(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0),
+ {{0, 4096}}, data, 0);
MockAbstractObjectWriteRequest mock_write_request2;
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.data_ctx),
- write("oid", _, 0, 0, _))
+ write(ictx->get_object_name(0), _, 0, 0, _))
.WillOnce(WithoutArgs(Invoke([req, &mock_write_request2]() {
req->append_request(&mock_write_request2);
return 0;
MockAbstractObjectWriteRequest mock_write_request;
expect_is_empty_write_op(mock_write_request, false);
- auto req = new MockCopyupRequest(&mock_image_ctx, "oid", 0,
+ auto req = new MockCopyupRequest(&mock_image_ctx, 0,
{{0, 4096}}, {});
mock_image_ctx.copyup_list[0] = req;
req->append_request(&mock_write_request);
expect_is_empty_write_op(mock_write_request, false);
- auto req = new MockCopyupRequest(&mock_image_ctx, "oid", 0,
+ auto req = new MockCopyupRequest(&mock_image_ctx, 0,
{{0, 4096}}, {});
mock_image_ctx.copyup_list[0] = req;
req->append_request(&mock_write_request);
expect_object_map_update(mock_image_ctx, CEPH_NOSNAP, 0, OBJECT_EXISTS, true,
-EINVAL);
- auto req = new MockCopyupRequest(&mock_image_ctx, "oid", 0,
+ auto req = new MockCopyupRequest(&mock_image_ctx, 0,
{{0, 4096}}, {});
mock_image_ctx.copyup_list[0] = req;
req->append_request(&mock_write_request);
0);
expect_add_copyup_ops(mock_write_request);
- expect_sparse_copyup(mock_image_ctx, 0, "oid", {{0, 4096}}, data, -EPERM);
- expect_write(mock_image_ctx, CEPH_NOSNAP, "oid", 0);
+ expect_sparse_copyup(mock_image_ctx, 0, ictx->get_object_name(0), {{0, 4096}},
+ data, -EPERM);
+ expect_write(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0), 0);
- auto req = new MockCopyupRequest(&mock_image_ctx, "oid", 0,
+ auto req = new MockCopyupRequest(&mock_image_ctx, 0,
{{0, 4096}}, {});
mock_image_ctx.copyup_list[0] = req;
req->append_request(&mock_write_request);
0);
expect_add_copyup_ops(mock_write_request);
- expect_copyup(mock_image_ctx, CEPH_NOSNAP, "oid", data, 0);
- expect_write(mock_image_ctx, CEPH_NOSNAP, "oid", 0);
+ expect_copyup(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0), data, 0);
+ expect_write(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0), 0);
- auto req = new MockCopyupRequest(&mock_image_ctx, "oid", 0,
- {{0, 4096}}, {});
+ auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}}, {});
mock_image_ctx.copyup_list[0] = req;
req->append_request(&mock_write_request);
req->send();
struct CopyupRequest<librbd::MockTestImageCtx> : public CopyupRequest<librbd::MockImageCtx> {
static CopyupRequest* s_instance;
static CopyupRequest* create(librbd::MockTestImageCtx *ictx,
- const std::string &oid, uint64_t objectno,
- Extents &&image_extents,
+ uint64_t objectno, Extents &&image_extents,
const ZTracer::Trace &parent_trace) {
return s_instance;
}
ExtentMap extent_map;
C_SaferCond ctx;
auto req = MockObjectReadRequest::create(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0, 4096, CEPH_NOSNAP, 0, {},
- &bl, &extent_map, &ctx);
+ &mock_image_ctx, 0, 0, 4096, CEPH_NOSNAP, 0, {}, &bl, &extent_map, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
ExtentMap extent_map;
C_SaferCond ctx;
auto req = MockObjectReadRequest::create(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0,
- ictx->sparse_read_threshold_bytes, CEPH_NOSNAP, 0, {}, &bl, &extent_map,
- &ctx);
+ &mock_image_ctx, 0, 0, ictx->sparse_read_threshold_bytes, CEPH_NOSNAP, 0,
+ {}, &bl, &extent_map, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
ExtentMap extent_map;
C_SaferCond ctx;
auto req = MockObjectReadRequest::create(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0, 4096, CEPH_NOSNAP, 0, {},
- &bl, &extent_map, &ctx);
+ &mock_image_ctx, 0, 0, 4096, CEPH_NOSNAP, 0, {}, &bl, &extent_map, &ctx);
req->send();
ASSERT_EQ(-EPERM, ctx.wait());
}
ExtentMap extent_map;
C_SaferCond ctx;
auto req = MockObjectReadRequest::create(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0, 4096, CEPH_NOSNAP, 0, {},
- &bl, &extent_map, &ctx);
+ &mock_image_ctx, 0, 0, 4096, CEPH_NOSNAP, 0, {}, &bl, &extent_map, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
ExtentMap extent_map;
C_SaferCond ctx;
auto req = MockObjectReadRequest::create(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0, 4096, CEPH_NOSNAP, 0, {},
- &bl, &extent_map, &ctx);
+ &mock_image_ctx, 0, 0, 4096, CEPH_NOSNAP, 0, {}, &bl, &extent_map, &ctx);
req->send();
ASSERT_EQ(-EPERM, ctx.wait());
}
ExtentMap extent_map;
C_SaferCond ctx;
auto req = MockObjectReadRequest::create(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0, 4096, CEPH_NOSNAP, 0, {},
- &bl, &extent_map, &ctx);
+ &mock_image_ctx, 0, 0, 4096, CEPH_NOSNAP, 0, {}, &bl, &extent_map, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0, std::move(bl),
- mock_image_ctx.snapc, 0, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0, std::move(bl),
- mock_image_ctx.snapc, 0, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0, std::move(bl),
- mock_image_ctx.snapc, 0, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0, std::move(bl),
- mock_image_ctx.snapc, 0, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, {}, &ctx);
req->send();
ASSERT_EQ(-EPERM, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0, std::move(bl),
- mock_image_ctx.snapc, 0, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0, std::move(bl),
- mock_image_ctx.snapc, 0, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0, std::move(bl),
- mock_image_ctx.snapc, 0, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0, std::move(bl),
- mock_image_ctx.snapc, 0, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, {}, &ctx);
req->send();
ASSERT_EQ(-EPERM, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectDiscardRequest::create_discard(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0,
- mock_image_ctx.get_object_size(), mock_image_ctx.snapc, 0, {}, &ctx);
+ &mock_image_ctx, 0, 0, mock_image_ctx.get_object_size(),
+ mock_image_ctx.snapc, 0, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectDiscardRequest::create_discard(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0,
- mock_image_ctx.get_object_size(), mock_image_ctx.snapc,
- OBJECT_DISCARD_FLAG_DISABLE_CLONE_REMOVE, {}, &ctx);
+ &mock_image_ctx, 0, 0, mock_image_ctx.get_object_size(),
+ mock_image_ctx.snapc, OBJECT_DISCARD_FLAG_DISABLE_CLONE_REMOVE, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectDiscardRequest::create_discard(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0,
- mock_image_ctx.get_object_size(), mock_image_ctx.snapc,
- OBJECT_DISCARD_FLAG_DISABLE_CLONE_REMOVE, {}, &ctx);
+ &mock_image_ctx, 0, 0, mock_image_ctx.get_object_size(),
+ mock_image_ctx.snapc, OBJECT_DISCARD_FLAG_DISABLE_CLONE_REMOVE, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectDiscardRequest::create_discard(
- &mock_image_ctx, ictx->get_object_name(0), 0, 1,
- mock_image_ctx.get_object_size() - 1, mock_image_ctx.snapc, 0, {}, &ctx);
+ &mock_image_ctx, 0, 1, mock_image_ctx.get_object_size() - 1,
+ mock_image_ctx.snapc, 0, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectDiscardRequest::create_discard(
- &mock_image_ctx, ictx->get_object_name(0), 0, 1, 1, mock_image_ctx.snapc,
- 0, {}, &ctx);
+ &mock_image_ctx, 0, 1, 1, mock_image_ctx.snapc, 0, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectDiscardRequest::create_discard(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0,
- mock_image_ctx.get_object_size(), mock_image_ctx.snapc,
+ &mock_image_ctx, 0, 0, mock_image_ctx.get_object_size(),
+ mock_image_ctx.snapc,
OBJECT_DISCARD_FLAG_DISABLE_CLONE_REMOVE |
OBJECT_DISCARD_FLAG_DISABLE_OBJECT_MAP_UPDATE, {}, &ctx);
req->send();
C_SaferCond ctx;
auto req = MockObjectDiscardRequest::create_discard(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0,
- mock_image_ctx.get_object_size(), mock_image_ctx.snapc,
+ &mock_image_ctx, 0, 0, mock_image_ctx.get_object_size(),
+ mock_image_ctx.snapc,
OBJECT_DISCARD_FLAG_DISABLE_CLONE_REMOVE |
OBJECT_DISCARD_FLAG_DISABLE_OBJECT_MAP_UPDATE, {},
&ctx);
C_SaferCond ctx;
auto req = MockObjectWriteSameRequest::create_write_same(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0, 4096, std::move(bl),
- mock_image_ctx.snapc, 0, {}, &ctx);
+ &mock_image_ctx, 0, 0, 4096, std::move(bl), mock_image_ctx.snapc, 0, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
uint64_t mismatch_offset;
auto req = MockObjectWriteSameRequest::create_compare_and_write(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0, std::move(cmp_bl),
- std::move(bl), mock_image_ctx.snapc, &mismatch_offset, 0, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(cmp_bl), std::move(bl),
+ mock_image_ctx.snapc, &mismatch_offset, 0, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
uint64_t mismatch_offset;
auto req = MockObjectWriteSameRequest::create_compare_and_write(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0, std::move(cmp_bl),
- std::move(bl), mock_image_ctx.snapc, &mismatch_offset, 0, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(cmp_bl), std::move(bl),
+ mock_image_ctx.snapc, &mismatch_offset, 0, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
uint64_t mismatch_offset;
auto req = MockObjectWriteSameRequest::create_compare_and_write(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0, std::move(cmp_bl),
- std::move(bl), mock_image_ctx.snapc, &mismatch_offset, 0, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(cmp_bl), std::move(bl),
+ mock_image_ctx.snapc, &mismatch_offset, 0, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
uint64_t mismatch_offset;
auto req = MockObjectWriteSameRequest::create_compare_and_write(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0, std::move(cmp_bl),
- std::move(bl), mock_image_ctx.snapc, &mismatch_offset, 0, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(cmp_bl), std::move(bl),
+ mock_image_ctx.snapc, &mismatch_offset, 0, {}, &ctx);
req->send();
ASSERT_EQ(-EILSEQ, ctx.wait());
ASSERT_EQ(1ULL, mismatch_offset);
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, ictx->get_object_name(0), 0, 0, std::move(bl),
- mock_image_ctx.snapc, 0, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, {}, &ctx);
req->send();
ASSERT_EQ(-EBLACKLISTED, ctx.wait());
}
C_SaferCond cond;
Context *on_finish = &cond;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.read(
- ictx->get_object_name(0), 0, 0, 4096, CEPH_NOSNAP, 0, {}, nullptr,
- nullptr, nullptr, nullptr, &on_finish, nullptr));
+ 0, 0, 4096, CEPH_NOSNAP, 0, {}, nullptr, nullptr, nullptr, nullptr,
+ &on_finish, nullptr));
ASSERT_EQ(on_finish, &cond); // not modified
on_finish->complete(0);
ASSERT_EQ(0, cond.wait());
C_SaferCond cond;
Context *on_finish = &cond;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.discard(
- ictx->get_object_name(0), 0, 0, 4096, mock_image_ctx.snapc, 0, {},
- nullptr, nullptr, nullptr, &on_finish, nullptr));
+ 0, 0, 4096, mock_image_ctx.snapc, 0, {}, nullptr, nullptr, nullptr,
+ &on_finish, nullptr));
ASSERT_NE(on_finish, &cond);
on_finish->complete(0);
ASSERT_EQ(0, cond.wait());
C_SaferCond cond;
Context *on_finish = &cond;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(0), 0, 0, std::move(data), mock_image_ctx.snapc, 0,
- {}, &object_dispatch_flags, nullptr, nullptr, &on_finish, nullptr));
+ 0, 0, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, nullptr, &on_finish, nullptr));
ASSERT_NE(on_finish, &cond);
on_finish->complete(0);
ASSERT_EQ(0, cond.wait());
C_SaferCond cond;
Context *on_finish = &cond;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write_same(
- ictx->get_object_name(0), 0, 0, 4096, std::move(buffer_extents),
- std::move(data), mock_image_ctx.snapc, 0, {}, nullptr, nullptr, nullptr,
- &on_finish, nullptr));
+ 0, 0, 4096, std::move(buffer_extents), std::move(data),
+ mock_image_ctx.snapc, 0, {}, nullptr, nullptr, nullptr, &on_finish,
+ nullptr));
ASSERT_NE(on_finish, &cond);
on_finish->complete(0);
ASSERT_EQ(0, cond.wait());
C_SaferCond cond;
Context *on_finish = &cond;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.compare_and_write(
- ictx->get_object_name(0), 0, 0, std::move(cmp_data),
- std::move(write_data), mock_image_ctx.snapc, 0, {}, nullptr, nullptr,
- nullptr, nullptr, &on_finish, nullptr));
+ 0, 0, std::move(cmp_data), std::move(write_data), mock_image_ctx.snapc, 0,
+ {}, nullptr, nullptr, nullptr, nullptr, &on_finish, nullptr));
ASSERT_NE(on_finish, &cond);
on_finish->complete(0);
ASSERT_EQ(0, cond.wait());
C_SaferCond cond1;
Context *on_finish1 = &cond1;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(0), 0, 0, std::move(data), mock_image_ctx.snapc, 0,
- {}, &object_dispatch_flags, nullptr, nullptr, &on_finish1, nullptr));
+ 0, 0, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, nullptr, &on_finish1, nullptr));
ASSERT_NE(on_finish1, &cond1);
Context *timer_task = nullptr;
Context *on_finish2 = &cond2;
C_SaferCond on_dispatched;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(0), 0, 0, std::move(data), mock_image_ctx.snapc, 0,
- {}, &object_dispatch_flags, nullptr, &dispatch_result, &on_finish2,
+ 0, 0, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, &dispatch_result, &on_finish2,
&on_dispatched));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_EQ(on_finish2, &cond2);
C_SaferCond cond1;
Context *on_finish1 = &cond1;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(0), 0, 0, std::move(data), mock_image_ctx.snapc, 0,
- {}, &object_dispatch_flags, nullptr, nullptr, &on_finish1, nullptr));
+ 0, 0, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, nullptr, &on_finish1, nullptr));
ASSERT_NE(on_finish1, &cond1);
Context *timer_task = nullptr;
Context *on_finish2 = &cond2;
C_SaferCond on_dispatched;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(0), 0, 0, std::move(data), mock_image_ctx.snapc, 0,
- {}, &object_dispatch_flags, nullptr, &dispatch_result, &on_finish2,
+ 0, 0, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, &dispatch_result, &on_finish2,
&on_dispatched));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_EQ(on_finish2, &cond2);
C_SaferCond cond1;
Context *on_finish1 = &cond1;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(0), 0, 0, std::move(data), mock_image_ctx.snapc, 0,
- {}, &object_dispatch_flags, nullptr, nullptr, &on_finish1, nullptr));
+ 0, 0, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, nullptr, &on_finish1, nullptr));
ASSERT_NE(on_finish1, &cond1);
Context *timer_task = nullptr;
Context *on_finish2 = &cond2;
C_SaferCond on_dispatched2;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(0), 0, object_off, std::move(data),
- mock_image_ctx.snapc, 0, {}, &object_dispatch_flags, nullptr,
- &dispatch_result, &on_finish2, &on_dispatched2));
+ 0, object_off, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, &dispatch_result, &on_finish2,
+ &on_dispatched2));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_EQ(on_finish2, &cond2);
ASSERT_NE(timer_task, nullptr);
Context *on_finish3 = &cond3;
C_SaferCond on_dispatched3;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(0), 0, object_off, std::move(data),
- mock_image_ctx.snapc, 0, {}, &object_dispatch_flags, nullptr,
- &dispatch_result, &on_finish3, &on_dispatched3));
+ 0, object_off, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, &dispatch_result, &on_finish3,
+ &on_dispatched3));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_EQ(on_finish3, &cond3);
Context *on_finish4 = &cond4;
C_SaferCond on_dispatched4;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(0), 0, object_off, std::move(data),
- mock_image_ctx.snapc, 0, {}, &object_dispatch_flags, nullptr,
- &dispatch_result, &on_finish4, &on_dispatched4));
+ 0, object_off, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, &dispatch_result, &on_finish4,
+ &on_dispatched4));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_EQ(on_finish4, &cond4);
Context *on_finish5 = &cond5;
C_SaferCond on_dispatched5;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(0), 0, object_off, std::move(data),
- mock_image_ctx.snapc, 0, {}, &object_dispatch_flags, nullptr,
- &dispatch_result, &on_finish5, &on_dispatched5));
+ 0, object_off, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, &dispatch_result, &on_finish5,
+ &on_dispatched5));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_EQ(on_finish5, &cond5);
Context *on_finish6 = &cond6;
C_SaferCond on_dispatched6;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(0), 0, object_off, std::move(data),
- mock_image_ctx.snapc, 0, {}, &object_dispatch_flags, nullptr,
- &dispatch_result, &on_finish6, &on_dispatched6));
+ 0, object_off, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, &dispatch_result, &on_finish6,
+ &on_dispatched6));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_EQ(on_finish6, &cond6);
C_SaferCond cond1;
Context *on_finish1 = &cond1;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(0), 0, 0, std::move(data), mock_image_ctx.snapc, 0,
- {}, &object_dispatch_flags, nullptr, nullptr, &on_finish1, nullptr));
+ 0, 0, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, nullptr, &on_finish1, nullptr));
ASSERT_NE(on_finish1, &cond1);
Context *timer_task = nullptr;
Context *on_finish2 = &cond2;
C_SaferCond on_dispatched2;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(0), 0, object_off, std::move(data),
- mock_image_ctx.snapc, 0, {}, &object_dispatch_flags, nullptr,
- &dispatch_result, &on_finish2, &on_dispatched2));
+ 0, object_off, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, &dispatch_result, &on_finish2,
+ &on_dispatched2));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_EQ(on_finish2, &cond2);
ASSERT_NE(timer_task, nullptr);
C_SaferCond cond3;
Context *on_finish3 = &cond3;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(0), 0, object_off, std::move(data),
- mock_image_ctx.snapc, 0, {}, &object_dispatch_flags, nullptr,
- &dispatch_result, &on_finish3, nullptr));
+ 0, object_off, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, &dispatch_result, &on_finish3, nullptr));
ASSERT_NE(on_finish3, &cond3);
on_finish1->complete(0);
C_SaferCond cond1;
Context *on_finish1 = &cond1;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(0), 0, 0, std::move(data), mock_image_ctx.snapc, 0,
- {}, &object_dispatch_flags, nullptr, nullptr, &on_finish1, nullptr));
+ 0, 0, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, nullptr, &on_finish1, nullptr));
ASSERT_NE(on_finish1, &cond1);
// write (2) 0~10 (delayed)
Context *on_finish2 = &cond2;
C_SaferCond on_dispatched2;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(0), 0, object_off, std::move(data),
- mock_image_ctx.snapc, 0, {}, &object_dispatch_flags, nullptr,
- &dispatch_result, &on_finish2, &on_dispatched2));
+ 0, object_off, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, &dispatch_result, &on_finish2,
+ &on_dispatched2));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_EQ(on_finish2, &cond2);
ASSERT_NE(timer_task, nullptr);
Context *on_finish3 = &cond3;
C_SaferCond on_dispatched3;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(0), 0, object_off, std::move(data),
- mock_image_ctx.snapc, 0, {}, &object_dispatch_flags, nullptr,
- &dispatch_result, &on_finish3, &on_dispatched3));
+ 0, object_off, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, &dispatch_result, &on_finish3,
+ &on_dispatched3));
ASSERT_EQ(on_finish3, &cond3);
// discard (1) (non-seq io)
C_SaferCond cond4;
Context *on_finish4 = &cond4;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.discard(
- ictx->get_object_name(0), 0, 4096, 4096, mock_image_ctx.snapc, 0, {},
- nullptr, nullptr, nullptr, &on_finish4, nullptr));
+ 0, 4096, 4096, mock_image_ctx.snapc, 0, {}, nullptr, nullptr, nullptr,
+ &on_finish4, nullptr));
ASSERT_NE(on_finish4, &cond4);
ASSERT_EQ(0, on_dispatched2.wait());
ASSERT_EQ(0, on_dispatched3.wait());
Context *on_finish5 = &cond5;
C_SaferCond on_dispatched5;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(0), 0, object_off, std::move(data),
- mock_image_ctx.snapc, 0, {}, &object_dispatch_flags, nullptr,
- &dispatch_result, &on_finish5, &on_dispatched5));
+ 0, object_off, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, &dispatch_result, &on_finish5,
+ &on_dispatched5));
ASSERT_EQ(on_finish5, &cond5);
ASSERT_NE(timer_task, nullptr);
C_SaferCond cond6;
Context *on_finish6 = &cond6;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.discard(
- ictx->get_object_name(0), 0, 4096, 4096, mock_image_ctx.snapc, 0, {},
- nullptr, nullptr, nullptr, &on_finish6, nullptr));
+ 0, 4096, 4096, mock_image_ctx.snapc, 0, {}, nullptr, nullptr, nullptr,
+ &on_finish6, nullptr));
ASSERT_NE(on_finish6, &cond6);
ASSERT_EQ(0, on_dispatched5.wait());
Context *on_finish7 = &cond7;
C_SaferCond on_dispatched7;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(0), 0, object_off, std::move(data),
- mock_image_ctx.snapc, 0, {}, &object_dispatch_flags, nullptr,
- &dispatch_result, &on_finish7, &on_dispatched7));
+ 0, object_off, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, &dispatch_result, &on_finish7,
+ &on_dispatched7));
ASSERT_EQ(on_finish7, &cond7);
ASSERT_NE(timer_task, nullptr);
C_SaferCond cond1;
Context *on_finish1 = &cond1;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(object_no), object_no, 0, std::move(data),
- mock_image_ctx.snapc, 0, {}, &object_dispatch_flags, nullptr, nullptr,
- &on_finish1, nullptr));
+ object_no, 0, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, nullptr, &on_finish1, nullptr));
ASSERT_NE(on_finish1, &cond1);
Context *timer_task = nullptr;
Context *on_finish2 = &cond2;
C_SaferCond on_dispatched2;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(object_no), object_no, 0, std::move(data),
- mock_image_ctx.snapc, 0, {}, &object_dispatch_flags, nullptr,
- &dispatch_result, &on_finish2, &on_dispatched2));
+ object_no, 0, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, &dispatch_result, &on_finish2,
+ &on_dispatched2));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_EQ(on_finish2, &cond2);
ASSERT_NE(timer_task, nullptr);
C_SaferCond cond3;
Context *on_finish3 = &cond3;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(object_no), object_no, 0, std::move(data),
- mock_image_ctx.snapc, 0, {}, &object_dispatch_flags, nullptr, nullptr,
- &on_finish3, nullptr));
+ object_no, 0, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, nullptr, &on_finish3, nullptr));
ASSERT_NE(on_finish3, &cond3);
data.clear();
Context *on_finish4 = &cond4;
C_SaferCond on_dispatched4;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(object_no), object_no, 0, std::move(data),
- mock_image_ctx.snapc, 0, {}, &object_dispatch_flags, nullptr,
- &dispatch_result, &on_finish4, &on_dispatched4));
+ object_no, 0, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, &dispatch_result, &on_finish4,
+ &on_dispatched4));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_EQ(on_finish4, &cond4);
C_SaferCond cond1;
Context *on_finish1 = &cond1;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(0), 0, 0, std::move(data), mock_image_ctx.snapc, 0,
- {}, &object_dispatch_flags, nullptr, nullptr, &on_finish1, nullptr));
+ 0, 0, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, nullptr, &on_finish1, nullptr));
ASSERT_NE(on_finish1, &cond1);
Context *timer_task = nullptr;
Context *on_finish2 = &cond2;
C_SaferCond on_dispatched;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- ictx->get_object_name(0), 0, 0, std::move(data), mock_image_ctx.snapc, 0,
- {}, &object_dispatch_flags, nullptr, &dispatch_result, &on_finish2,
+ 0, 0, std::move(data), mock_image_ctx.snapc, 0, {},
+ &object_dispatch_flags, nullptr, &dispatch_result, &on_finish2,
&on_dispatched));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_EQ(on_finish2, &cond2);
bool(uint64_t, uint64_t, uint64_t, librados::snap_t,
ceph::bufferlist*, ExtentMap*, DispatchResult*, Context*));
bool read(
- const std::string& oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, librados::snap_t snap_id, int op_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ librados::snap_t snap_id, int op_flags,
const ZTracer::Trace& parent_trace, ceph::bufferlist* read_data,
ExtentMap* extent_map, int* dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
bool(uint64_t, uint64_t, uint64_t, const ::SnapContext &, int,
int*, uint64_t*, DispatchResult*, Context*));
bool discard(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, const ::SnapContext &snapc, int discard_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ const ::SnapContext &snapc, int discard_flags,
const ZTracer::Trace &parent_trace, int* dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
const ::SnapContext &, int*, uint64_t*, DispatchResult*,
Context *));
bool write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
+ const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override {
const ceph::bufferlist&, const ::SnapContext &, int*,
uint64_t*, DispatchResult*, Context *));
bool write_same(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, Extents&& buffer_extents, ceph::bufferlist&& data,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ Extents&& buffer_extents, ceph::bufferlist&& data,
const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, int* dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
const ceph::bufferlist&, uint64_t*, int*, uint64_t*,
DispatchResult*, Context *));
bool compare_and_write(
- const std::string &oid, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& cmp_data, ceph::bufferlist&& write_data,
- const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
+ ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* dispatch_flags, uint64_t* journal_tid,
DispatchResult* dispatch_result, Context** on_finish,
projects / ceph.git / commitdiff