From 0bf699154d2722b624344889972bf8e72558d55a Mon Sep 17 00:00:00 2001 From: Yehuda Sadeh Date: Tue, 6 Jan 2015 16:23:47 -0800 Subject: [PATCH] rgw: add bucket index log flags, use these for marking versioned ops We want to mark operations as versioned. This is needed by the sync agent, so that we know how to handle bucket index log entries. We only want to apply link-olh and unlink-instance operations when it's versioned. Signed-off-by: Yehuda Sadeh --- src/cls/rgw/cls_rgw.cc | 16 ++++++------ src/cls/rgw/cls_rgw_client.cc | 8 ++++-- src/cls/rgw/cls_rgw_client.h | 6 +++-- src/cls/rgw/cls_rgw_ops.cc | 6 +++++ src/cls/rgw/cls_rgw_ops.h | 32 ++++++++++++++++++------ src/cls/rgw/cls_rgw_types.cc | 1 + src/cls/rgw/cls_rgw_types.h | 13 ++++++++-- src/rgw/rgw_rados.cc | 46 +++++++++++++++++++++-------------- src/rgw/rgw_rados.h | 23 ++++++++++++------ 9 files changed, 104 insertions(+), 47 deletions(-) diff --git a/src/cls/rgw/cls_rgw.cc b/src/cls/rgw/cls_rgw.cc index 58d8c1101b65..7f7bbfb9df2a 100644 --- a/src/cls/rgw/cls_rgw.cc +++ b/src/cls/rgw/cls_rgw.cc @@ -139,7 +139,7 @@ static void bi_log_index_key(cls_method_context_t hctx, string& key, string& id, static int log_index_operation(cls_method_context_t hctx, cls_rgw_obj_key& obj_key, RGWModifyOp op, string& tag, utime_t& timestamp, rgw_bucket_entry_ver& ver, RGWPendingState state, uint64_t index_ver, - string& max_marker) + string& max_marker, uint16_t bilog_flags) { bufferlist bl; @@ -153,6 +153,7 @@ static int log_index_operation(cls_method_context_t hctx, cls_rgw_obj_key& obj_k entry.state = state; entry.index_ver = index_ver; entry.tag = tag; + entry.bilog_flags = bilog_flags; string key; bi_log_index_key(hctx, key, entry.id, index_ver); @@ -670,7 +671,7 @@ int rgw_bucket_prepare_op(cls_method_context_t hctx, bufferlist *in, bufferlist if (op.log_op) { rc = log_index_operation(hctx, op.key, op.op, op.tag, entry.meta.mtime, - entry.ver, info.state, header.ver, header.max_marker); + entry.ver, info.state, header.ver, header.max_marker, op.bilog_flags); if (rc < 0) return rc; } @@ -826,7 +827,7 @@ int rgw_bucket_complete_op(cls_method_context_t hctx, bufferlist *in, bufferlist if (cancel) { if (op.log_op) { rc = log_index_operation(hctx, op.key, op.op, op.tag, entry.meta.mtime, entry.ver, - CLS_RGW_STATE_COMPLETE, header.ver, header.max_marker); + CLS_RGW_STATE_COMPLETE, header.ver, header.max_marker, op.bilog_flags); if (rc < 0) return rc; } @@ -886,7 +887,7 @@ int rgw_bucket_complete_op(cls_method_context_t hctx, bufferlist *in, bufferlist if (op.log_op) { rc = log_index_operation(hctx, op.key, op.op, op.tag, entry.meta.mtime, entry.ver, - CLS_RGW_STATE_COMPLETE, header.ver, header.max_marker); + CLS_RGW_STATE_COMPLETE, header.ver, header.max_marker, op.bilog_flags); if (rc < 0) return rc; } @@ -911,7 +912,7 @@ int rgw_bucket_complete_op(cls_method_context_t hctx, bufferlist *in, bufferlist if (op.log_op) { rc = log_index_operation(hctx, remove_key, CLS_RGW_OP_DEL, op.tag, remove_entry.meta.mtime, - remove_entry.ver, CLS_RGW_STATE_COMPLETE, header.ver, header.max_marker); + remove_entry.ver, CLS_RGW_STATE_COMPLETE, header.ver, header.max_marker, op.bilog_flags); if (rc < 0) continue; } @@ -1487,7 +1488,7 @@ static int rgw_bucket_link_olh(cls_method_context_t hctx, bufferlist *in, buffer RGWModifyOp operation = (op.delete_marker ? CLS_RGW_OP_LINK_OLH_DM : CLS_RGW_OP_LINK_OLH); ret = log_index_operation(hctx, op.key, operation, op.op_tag, entry.meta.mtime, ver, - CLS_RGW_STATE_COMPLETE, header.ver, header.max_marker); + CLS_RGW_STATE_COMPLETE, header.ver, header.max_marker, op.bilog_flags | RGW_BILOG_FLAG_VERSIONED_OP); if (ret < 0) return ret; } @@ -1617,7 +1618,8 @@ static int rgw_bucket_unlink_instance(cls_method_context_t hctx, bufferlist *in, utime_t mtime = ceph_clock_now(g_ceph_context); /* mtime has no real meaning in instance removal context */ ret = log_index_operation(hctx, op.key, CLS_RGW_OP_UNLINK_INSTANCE, op.op_tag, mtime, ver, - CLS_RGW_STATE_COMPLETE, header.ver, header.max_marker); + CLS_RGW_STATE_COMPLETE, header.ver, header.max_marker, + op.bilog_flags | RGW_BILOG_FLAG_VERSIONED_OP); if (ret < 0) return ret; } diff --git a/src/cls/rgw/cls_rgw_client.cc b/src/cls/rgw/cls_rgw_client.cc index 5d8e6102be62..40a54def6f44 100644 --- a/src/cls/rgw/cls_rgw_client.cc +++ b/src/cls/rgw/cls_rgw_client.cc @@ -27,7 +27,8 @@ void cls_rgw_bucket_set_tag_timeout(ObjectWriteOperation& o, uint64_t tag_timeou } void cls_rgw_bucket_prepare_op(ObjectWriteOperation& o, RGWModifyOp op, string& tag, - const cls_rgw_obj_key& key, const string& locator, bool log_op) + const cls_rgw_obj_key& key, const string& locator, bool log_op, + uint16_t bilog_flags) { struct rgw_cls_obj_prepare_op call; call.op = op; @@ -35,6 +36,7 @@ void cls_rgw_bucket_prepare_op(ObjectWriteOperation& o, RGWModifyOp op, string& call.key = key; call.locator = locator; call.log_op = log_op; + call.bilog_flags = bilog_flags; bufferlist in; ::encode(call, in); o.exec("rgw", "bucket_prepare_op", in); @@ -44,7 +46,8 @@ void cls_rgw_bucket_complete_op(ObjectWriteOperation& o, RGWModifyOp op, string& rgw_bucket_entry_ver& ver, const cls_rgw_obj_key& key, rgw_bucket_dir_entry_meta& dir_meta, - list *remove_objs, bool log_op) + list *remove_objs, bool log_op, + uint16_t bilog_flags) { bufferlist in; @@ -55,6 +58,7 @@ void cls_rgw_bucket_complete_op(ObjectWriteOperation& o, RGWModifyOp op, string& call.ver = ver; call.meta = dir_meta; call.log_op = log_op; + call.bilog_flags = bilog_flags; if (remove_objs) call.remove_objs = *remove_objs; ::encode(call, in); diff --git a/src/cls/rgw/cls_rgw_client.h b/src/cls/rgw/cls_rgw_client.h index d7568949e0d0..9decc5a8a018 100644 --- a/src/cls/rgw/cls_rgw_client.h +++ b/src/cls/rgw/cls_rgw_client.h @@ -18,13 +18,15 @@ void cls_rgw_bucket_init(librados::ObjectWriteOperation& o); void cls_rgw_bucket_set_tag_timeout(librados::ObjectWriteOperation& o, uint64_t tag_timeout); void cls_rgw_bucket_prepare_op(librados::ObjectWriteOperation& o, RGWModifyOp op, string& tag, - const cls_rgw_obj_key& key, const string& locator, bool log_op); + const cls_rgw_obj_key& key, const string& locator, bool log_op, + uint16_t bilog_op); void cls_rgw_bucket_complete_op(librados::ObjectWriteOperation& o, RGWModifyOp op, string& tag, rgw_bucket_entry_ver& ver, const cls_rgw_obj_key& key, rgw_bucket_dir_entry_meta& dir_meta, - list *remove_objs, bool log_op); + list *remove_objs, bool log_op, + uint16_t bilog_op); int cls_rgw_list_op(librados::IoCtx& io_ctx, const string& oid, const cls_rgw_obj_key& start_obj, diff --git a/src/cls/rgw/cls_rgw_ops.cc b/src/cls/rgw/cls_rgw_ops.cc index b70df791ff7b..df63af49f40c 100644 --- a/src/cls/rgw/cls_rgw_ops.cc +++ b/src/cls/rgw/cls_rgw_ops.cc @@ -105,6 +105,8 @@ void rgw_cls_obj_prepare_op::dump(Formatter *f) const f->dump_string("name", key.name); f->dump_string("tag", tag); f->dump_string("locator", locator); + f->dump_bool("log_op", log_op); + f->dump_int("bilog_flags", bilog_flags); } void rgw_cls_obj_complete_op::generate_test_instances(list& o) @@ -140,6 +142,8 @@ void rgw_cls_obj_complete_op::dump(Formatter *f) const meta.dump(f); f->close_section(); f->dump_string("tag", tag); + f->dump_bool("log_op", log_op); + f->dump_int("bilog_flags", bilog_flags); } void rgw_cls_link_olh_op::generate_test_instances(list& o) @@ -170,6 +174,7 @@ void rgw_cls_link_olh_op::dump(Formatter *f) const ::encode_json("meta", meta, f); ::encode_json("olh_epoch", olh_epoch, f); ::encode_json("log_op", log_op, f); + ::encode_json("bilog_flags", (uint32_t)bilog_flags, f); } void rgw_cls_unlink_instance_op::generate_test_instances(list& o) @@ -191,6 +196,7 @@ void rgw_cls_unlink_instance_op::dump(Formatter *f) const ::encode_json("op_tag", op_tag, f); ::encode_json("olh_epoch", olh_epoch, f); ::encode_json("log_op", log_op, f); + ::encode_json("bilog_flags", (uint32_t)bilog_flags, f); } void rgw_cls_read_olh_log_op::generate_test_instances(list& o) diff --git a/src/cls/rgw/cls_rgw_ops.h b/src/cls/rgw/cls_rgw_ops.h index 7891828fc024..27ef2ed091f0 100644 --- a/src/cls/rgw/cls_rgw_ops.h +++ b/src/cls/rgw/cls_rgw_ops.h @@ -34,21 +34,23 @@ struct rgw_cls_obj_prepare_op string tag; string locator; bool log_op; + uint16_t bilog_flags; - rgw_cls_obj_prepare_op() : op(CLS_RGW_OP_UNKNOWN), log_op(false) {} + rgw_cls_obj_prepare_op() : op(CLS_RGW_OP_UNKNOWN), log_op(false), bilog_flags(0) {} void encode(bufferlist &bl) const { - ENCODE_START(5, 5, bl); + ENCODE_START(6, 5, bl); uint8_t c = (uint8_t)op; ::encode(c, bl); ::encode(tag, bl); ::encode(locator, bl); ::encode(log_op, bl); ::encode(key, bl); + ::encode(bilog_flags, bl); ENCODE_FINISH(bl); } void decode(bufferlist::iterator &bl) { - DECODE_START_LEGACY_COMPAT_LEN(5, 3, 3, bl); + DECODE_START_LEGACY_COMPAT_LEN(6, 3, 3, bl); uint8_t c; ::decode(c, bl); op = (RGWModifyOp)c; @@ -65,6 +67,9 @@ struct rgw_cls_obj_prepare_op if (struct_v >= 5) { ::decode(key, bl); } + if (struct_v >= 6) { + ::decode(bilog_flags, bl); + } DECODE_FINISH(bl); } void dump(Formatter *f) const; @@ -81,13 +86,14 @@ struct rgw_cls_obj_complete_op struct rgw_bucket_dir_entry_meta meta; string tag; bool log_op; + uint16_t bilog_flags; list remove_objs; - rgw_cls_obj_complete_op() : op(CLS_RGW_OP_ADD), log_op(false) {} + rgw_cls_obj_complete_op() : op(CLS_RGW_OP_ADD), log_op(false), bilog_flags(0) {} void encode(bufferlist &bl) const { - ENCODE_START(7, 7, bl); + ENCODE_START(8, 7, bl); uint8_t c = (uint8_t)op; ::encode(c, bl); ::encode(ver.epoch, bl); @@ -98,10 +104,11 @@ struct rgw_cls_obj_complete_op ::encode(ver, bl); ::encode(log_op, bl); ::encode(key, bl); + ::encode(bilog_flags, bl); ENCODE_FINISH(bl); } void decode(bufferlist::iterator &bl) { - DECODE_START_LEGACY_COMPAT_LEN(7, 3, 3, bl); + DECODE_START_LEGACY_COMPAT_LEN(8, 3, 3, bl); uint8_t c; ::decode(c, bl); op = (RGWModifyOp)c; @@ -138,6 +145,9 @@ struct rgw_cls_obj_complete_op if (struct_v >= 7) { ::decode(key, bl); } + if (struct_v >= 8) { + ::decode(bilog_flags, bl); + } DECODE_FINISH(bl); } void dump(Formatter *f) const; @@ -153,8 +163,9 @@ struct rgw_cls_link_olh_op { struct rgw_bucket_dir_entry_meta meta; uint64_t olh_epoch; bool log_op; + uint16_t bilog_flags; - rgw_cls_link_olh_op() : delete_marker(false), olh_epoch(0), log_op(false) {} + rgw_cls_link_olh_op() : delete_marker(false), olh_epoch(0), log_op(false), bilog_flags(0) {} void encode(bufferlist& bl) const { ENCODE_START(1, 1, bl); @@ -165,6 +176,7 @@ struct rgw_cls_link_olh_op { ::encode(meta, bl); ::encode(olh_epoch, bl); ::encode(log_op, bl); + ::encode(bilog_flags, bl); ENCODE_FINISH(bl); } @@ -177,6 +189,7 @@ struct rgw_cls_link_olh_op { ::decode(meta, bl); ::decode(olh_epoch, bl); ::decode(log_op, bl); + ::decode(bilog_flags, bl); DECODE_FINISH(bl); } @@ -190,8 +203,9 @@ struct rgw_cls_unlink_instance_op { string op_tag; uint64_t olh_epoch; bool log_op; + uint16_t bilog_flags; - rgw_cls_unlink_instance_op() : olh_epoch(0), log_op(false) {} + rgw_cls_unlink_instance_op() : olh_epoch(0), log_op(false), bilog_flags(0) {} void encode(bufferlist& bl) const { ENCODE_START(1, 1, bl); @@ -199,6 +213,7 @@ struct rgw_cls_unlink_instance_op { ::encode(op_tag, bl); ::encode(olh_epoch, bl); ::encode(log_op, bl); + ::encode(bilog_flags, bl); ENCODE_FINISH(bl); } @@ -208,6 +223,7 @@ struct rgw_cls_unlink_instance_op { ::decode(op_tag, bl); ::decode(olh_epoch, bl); ::decode(log_op, bl); + ::decode(bilog_flags, bl); DECODE_FINISH(bl); } diff --git a/src/cls/rgw/cls_rgw_types.cc b/src/cls/rgw/cls_rgw_types.cc index a2daa153a4d8..c830991cab21 100644 --- a/src/cls/rgw/cls_rgw_types.cc +++ b/src/cls/rgw/cls_rgw_types.cc @@ -321,6 +321,7 @@ void rgw_bi_log_entry::dump(Formatter *f) const f->open_object_section("ver"); ver.dump(f); f->close_section(); + f->dump_bool("versioned", (bilog_flags & RGW_BILOG_FLAG_VERSIONED_OP) != 0); } void rgw_bi_log_entry::generate_test_instances(list& ls) diff --git a/src/cls/rgw/cls_rgw_types.h b/src/cls/rgw/cls_rgw_types.h index 5221520cbc53..2799de5d5e3e 100644 --- a/src/cls/rgw/cls_rgw_types.h +++ b/src/cls/rgw/cls_rgw_types.h @@ -32,6 +32,10 @@ enum RGWModifyOp { CLS_RGW_OP_UNLINK_INSTANCE = 6, }; +enum RGWBILogFlags { + RGW_BILOG_FLAG_VERSIONED_OP = 0x1, +}; + struct rgw_bucket_pending_info { RGWPendingState state; utime_t timestamp; @@ -462,8 +466,9 @@ struct rgw_bi_log_entry { RGWPendingState state; uint64_t index_ver; string tag; + uint16_t bilog_flags; - rgw_bi_log_entry() : op(CLS_RGW_OP_UNKNOWN), state(CLS_RGW_STATE_PENDING_MODIFY), index_ver(0) {} + rgw_bi_log_entry() : op(CLS_RGW_OP_UNKNOWN), state(CLS_RGW_STATE_PENDING_MODIFY), index_ver(0), bilog_flags(0) {} void encode(bufferlist &bl) const { ENCODE_START(2, 1, bl); @@ -478,6 +483,7 @@ struct rgw_bi_log_entry { ::encode(c, bl); encode_packed_val(index_ver, bl); ::encode(instance, bl); + ::encode(bilog_flags, bl); ENCODE_FINISH(bl); } void decode(bufferlist::iterator &bl) { @@ -493,7 +499,10 @@ struct rgw_bi_log_entry { ::decode(c, bl); state = (RGWPendingState)c; decode_packed_val(index_ver, bl); - ::decode(instance, bl); + if (struct_v >= 2) { + ::decode(instance, bl); + ::decode(bilog_flags, bl); + } DECODE_FINISH(bl); } void dump(Formatter *f) const; diff --git a/src/rgw/rgw_rados.cc b/src/rgw/rgw_rados.cc index 138f84d5835a..e40f3fde46b2 100644 --- a/src/rgw/rgw_rados.cc +++ b/src/rgw/rgw_rados.cc @@ -897,7 +897,7 @@ RGWPutObjProcessor_Aio::~RGWPutObjProcessor_Aio() list::iterator iter; for (iter = written_objs.begin(); iter != written_objs.end(); ++iter) { rgw_obj& obj = *iter; - int r = store->delete_obj(obj_ctx, bucket_info, obj, false); + int r = store->delete_obj(obj_ctx, bucket_info, obj, 0, 0); if (r < 0 && r != -ENOENT) { ldout(store->ctx(), 0) << "WARNING: failed to remove obj (" << obj << "), leaked" << dendl; } @@ -2914,9 +2914,15 @@ int RGWRados::Object::Write::write_meta(uint64_t size, index_tag = state->write_tag; + bool versioned_op = (target->versioning_enabled() || is_olh || versioned_target); + RGWRados::Bucket bop(store, bucket); RGWRados::Bucket::UpdateIndex index_op(&bop, obj, state); + if (versioned_op) { + index_op.set_bilog_flags(RGW_BILOG_FLAG_VERSIONED_OP); + } + r = index_op.prepare(CLS_RGW_OP_ADD); if (r < 0) return r; @@ -2950,7 +2956,7 @@ int RGWRados::Object::Write::write_meta(uint64_t size, target->invalidate_state(); state = NULL; - if (target->versioning_enabled() || is_olh || versioned_target) { + if (versioned_op) { r = store->set_olh(target->get_ctx(), target->get_bucket_info(), obj, false, NULL, meta.olh_epoch); if (r < 0) { return r; @@ -4075,6 +4081,8 @@ int RGWRados::Object::Delete::delete_obj() RGWRados::Bucket bop(store, bucket); RGWRados::Bucket::UpdateIndex index_op(&bop, obj, state); + index_op.set_bilog_flags(params.bilog_flags); + string tag; r = index_op.prepare(CLS_RGW_OP_DEL); if (r < 0) @@ -4120,13 +4128,15 @@ int RGWRados::Object::Delete::delete_obj() return 0; } -int RGWRados::delete_obj(RGWObjectCtx& obj_ctx, RGWBucketInfo& bucket_info, rgw_obj& obj, int versioning_status) +int RGWRados::delete_obj(RGWObjectCtx& obj_ctx, RGWBucketInfo& bucket_info, rgw_obj& obj, + int versioning_status, uint16_t bilog_flags) { RGWRados::Object del_target(this, bucket_info, obj_ctx, obj); RGWRados::Object::Delete del_op(&del_target); del_op.params.bucket_owner = bucket_info.owner; del_op.params.versioning_status = versioning_status; + del_op.params.bilog_flags = bilog_flags; return del_op.delete_obj(); } @@ -4813,7 +4823,7 @@ int RGWRados::Bucket::UpdateIndex::prepare(RGWModifyOp op) append_rand_alpha(store->ctx(), optag, optag, 32); } } - ret = store->cls_obj_prepare_op(bucket, op, optag, obj); + ret = store->cls_obj_prepare_op(bucket, op, optag, obj, bilog_flags); return ret; } @@ -4841,7 +4851,7 @@ int RGWRados::Bucket::UpdateIndex::complete(int64_t poolid, uint64_t epoch, uint ent.owner_display_name = owner.get_display_name(); ent.content_type = content_type; - int ret = store->cls_obj_complete_add(bucket, optag, poolid, epoch, ent, category, remove_objs); + int ret = store->cls_obj_complete_add(bucket, optag, poolid, epoch, ent, category, remove_objs, bilog_flags); return ret; } @@ -4849,14 +4859,14 @@ int RGWRados::Bucket::UpdateIndex::complete(int64_t poolid, uint64_t epoch, uint int RGWRados::Bucket::UpdateIndex::complete_del(int64_t poolid, uint64_t epoch) { RGWRados *store = target->get_store(); - return store->cls_obj_complete_del(target->get_bucket(), optag, poolid, epoch, obj); + return store->cls_obj_complete_del(target->get_bucket(), optag, poolid, epoch, obj, bilog_flags); } int RGWRados::Bucket::UpdateIndex::cancel() { RGWRados *store = target->get_store(); - return store->cls_obj_complete_cancel(target->get_bucket(), optag, obj); + return store->cls_obj_complete_cancel(target->get_bucket(), optag, obj, bilog_flags); } int RGWRados::Object::Read::read(int64_t ofs, int64_t end, bufferlist& bl) @@ -5867,7 +5877,7 @@ int RGWRados::apply_olh_log(RGWObjectCtx& obj_ctx, RGWObjState& state, RGWBucket cls_rgw_obj_key& key = *liter; rgw_obj obj_instance(bucket, key.name); obj_instance.set_instance(key.instance); - int ret = delete_obj(obj_ctx, bucket_info, obj_instance, 0); + int ret = delete_obj(obj_ctx, bucket_info, obj_instance, 0, RGW_BILOG_FLAG_VERSIONED_OP); if (ret < 0 && ret != -ENOENT) { ldout(cct, 0) << "ERROR: delete_obj() returned " << ret << " obj_instance=" << obj_instance << dendl; return ret; @@ -7019,7 +7029,7 @@ int RGWRados::cls_rgw_init_index(librados::IoCtx& index_ctx, librados::ObjectWri } int RGWRados::cls_obj_prepare_op(rgw_bucket& bucket, RGWModifyOp op, string& tag, - rgw_obj& obj) + rgw_obj& obj, uint16_t bilog_flags) { librados::IoCtx index_ctx; string oid; @@ -7030,7 +7040,7 @@ int RGWRados::cls_obj_prepare_op(rgw_bucket& bucket, RGWModifyOp op, string& tag ObjectWriteOperation o; cls_rgw_obj_key key(obj.get_index_key_name(), obj.get_instance()); - cls_rgw_bucket_prepare_op(o, op, tag, key, obj.get_loc(), zone_public_config.log_data); + cls_rgw_bucket_prepare_op(o, op, tag, key, obj.get_loc(), zone_public_config.log_data, bilog_flags); r = index_ctx.operate(oid, &o); return r; } @@ -7038,7 +7048,7 @@ int RGWRados::cls_obj_prepare_op(rgw_bucket& bucket, RGWModifyOp op, string& tag int RGWRados::cls_obj_complete_op(rgw_bucket& bucket, RGWModifyOp op, string& tag, int64_t pool, uint64_t epoch, RGWObjEnt& ent, RGWObjCategory category, - list *remove_objs) + list *remove_objs, uint16_t bilog_flags) { librados::IoCtx index_ctx; string oid; @@ -7075,7 +7085,7 @@ int RGWRados::cls_obj_complete_op(rgw_bucket& bucket, RGWModifyOp op, string& ta ver.epoch = epoch; cls_rgw_obj_key key(ent.key.name, ent.key.instance); cls_rgw_bucket_complete_op(o, op, tag, ver, key, dir_meta, pro, - zone_public_config.log_data); + zone_public_config.log_data, bilog_flags); AioCompletion *c = librados::Rados::aio_create_completion(NULL, NULL, NULL); r = index_ctx.aio_operate(oid, c, &o); @@ -7086,25 +7096,25 @@ int RGWRados::cls_obj_complete_op(rgw_bucket& bucket, RGWModifyOp op, string& ta int RGWRados::cls_obj_complete_add(rgw_bucket& bucket, string& tag, int64_t pool, uint64_t epoch, RGWObjEnt& ent, RGWObjCategory category, - list *remove_objs) + list *remove_objs, uint16_t bilog_flags) { - return cls_obj_complete_op(bucket, CLS_RGW_OP_ADD, tag, pool, epoch, ent, category, remove_objs); + return cls_obj_complete_op(bucket, CLS_RGW_OP_ADD, tag, pool, epoch, ent, category, remove_objs, bilog_flags); } int RGWRados::cls_obj_complete_del(rgw_bucket& bucket, string& tag, int64_t pool, uint64_t epoch, - rgw_obj& obj) + rgw_obj& obj, uint16_t bilog_flags) { RGWObjEnt ent; obj.get_index_key(&ent.key); - return cls_obj_complete_op(bucket, CLS_RGW_OP_DEL, tag, pool, epoch, ent, RGW_OBJ_CATEGORY_NONE, NULL); + return cls_obj_complete_op(bucket, CLS_RGW_OP_DEL, tag, pool, epoch, ent, RGW_OBJ_CATEGORY_NONE, NULL, bilog_flags); } -int RGWRados::cls_obj_complete_cancel(rgw_bucket& bucket, string& tag, rgw_obj& obj) +int RGWRados::cls_obj_complete_cancel(rgw_bucket& bucket, string& tag, rgw_obj& obj, uint16_t bilog_flags) { RGWObjEnt ent; obj.get_index_key(&ent.key); - return cls_obj_complete_op(bucket, CLS_RGW_OP_ADD, tag, -1 /* pool id */, 0, ent, RGW_OBJ_CATEGORY_NONE, NULL); + return cls_obj_complete_op(bucket, CLS_RGW_OP_ADD, tag, -1 /* pool id */, 0, ent, RGW_OBJ_CATEGORY_NONE, NULL, bilog_flags); } int RGWRados::cls_obj_set_bucket_tag_timeout(rgw_bucket& bucket, uint64_t timeout) diff --git a/src/rgw/rgw_rados.h b/src/rgw/rgw_rados.h index eadd3ec36d24..2c32adb90060 100644 --- a/src/rgw/rgw_rados.h +++ b/src/rgw/rgw_rados.h @@ -1495,8 +1495,9 @@ public: ACLOwner obj_owner; /* needed for creation of deletion marker */ uint64_t olh_epoch; string marker_version_id; + uint32_t bilog_flags; - DeleteParams() : versioning_status(0), olh_epoch(0) {} + DeleteParams() : versioning_status(0), olh_epoch(0), bilog_flags(0) {} } params; struct DeleteResult { @@ -1527,9 +1528,14 @@ public: string optag; rgw_obj obj; RGWObjState *obj_state; + uint16_t bilog_flags; public: - UpdateIndex(RGWRados::Bucket *_target, rgw_obj& _obj, RGWObjState *_state) : target(_target), obj(_obj), obj_state(_state) {} + UpdateIndex(RGWRados::Bucket *_target, rgw_obj& _obj, RGWObjState *_state) : target(_target), obj(_obj), obj_state(_state), bilog_flags(0) {} + + void set_bilog_flags(uint16_t flags) { + bilog_flags = flags; + } int prepare(RGWModifyOp); int complete(int64_t poolid, uint64_t epoch, uint64_t size, @@ -1686,7 +1692,8 @@ public: int bucket_suspended(rgw_bucket& bucket, bool *suspended); /** Delete an object.*/ - virtual int delete_obj(RGWObjectCtx& obj_ctx, RGWBucketInfo& bucket_owner, rgw_obj& src_obj, int versioning_status); + virtual int delete_obj(RGWObjectCtx& obj_ctx, RGWBucketInfo& bucket_owner, rgw_obj& src_obj, + int versioning_status, uint16_t bilog_flags = 0); /* Delete a system object */ virtual int delete_system_obj(rgw_obj& src_obj, RGWObjVersionTracker *objv_tracker = NULL); @@ -1845,12 +1852,12 @@ public: int cls_rgw_init_index(librados::IoCtx& io_ctx, librados::ObjectWriteOperation& op, string& oid); int cls_obj_prepare_op(rgw_bucket& bucket, RGWModifyOp op, string& tag, - rgw_obj& obj); + rgw_obj& obj, uint16_t bilog_flags); int cls_obj_complete_op(rgw_bucket& bucket, RGWModifyOp op, string& tag, int64_t pool, uint64_t epoch, - RGWObjEnt& ent, RGWObjCategory category, list *remove_objs); - int cls_obj_complete_add(rgw_bucket& bucket, string& tag, int64_t pool, uint64_t epoch, RGWObjEnt& ent, RGWObjCategory category, list *remove_objs); - int cls_obj_complete_del(rgw_bucket& bucket, string& tag, int64_t pool, uint64_t epoch, rgw_obj& obj); - int cls_obj_complete_cancel(rgw_bucket& bucket, string& tag, rgw_obj& obj); + RGWObjEnt& ent, RGWObjCategory category, list *remove_objs, uint16_t bilog_flags); + int cls_obj_complete_add(rgw_bucket& bucket, string& tag, int64_t pool, uint64_t epoch, RGWObjEnt& ent, RGWObjCategory category, list *remove_objs, uint16_t bilog_flags); + int cls_obj_complete_del(rgw_bucket& bucket, string& tag, int64_t pool, uint64_t epoch, rgw_obj& obj, uint16_t bilog_flags); + int cls_obj_complete_cancel(rgw_bucket& bucket, string& tag, rgw_obj& obj, uint16_t bilog_flags); int cls_obj_set_bucket_tag_timeout(rgw_bucket& bucket, uint64_t timeout); int cls_bucket_list(rgw_bucket& bucket, rgw_obj_key& start, const string& prefix, uint32_t num, bool list_versions, map& m, bool *is_truncated, -- 2.47.3