1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
2 // vim: ts=8 sw=2 smarttab
5 #include "rgw_bucket.h"
6 #include "rgw_reshard.h"
7 #include "cls/rgw/cls_rgw_client.h"
8 #include "cls/lock/cls_lock_client.h"
9 #include "common/errno.h"
10 #include "common/ceph_json.h"
12 #include "common/dout.h"
14 #define dout_context g_ceph_context
15 #define dout_subsys ceph_subsys_rgw
17 const string reshard_oid_prefix = "reshard.";
18 const string reshard_lock_name = "reshard_process";
19 const string bucket_instance_lock_name = "bucket_instance_lock";
23 #define RESHARD_SHARD_WINDOW 64
24 #define RESHARD_MAX_AIO 128
26 class BucketReshardShard {
28 const RGWBucketInfo& bucket_info;
30 RGWRados::BucketShard bs;
31 vector<rgw_cls_bi_entry> entries;
32 map<uint8_t, rgw_bucket_category_stats> stats;
33 deque<librados::AioCompletion *>& aio_completions;
35 int wait_next_completion() {
36 librados::AioCompletion *c = aio_completions.front();
37 aio_completions.pop_front();
41 int ret = c->get_return_value();
45 derr << "ERROR: reshard rados operation failed: " << cpp_strerror(-ret) << dendl;
52 int get_completion(librados::AioCompletion **c) {
53 if (aio_completions.size() >= RESHARD_MAX_AIO) {
54 int ret = wait_next_completion();
60 *c = librados::Rados::aio_create_completion(nullptr, nullptr, nullptr);
61 aio_completions.push_back(*c);
67 BucketReshardShard(RGWRados *_store, const RGWBucketInfo& _bucket_info,
69 deque<librados::AioCompletion *>& _completions) : store(_store), bucket_info(_bucket_info), bs(store),
70 aio_completions(_completions) {
71 num_shard = (bucket_info.num_shards > 0 ? _num_shard : -1);
72 bs.init(bucket_info.bucket, num_shard);
79 int add_entry(rgw_cls_bi_entry& entry, bool account, uint8_t category,
80 const rgw_bucket_category_stats& entry_stats) {
81 entries.push_back(entry);
83 rgw_bucket_category_stats& target = stats[category];
84 target.num_entries += entry_stats.num_entries;
85 target.total_size += entry_stats.total_size;
86 target.total_size_rounded += entry_stats.total_size_rounded;
88 if (entries.size() >= RESHARD_SHARD_WINDOW) {
97 if (entries.size() == 0) {
101 librados::ObjectWriteOperation op;
102 for (auto& entry : entries) {
103 store->bi_put(op, bs, entry);
105 cls_rgw_bucket_update_stats(op, false, stats);
107 librados::AioCompletion *c;
108 int ret = get_completion(&c);
112 ret = bs.index_ctx.aio_operate(bs.bucket_obj, c, &op);
114 derr << "ERROR: failed to store entries in target bucket shard (bs=" << bs.bucket << "/" << bs.shard_id << ") error=" << cpp_strerror(-ret) << dendl;
124 while (!aio_completions.empty()) {
125 int r = wait_next_completion();
134 class BucketReshardManager {
136 const RGWBucketInfo& target_bucket_info;
137 deque<librados::AioCompletion *> completions;
138 int num_target_shards;
139 vector<BucketReshardShard *> target_shards;
142 BucketReshardManager(RGWRados *_store, const RGWBucketInfo& _target_bucket_info, int _num_target_shards) : store(_store), target_bucket_info(_target_bucket_info),
143 num_target_shards(_num_target_shards) {
144 target_shards.resize(num_target_shards);
145 for (int i = 0; i < num_target_shards; ++i) {
146 target_shards[i] = new BucketReshardShard(store, target_bucket_info, i, completions);
150 ~BucketReshardManager() {
151 for (auto& shard : target_shards) {
152 int ret = shard->wait_all_aio();
154 ldout(store->ctx(), 20) << __func__ << ": shard->wait_all_aio() returned ret=" << ret << dendl;
159 int add_entry(int shard_index,
160 rgw_cls_bi_entry& entry, bool account, uint8_t category,
161 const rgw_bucket_category_stats& entry_stats) {
162 int ret = target_shards[shard_index]->add_entry(entry, account, category, entry_stats);
164 derr << "ERROR: target_shards.add_entry(" << entry.idx << ") returned error: " << cpp_strerror(-ret) << dendl;
172 for (auto& shard : target_shards) {
173 int r = shard->flush();
175 derr << "ERROR: target_shards[" << shard->get_num_shard() << "].flush() returned error: " << cpp_strerror(-r) << dendl;
179 for (auto& shard : target_shards) {
180 int r = shard->wait_all_aio();
182 derr << "ERROR: target_shards[" << shard->get_num_shard() << "].wait_all_aio() returned error: " << cpp_strerror(-r) << dendl;
187 target_shards.clear();
192 RGWBucketReshard::RGWBucketReshard(RGWRados *_store, const RGWBucketInfo& _bucket_info, const map<string, bufferlist>& _bucket_attrs) :
193 store(_store), bucket_info(_bucket_info), bucket_attrs(_bucket_attrs),
194 reshard_lock(reshard_lock_name) {
195 const rgw_bucket& b = bucket_info.bucket;
196 reshard_oid = b.tenant + (b.tenant.empty() ? "" : ":") + b.name + ":" + b.bucket_id;
198 utime_t lock_duration(store->ctx()->_conf->rgw_reshard_bucket_lock_duration, 0);
199 #define COOKIE_LEN 16
200 char cookie_buf[COOKIE_LEN + 1];
201 gen_rand_alphanumeric(store->ctx(), cookie_buf, sizeof(cookie_buf) - 1);
202 cookie_buf[COOKIE_LEN] = '\0';
204 reshard_lock.set_cookie(cookie_buf);
205 reshard_lock.set_duration(lock_duration);
208 int RGWBucketReshard::lock_bucket()
210 int ret = reshard_lock.lock_exclusive(&store->reshard_pool_ctx, reshard_oid);
212 ldout(store->ctx(), 0) << "RGWReshard::add failed to acquire lock on " << reshard_oid << " ret=" << ret << dendl;
218 void RGWBucketReshard::unlock_bucket()
220 int ret = reshard_lock.unlock(&store->reshard_pool_ctx, reshard_oid);
222 ldout(store->ctx(), 0) << "WARNING: RGWReshard::add failed to drop lock on " << reshard_oid << " ret=" << ret << dendl;
226 int RGWBucketReshard::set_resharding_status(const string& new_instance_id, int32_t num_shards, cls_rgw_reshard_status status)
228 if (new_instance_id.empty()) {
229 ldout(store->ctx(), 0) << __func__ << " missing new bucket instance id" << dendl;
233 cls_rgw_bucket_instance_entry instance_entry;
234 instance_entry.set_status(new_instance_id, num_shards, status);
236 int ret = store->bucket_set_reshard(bucket_info, instance_entry);
238 ldout(store->ctx(), 0) << "RGWReshard::" << __func__ << " ERROR: error setting bucket resharding flag on bucket index: "
239 << cpp_strerror(-ret) << dendl;
245 int RGWBucketReshard::clear_resharding()
247 cls_rgw_bucket_instance_entry instance_entry;
249 int ret = store->bucket_set_reshard(bucket_info, instance_entry);
251 ldout(store->ctx(), 0) << "RGWReshard::" << __func__ << " ERROR: error setting bucket resharding flag on bucket index: "
252 << cpp_strerror(-ret) << dendl;
258 static int create_new_bucket_instance(RGWRados *store,
260 const RGWBucketInfo& bucket_info,
261 map<string, bufferlist>& attrs,
262 RGWBucketInfo& new_bucket_info)
264 new_bucket_info = bucket_info;
266 store->create_bucket_id(&new_bucket_info.bucket.bucket_id);
267 new_bucket_info.bucket.oid.clear();
269 new_bucket_info.num_shards = new_num_shards;
270 new_bucket_info.objv_tracker.clear();
272 new_bucket_info.new_bucket_instance_id.clear();
273 new_bucket_info.reshard_status = 0;
275 int ret = store->init_bucket_index(new_bucket_info, new_bucket_info.num_shards);
277 cerr << "ERROR: failed to init new bucket indexes: " << cpp_strerror(-ret) << std::endl;
281 ret = store->put_bucket_instance_info(new_bucket_info, true, real_time(), &attrs);
283 cerr << "ERROR: failed to store new bucket instance info: " << cpp_strerror(-ret) << std::endl;
290 int RGWBucketReshard::create_new_bucket_instance(int new_num_shards,
291 RGWBucketInfo& new_bucket_info)
293 return ::create_new_bucket_instance(store, new_num_shards, bucket_info, bucket_attrs, new_bucket_info);
296 class BucketInfoReshardUpdate
299 RGWBucketInfo bucket_info;
300 std::map<string, bufferlist> bucket_attrs;
302 bool in_progress{false};
304 int set_status(cls_rgw_reshard_status s) {
305 bucket_info.reshard_status = s;
306 int ret = store->put_bucket_instance_info(bucket_info, false, real_time(), &bucket_attrs);
308 ldout(store->ctx(), 0) << "ERROR: failed to write bucket info, ret=" << ret << dendl;
315 BucketInfoReshardUpdate(RGWRados *_store, RGWBucketInfo& _bucket_info,
316 map<string, bufferlist>& _bucket_attrs, const string& new_bucket_id) : store(_store),
317 bucket_info(_bucket_info),
318 bucket_attrs(_bucket_attrs) {
319 bucket_info.new_bucket_instance_id = new_bucket_id;
321 ~BucketInfoReshardUpdate() {
323 bucket_info.new_bucket_instance_id.clear();
324 set_status(CLS_RGW_RESHARD_NONE);
329 int ret = set_status(CLS_RGW_RESHARD_IN_PROGRESS);
338 int ret = set_status(CLS_RGW_RESHARD_DONE);
347 int RGWBucketReshard::do_reshard(
349 const RGWBucketInfo& new_bucket_info,
353 Formatter *formatter)
355 rgw_bucket& bucket = bucket_info.bucket;
360 (*out) << "*** NOTICE: operation will not remove old bucket index objects ***" << std::endl;
361 (*out) << "*** these will need to be removed manually ***" << std::endl;
362 (*out) << "tenant: " << bucket_info.bucket.tenant << std::endl;
363 (*out) << "bucket name: " << bucket_info.bucket.name << std::endl;
364 (*out) << "old bucket instance id: " << bucket_info.bucket.bucket_id << std::endl;
365 (*out) << "new bucket instance id: " << new_bucket_info.bucket.bucket_id << std::endl;
368 /* update bucket info -- in progress*/
369 list<rgw_cls_bi_entry> entries;
371 if (max_entries < 0) {
372 ldout(store->ctx(), 0) << __func__ << ": can't reshard, negative max_entries" << dendl;
376 BucketInfoReshardUpdate bucket_info_updater(store, bucket_info, bucket_attrs, new_bucket_info.bucket.bucket_id);
378 ret = bucket_info_updater.start();
380 ldout(store->ctx(), 0) << __func__ << ": failed to update bucket info ret=" << ret << dendl;
384 int num_target_shards = (new_bucket_info.num_shards > 0 ? new_bucket_info.num_shards : 1);
386 BucketReshardManager target_shards_mgr(store, new_bucket_info, num_target_shards);
388 verbose = verbose && (formatter != nullptr);
391 formatter->open_array_section("entries");
394 uint64_t total_entries = 0;
397 cout << "total entries:";
400 int num_source_shards = (bucket_info.num_shards > 0 ? bucket_info.num_shards : 1);
402 for (int i = 0; i < num_source_shards; ++i) {
403 bool is_truncated = true;
405 while (is_truncated) {
407 ret = store->bi_list(bucket, i, string(), marker, max_entries, &entries, &is_truncated);
408 if (ret < 0 && ret != -ENOENT) {
409 derr << "ERROR: bi_list(): " << cpp_strerror(-ret) << dendl;
413 list<rgw_cls_bi_entry>::iterator iter;
414 for (iter = entries.begin(); iter != entries.end(); ++iter) {
415 rgw_cls_bi_entry& entry = *iter;
417 formatter->open_object_section("entry");
419 encode_json("shard_id", i, formatter);
420 encode_json("num_entry", total_entries, formatter);
421 encode_json("entry", entry, formatter);
428 cls_rgw_obj_key cls_key;
430 rgw_bucket_category_stats stats;
431 bool account = entry.get_info(&cls_key, &category, &stats);
432 rgw_obj_key key(cls_key);
433 rgw_obj obj(new_bucket_info.bucket, key);
434 int ret = store->get_target_shard_id(new_bucket_info, obj.get_hash_object(), &target_shard_id);
436 lderr(store->ctx()) << "ERROR: get_target_shard_id() returned ret=" << ret << dendl;
440 int shard_index = (target_shard_id > 0 ? target_shard_id : 0);
442 ret = target_shards_mgr.add_entry(shard_index, entry, account, category, stats);
447 formatter->close_section();
449 formatter->flush(*out);
450 formatter->flush(*out);
452 } else if (out && !(total_entries % 1000)) {
453 (*out) << " " << total_entries;
459 formatter->close_section();
461 formatter->flush(*out);
464 (*out) << " " << total_entries << std::endl;
467 ret = target_shards_mgr.finish();
469 lderr(store->ctx()) << "ERROR: failed to reshard" << dendl;
473 RGWBucketAdminOpState bucket_op;
475 bucket_op.set_bucket_name(new_bucket_info.bucket.name);
476 bucket_op.set_bucket_id(new_bucket_info.bucket.bucket_id);
477 bucket_op.set_user_id(new_bucket_info.owner);
479 int r = RGWBucketAdminOp::link(store, bucket_op, &err);
481 lderr(store->ctx()) << "failed to link new bucket instance (bucket_id=" << new_bucket_info.bucket.bucket_id << ": " << err << "; " << cpp_strerror(-r) << ")" << dendl;
485 ret = bucket_info_updater.complete();
487 ldout(store->ctx(), 0) << __func__ << ": failed to update bucket info ret=" << ret << dendl;
488 /* don't error out, reshard process succeeded */
493 int RGWBucketReshard::get_status(list<cls_rgw_bucket_instance_entry> *status)
495 librados::IoCtx index_ctx;
496 map<int, string> bucket_objs;
498 int r = store->open_bucket_index(bucket_info, index_ctx, bucket_objs);
503 for (auto i : bucket_objs) {
504 cls_rgw_bucket_instance_entry entry;
506 int ret = cls_rgw_get_bucket_resharding(index_ctx, i.second, &entry);
507 if (ret < 0 && ret != -ENOENT) {
508 lderr(store->ctx()) << "ERROR: " << __func__ << ": cls_rgw_get_bucket_resharding() returned ret=" << ret << dendl;
512 status->push_back(entry);
518 int RGWBucketReshard::execute(int num_shards, int max_op_entries,
519 bool verbose, ostream *out, Formatter *formatter, RGWReshard* reshard_log)
522 int ret = lock_bucket();
527 RGWBucketInfo new_bucket_info;
528 ret = create_new_bucket_instance(num_shards, new_bucket_info);
535 ret = reshard_log->update(bucket_info, new_bucket_info);
542 ret = set_resharding_status(new_bucket_info.bucket.bucket_id, num_shards, CLS_RGW_RESHARD_IN_PROGRESS);
548 ret = do_reshard(num_shards,
551 verbose, out, formatter);
558 ret = set_resharding_status(new_bucket_info.bucket.bucket_id, num_shards, CLS_RGW_RESHARD_DONE);
570 RGWReshard::RGWReshard(RGWRados* _store, bool _verbose, ostream *_out,
571 Formatter *_formatter) : store(_store), instance_lock(bucket_instance_lock_name),
572 verbose(_verbose), out(_out), formatter(_formatter)
574 num_logshards = store->ctx()->_conf->rgw_reshard_num_logs;
577 string RGWReshard::get_logshard_key(const string& tenant, const string& bucket_name)
579 return tenant + ":" + bucket_name;
582 #define MAX_RESHARD_LOGSHARDS_PRIME 7877
584 void RGWReshard::get_bucket_logshard_oid(const string& tenant, const string& bucket_name, string *oid)
586 string key = get_logshard_key(tenant, bucket_name);
588 uint32_t sid = ceph_str_hash_linux(key.c_str(), key.size());
589 uint32_t sid2 = sid ^ ((sid & 0xFF) << 24);
590 sid = sid2 % MAX_RESHARD_LOGSHARDS_PRIME % num_logshards;
591 int logshard = sid % num_logshards;
593 get_logshard_oid(logshard, oid);
596 int RGWReshard::add(cls_rgw_reshard_entry& entry)
598 if (!store->can_reshard()) {
599 ldout(store->ctx(), 20) << __func__ << " Resharding is disabled" << dendl;
605 get_bucket_logshard_oid(entry.tenant, entry.bucket_name, &logshard_oid);
607 librados::ObjectWriteOperation op;
608 cls_rgw_reshard_add(op, entry);
610 int ret = store->reshard_pool_ctx.operate(logshard_oid, &op);
612 lderr(store->ctx()) << "ERROR: failed to add entry to reshard log, oid=" << logshard_oid << " tenant=" << entry.tenant << " bucket=" << entry.bucket_name << dendl;
618 int RGWReshard::update(const RGWBucketInfo& bucket_info, const RGWBucketInfo& new_bucket_info)
620 cls_rgw_reshard_entry entry;
621 entry.bucket_name = bucket_info.bucket.name;
622 entry.bucket_id = bucket_info.bucket.bucket_id;
624 int ret = get(entry);
629 entry.new_instance_id = new_bucket_info.bucket.name + ":" + new_bucket_info.bucket.bucket_id;
633 ldout(store->ctx(), 0) << __func__ << ":Error in updating entry bucket " << entry.bucket_name << ": " <<
634 cpp_strerror(-ret) << dendl;
641 int RGWReshard::list(int logshard_num, string& marker, uint32_t max, std::list<cls_rgw_reshard_entry>& entries, bool *is_truncated)
645 get_logshard_oid(logshard_num, &logshard_oid);
647 int ret = cls_rgw_reshard_list(store->reshard_pool_ctx, logshard_oid, marker, max, entries, is_truncated);
650 if (ret == -ENOENT) {
651 *is_truncated = false;
654 lderr(store->ctx()) << "ERROR: failed to list reshard log entries, oid=" << logshard_oid << dendl;
655 if (ret == -EACCES) {
656 lderr(store->ctx()) << "access denied to pool " << store->get_zone_params().reshard_pool
657 << ". Fix the pool access permissions of your client" << dendl;
664 int RGWReshard::get(cls_rgw_reshard_entry& entry)
668 get_bucket_logshard_oid(entry.tenant, entry.bucket_name, &logshard_oid);
670 int ret = cls_rgw_reshard_get(store->reshard_pool_ctx, logshard_oid, entry);
672 lderr(store->ctx()) << "ERROR: failed to get entry from reshard log, oid=" << logshard_oid << " tenant=" << entry.tenant << " bucket=" << entry.bucket_name << dendl;
679 int RGWReshard::remove(cls_rgw_reshard_entry& entry)
683 get_bucket_logshard_oid(entry.tenant, entry.bucket_name, &logshard_oid);
685 librados::ObjectWriteOperation op;
686 cls_rgw_reshard_remove(op, entry);
688 int ret = store->reshard_pool_ctx.operate(logshard_oid, &op);
690 lderr(store->ctx()) << "ERROR: failed to remove entry from reshard log, oid=" << logshard_oid << " tenant=" << entry.tenant << " bucket=" << entry.bucket_name << dendl;
697 int RGWReshard::clear_bucket_resharding(const string& bucket_instance_oid, cls_rgw_reshard_entry& entry)
699 int ret = cls_rgw_clear_bucket_resharding(store->reshard_pool_ctx, bucket_instance_oid);
701 lderr(store->ctx()) << "ERROR: failed to clear bucket resharding, bucket_instance_oid=" << bucket_instance_oid << dendl;
708 const int num_retries = 10;
709 const int default_reshard_sleep_duration = 5;
711 int RGWReshardWait::do_wait()
713 Mutex::Locker l(lock);
715 cond.WaitInterval(lock, utime_t(default_reshard_sleep_duration, 0));
724 int RGWReshardWait::block_while_resharding(RGWRados::BucketShard *bs, string *new_bucket_id)
727 cls_rgw_bucket_instance_entry entry;
729 for (int i=0; i < num_retries;i++) {
730 ret = cls_rgw_get_bucket_resharding(bs->index_ctx, bs->bucket_obj, &entry);
732 ldout(store->ctx(), 0) << __func__ << " ERROR: failed to get bucket resharding :" <<
733 cpp_strerror(-ret)<< dendl;
736 if (!entry.resharding_in_progress()) {
737 *new_bucket_id = entry.new_bucket_instance_id;
740 ldout(store->ctx(), 20) << "NOTICE: reshard still in progress; " << (i < num_retries - 1 ? "retrying" : "too many retries") << dendl;
741 /* needed to unlock as clear resharding uses the same lock */
743 if (i == num_retries - 1) {
749 ldout(store->ctx(), 0) << __func__ << " ERROR: bucket is still resharding, please retry" << dendl;
753 ldout(store->ctx(), 0) << __func__ << " ERROR: bucket is still resharding, please retry" << dendl;
754 return -ERR_BUSY_RESHARDING;
757 int RGWReshard::process_single_logshard(int logshard_num)
760 bool truncated = true;
762 CephContext *cct = store->ctx();
763 int max_entries = 1000;
766 rados::cls::lock::Lock l(reshard_lock_name);
768 utime_t time(max_secs, 0);
769 l.set_duration(time);
771 char cookie_buf[COOKIE_LEN + 1];
772 gen_rand_alphanumeric(store->ctx(), cookie_buf, sizeof(cookie_buf) - 1);
773 cookie_buf[COOKIE_LEN] = '\0';
775 l.set_cookie(cookie_buf);
778 get_logshard_oid(logshard_num, &logshard_oid);
780 int ret = l.lock_exclusive(&store->reshard_pool_ctx, logshard_oid);
781 if (ret == -EBUSY) { /* already locked by another processor */
782 ldout(store->ctx(), 5) << __func__ << "(): failed to acquire lock on " << logshard_oid << dendl;
786 utime_t lock_start_time = ceph_clock_now();
789 std::list<cls_rgw_reshard_entry> entries;
790 ret = list(logshard_num, marker, max_entries, entries, &truncated);
792 ldout(cct, 10) << "cannot list all reshards in logshard oid=" << logshard_oid << dendl;
796 for(auto& entry: entries) {
797 if(entry.new_instance_id.empty()) {
799 ldout(store->ctx(), 20) << __func__ << " resharding " << entry.bucket_name << dendl;
801 RGWObjectCtx obj_ctx(store);
803 RGWBucketInfo bucket_info;
804 map<string, bufferlist> attrs;
806 ret = store->get_bucket_info(obj_ctx, entry.tenant, entry.bucket_name, bucket_info, nullptr,
809 ldout(cct, 0) << __func__ << ": Error in get_bucket_info: " << cpp_strerror(-ret) << dendl;
813 RGWBucketReshard br(store, bucket_info, attrs);
815 Formatter* formatter = new JSONFormatter(false);
816 auto formatter_ptr = std::unique_ptr<Formatter>(formatter);
817 ret = br.execute(entry.new_num_shards, max_entries, true,nullptr, formatter, this);
819 ldout (store->ctx(), 0) << __func__ << "ERROR in reshard_bucket " << entry.bucket_name << ":" <<
820 cpp_strerror(-ret)<< dendl;
824 ldout (store->ctx(), 20) << " removing entry" << entry.bucket_name<< dendl;
828 ldout(cct, 0)<< __func__ << ":Error removing bucket " << entry.bucket_name << " for resharding queue: "
829 << cpp_strerror(-ret) << dendl;
833 utime_t now = ceph_clock_now();
835 if (now > lock_start_time + max_secs / 2) { /* do you need to renew lock? */
837 ret = l.lock_exclusive(&store->reshard_pool_ctx, logshard_oid);
838 if (ret == -EBUSY) { /* already locked by another processor */
839 ldout(store->ctx(), 5) << __func__ << "(): failed to acquire lock on " << logshard_oid << dendl;
842 lock_start_time = now;
844 entry.get_key(&marker);
848 l.unlock(&store->reshard_pool_ctx, logshard_oid);
853 void RGWReshard::get_logshard_oid(int shard_num, string *logshard)
856 snprintf(buf, sizeof(buf), "%010u", (unsigned)shard_num);
858 string objname(reshard_oid_prefix);
859 *logshard = objname + buf;
862 int RGWReshard::process_all_logshards()
864 if (!store->can_reshard()) {
865 ldout(store->ctx(), 20) << __func__ << " Resharding is disabled" << dendl;
870 for (int i = 0; i < num_logshards; i++) {
872 get_logshard_oid(i, &logshard);
874 ldout(store->ctx(), 20) << "proceeding logshard = " << logshard << dendl;
876 ret = process_single_logshard(i);
885 bool RGWReshard::going_down()
890 void RGWReshard::start_processor()
892 worker = new ReshardWorker(store->ctx(), this);
893 worker->create("rgw_reshard");
896 void RGWReshard::stop_processor()
907 void *RGWReshard::ReshardWorker::entry() {
910 utime_t start = ceph_clock_now();
911 if (reshard->process_all_logshards()) {
912 /* All shards have been processed properly. Next time we can start
913 * from this moment. */
917 if (reshard->going_down())
920 utime_t end = ceph_clock_now();
922 int secs = cct->_conf->rgw_reshard_thread_interval;
924 if (secs <= end.sec())
925 continue; // next round
930 cond.WaitInterval(lock, utime_t(secs, 0));
932 } while (!reshard->going_down());
937 void RGWReshard::ReshardWorker::stop()
939 Mutex::Locker l(lock);