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 <yehuda@redhat.com>

diff --git a/src/cls/rgw/cls_rgw.cc b/src/cls/rgw/cls_rgw.cc
index 58d8c1101b65ff20d7af9a1236e60e602a5f4c13..7f7bbfb9df2ab59e195b549d93ce8d95fbead35f 100644 (file)
--- 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 5d8e6102be623421c4ceb5fecc93aaace5634848..40a54def6f4403464efc0141063fe4e5471aac37 100644 (file)
--- 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<cls_rgw_obj_key> *remove_objs, bool log_op)
+                               list<cls_rgw_obj_key> *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 d7568949e0d08e816b10b8e7ba3c305206c85295..9decc5a8a0182b6fba4858fca9c82fb591b6d001 100644 (file)
--- 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<cls_rgw_obj_key> *remove_objs, bool log_op);
+                               list<cls_rgw_obj_key> *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 b70df791ff7bb368bd7c8f23201ad3f13f04438e..df63af49f40ca09a7326f2c85d5ac03cf689c5c2 100644 (file)
--- 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<rgw_cls_obj_complete_op*>& 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<rgw_cls_link_olh_op*>& 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<rgw_cls_unlink_instance_op*>& 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<rgw_cls_read_olh_log_op*>& o)

diff --git a/src/cls/rgw/cls_rgw_ops.h b/src/cls/rgw/cls_rgw_ops.h
index 7891828fc0241d01be9ede71f23bd5f4c0454516..27ef2ed091f09bfadf1f2ec3c9682c8fad7ec923 100644 (file)
--- 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<cls_rgw_obj_key> 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 a2daa153a4d85231c0ad2f0ad66f5f75ea69849a..c830991cab21cf2887c6df5d62272a669ed4493c 100644 (file)
--- 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<rgw_bi_log_entry*>& ls)

diff --git a/src/cls/rgw/cls_rgw_types.h b/src/cls/rgw/cls_rgw_types.h
index 5221520cbc53cce929cdebf74a54334487595a6d..2799de5d5e3eaf54429abe7fcee2e61934f8f998 100644 (file)
--- 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 138f84d5835afac0c34b0e8a184ee2169656e351..e40f3fde46b2ab5543d2f4bd9312edb5ccc76037 100644 (file)
--- a/src/rgw/rgw_rados.cc
+++ b/src/rgw/rgw_rados.cc
@@ -897,7 +897,7 @@ RGWPutObjProcessor_Aio::~RGWPutObjProcessor_Aio()
   list<rgw_obj>::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<rgw_obj_key> *remove_objs)
+                                 list<rgw_obj_key> *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<rgw_obj_key> *remove_objs)
+                                   list<rgw_obj_key> *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 eadd3ec36d242cb480511cf65260bcc2ccf6b5d5..2c32adb90060470a3723e584f27c534aa576e31c 100644 (file)
--- 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<rgw_obj_key> *remove_objs);
-  int cls_obj_complete_add(rgw_bucket& bucket, string& tag, int64_t pool, uint64_t epoch, RGWObjEnt& ent, RGWObjCategory category, list<rgw_obj_key> *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<rgw_obj_key> *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<rgw_obj_key> *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<string, RGWObjEnt>& m, bool *is_truncated,