From: Haomai Wang Date: Fri, 10 Apr 2015 07:25:33 +0000 (+0800) Subject: Librbd: Don't affect global md_config_t X-Git-Tag: v9.0.1~147^2~1 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=dcf2b3b9e905575fba548c7a9b16fd61280f20ba;p=ceph.git Librbd: Don't affect global md_config_t Signed-off-by: Haomai Wang --- diff --git a/src/librbd/AioRequest.cc b/src/librbd/AioRequest.cc index 38e5db74b24d..eca8896720e3 100644 --- a/src/librbd/AioRequest.cc +++ b/src/librbd/AioRequest.cc @@ -89,7 +89,7 @@ namespace librbd { static inline bool is_copy_on_read(ImageCtx *ictx, librados::snap_t snap_id) { assert(ictx->snap_lock.is_locked()); - return (ictx->rbd_clone_copy_on_read) && + return (ictx->clone_copy_on_read) && (!ictx->read_only) && (snap_id == CEPH_NOSNAP); } diff --git a/src/librbd/AsyncFlattenRequest.cc b/src/librbd/AsyncFlattenRequest.cc index 9c1b2b8c8fa6..13037846bac6 100644 --- a/src/librbd/AsyncFlattenRequest.cc +++ b/src/librbd/AsyncFlattenRequest.cc @@ -124,7 +124,7 @@ void AsyncFlattenRequest::send() { AsyncObjectThrottle *throttle = new AsyncObjectThrottle( *this, context_factory, create_callback_context(), m_prog_ctx, 0, m_overlap_objects); - throttle->start_ops(m_image_ctx.rbd_concurrent_management_ops); + throttle->start_ops(m_image_ctx.concurrent_management_ops); } bool AsyncFlattenRequest::send_update_header() { diff --git a/src/librbd/AsyncTrimRequest.cc b/src/librbd/AsyncTrimRequest.cc index 211ceffa5664..996857c78356 100644 --- a/src/librbd/AsyncTrimRequest.cc +++ b/src/librbd/AsyncTrimRequest.cc @@ -150,7 +150,7 @@ void AsyncTrimRequest::send_remove_objects() { boost::lambda::_1, &m_image_ctx, boost::lambda::_2)); AsyncObjectThrottle *throttle = new AsyncObjectThrottle( *this, context_factory, ctx, m_prog_ctx, m_delete_start, m_num_objects); - throttle->start_ops(m_image_ctx.rbd_concurrent_management_ops); + throttle->start_ops(m_image_ctx.concurrent_management_ops); } void AsyncTrimRequest::send_pre_remove() { diff --git a/src/librbd/ImageCtx.cc b/src/librbd/ImageCtx.cc index 0dc032e00b56..14b490f0b743 100644 --- a/src/librbd/ImageCtx.cc +++ b/src/librbd/ImageCtx.cc @@ -2,6 +2,7 @@ // vim: ts=8 sw=2 smarttab #include #include +#include #include "common/ceph_context.h" #include "common/dout.h" @@ -151,42 +152,42 @@ namespace librbd { header_oid = old_header_name(name); } - if (rbd_cache) { + if (cache) { Mutex::Locker l(cache_lock); ldout(cct, 20) << "enabling caching..." << dendl; writeback_handler = new LibrbdWriteback(this, cache_lock); - uint64_t init_max_dirty = rbd_cache_max_dirty; - if (rbd_cache_writethrough_until_flush) + uint64_t init_max_dirty = cache_max_dirty; + if (cache_writethrough_until_flush) init_max_dirty = 0; ldout(cct, 20) << "Initial cache settings:" - << " size=" << rbd_cache_size + << " size=" << cache_size << " num_objects=" << 10 << " max_dirty=" << init_max_dirty - << " target_dirty=" << rbd_cache_target_dirty + << " target_dirty=" << cache_target_dirty << " max_dirty_age=" - << rbd_cache_max_dirty_age << dendl; + << cache_max_dirty_age << dendl; object_cacher = new ObjectCacher(cct, pname, *writeback_handler, cache_lock, NULL, NULL, - rbd_cache_size, + cache_size, 10, /* reset this in init */ init_max_dirty, - rbd_cache_target_dirty, - rbd_cache_max_dirty_age, - rbd_cache_block_writes_upfront); + cache_target_dirty, + cache_max_dirty_age, + cache_block_writes_upfront); object_set = new ObjectCacher::ObjectSet(NULL, data_ctx.get_id(), 0); object_set->return_enoent = true; object_cacher->start(); } - if (rbd_clone_copy_on_read) { + if (clone_copy_on_read) { copyup_finisher = new Finisher(cct); copyup_finisher->start(); } - readahead.set_trigger_requests(rbd_readahead_trigger_requests); - readahead.set_max_readahead_size(rbd_readahead_max_bytes); + readahead.set_trigger_requests(readahead_trigger_requests); + readahead.set_max_readahead_size(readahead_max_bytes); perf_start(pname); return 0; @@ -222,12 +223,12 @@ namespace librbd { // size object cache appropriately if (object_cacher) { - uint64_t obj = rbd_cache_max_dirty_object; + uint64_t obj = cache_max_dirty_object; if (!obj) { - obj = rbd_cache_size / (1ull << order); + obj = cache_size / (1ull << order); obj = obj * 4 + 10; } - ldout(cct, 10) << " cache bytes " << rbd_cache_size << " order " << (int)order + ldout(cct, 10) << " cache bytes " << cache_size << " order " << (int)order << " -> about " << obj << " objects" << dendl; object_cacher->set_max_objects(obj); } @@ -291,9 +292,9 @@ namespace librbd { if (snap_id == LIBRADOS_SNAP_HEAD) return flags; - if (rbd_balance_snap_reads) + if (balance_snap_reads) flags |= librados::OPERATION_BALANCE_READS; - else if (rbd_localize_snap_reads) + else if (localize_snap_reads) flags |= librados::OPERATION_LOCALIZE_READS; return flags; } @@ -613,12 +614,12 @@ namespace librbd { } void ImageCtx::user_flushed() { - if (object_cacher && rbd_cache_writethrough_until_flush) { + if (object_cacher && cache_writethrough_until_flush) { md_lock.get_read(); bool flushed_before = flush_encountered; md_lock.put_read(); - uint64_t max_dirty = rbd_cache_max_dirty; + uint64_t max_dirty = cache_max_dirty; if (!flushed_before && max_dirty > 0) { md_lock.get_write(); flush_encountered = true; @@ -810,7 +811,7 @@ namespace librbd { } } - bool ImageCtx::_filter_metadata_confs(const string &prefix, const vector &configs, + bool ImageCtx::_filter_metadata_confs(const string &prefix, map &configs, map &pairs, map *res) { size_t conf_prefix_len = prefix.size(); @@ -820,9 +821,10 @@ namespace librbd { return false; string key = it->first.substr(conf_prefix_len, it->first.size() - conf_prefix_len); - for (std::vector::const_iterator cit = configs.begin(); + for (map::iterator cit = configs.begin(); cit != configs.end(); ++cit) { - if (!key.compare(*cit)) { + if (!key.compare(cit->first)) { + cit->second = true; res->insert(make_pair(key, it->second)); break; } @@ -834,31 +836,32 @@ namespace librbd { void ImageCtx::apply_metadata_confs() { ldout(cct, 20) << __func__ << dendl; static uint64_t max_conf_items = 128; - const std::vector configs = boost::assign::list_of( - "rbd_cache")( - "rbd_cache_writethrough_until_flush")( - "rbd_cache_size")( - "rbd_cache_max_dirty")( - "rbd_cache_target_dirty")( - "rbd_cache_max_dirty_age")( - "rbd_cache_max_dirty_object")( - "rbd_cache_block_writes_upfront")( - "rbd_concurrent_management_ops")( - "rbd_balance_snap_reads")( - "rbd_localize_snap_reads")( - "rbd_balance_parent_reads")( - "rbd_localize_parent_reads")( - "rbd_readahead_trigger_requests")( - "rbd_readahead_max_bytes")( - "rbd_readahead_disable_after_bytes")( - "rbd_clone_copy_on_read")( - "rbd_blacklist_on_break_lock")( - "rbd_blacklist_expire_seconds")( - "rbd_request_timed_out_seconds"); + std::map configs = boost::assign::map_list_of( + "rbd_cache", false)( + "rbd_cache_writethrough_until_flush", false)( + "rbd_cache_size", false)( + "rbd_cache_max_dirty", false)( + "rbd_cache_target_dirty", false)( + "rbd_cache_max_dirty_age", false)( + "rbd_cache_max_dirty_object", false)( + "rbd_cache_block_writes_upfront", false)( + "rbd_concurrent_management_ops", false)( + "rbd_balance_snap_reads", false)( + "rbd_localize_snap_reads", false)( + "rbd_balance_parent_reads", false)( + "rbd_localize_parent_reads", false)( + "rbd_readahead_trigger_requests", false)( + "rbd_readahead_max_bytes", false)( + "rbd_readahead_disable_after_bytes", false)( + "rbd_clone_copy_on_read", false)( + "rbd_blacklist_on_break_lock", false)( + "rbd_blacklist_expire_seconds", false)( + "rbd_request_timed_out_seconds", false); string start = METADATA_CONF_PREFIX; int r = 0, j = 0; bool is_continue; + md_config_t local_config_t; do { map pairs, res; r = cls_client::metadata_list(&md_ctx, header_oid, start, max_conf_items, &pairs); @@ -871,7 +874,7 @@ namespace librbd { is_continue = _filter_metadata_confs(METADATA_CONF_PREFIX, configs, pairs, &res); for (map::iterator it = res.begin(); it != res.end(); ++it) { - j = cct->_conf->set_val(it->first.c_str(), it->second.c_str()); + j = local_config_t.set_val(it->first.c_str(), it->second.c_str()); if (j < 0) lderr(cct) << __func__ << " failed to set config " << it->first << " with value " << it->second.c_str() << ": " << j << dendl; @@ -880,26 +883,33 @@ namespace librbd { start = pairs.rbegin()->first; } while (is_continue); - md_config_t *conf = cct->_conf; - rbd_cache = conf->rbd_cache; - rbd_cache_writethrough_until_flush = conf->rbd_cache_writethrough_until_flush; - rbd_cache_size = conf->rbd_cache_size; - rbd_cache_max_dirty = conf->rbd_cache_max_dirty; - rbd_cache_target_dirty = conf->rbd_cache_target_dirty; - rbd_cache_max_dirty_age = conf->rbd_cache_max_dirty_age; - rbd_cache_max_dirty_object = conf->rbd_cache_max_dirty_object; - rbd_cache_block_writes_upfront = conf->rbd_cache_block_writes_upfront; - rbd_concurrent_management_ops = conf->rbd_concurrent_management_ops; - rbd_balance_snap_reads = conf->rbd_balance_snap_reads; - rbd_localize_snap_reads = conf->rbd_localize_snap_reads; - rbd_balance_parent_reads = conf->rbd_balance_parent_reads; - rbd_localize_parent_reads = conf->rbd_localize_parent_reads; - rbd_readahead_trigger_requests = conf->rbd_readahead_trigger_requests; - rbd_readahead_max_bytes = conf->rbd_readahead_max_bytes; - rbd_readahead_disable_after_bytes = conf->rbd_readahead_disable_after_bytes; - rbd_clone_copy_on_read = conf->rbd_clone_copy_on_read; - rbd_blacklist_on_break_lock = conf->rbd_blacklist_on_break_lock; - rbd_blacklist_expire_seconds = conf->rbd_blacklist_expire_seconds; - rbd_request_timed_out_seconds = conf->rbd_request_timed_out_seconds; +#define ASSIGN_OPTION(config) \ + do { \ + if (configs[#config]) \ + config = local_config_t.rbd_##config; \ + else \ + config = cct->_conf->rbd_##config; \ + } while (0); + + ASSIGN_OPTION(cache); + ASSIGN_OPTION(cache_writethrough_until_flush); + ASSIGN_OPTION(cache_size); + ASSIGN_OPTION(cache_max_dirty); + ASSIGN_OPTION(cache_target_dirty); + ASSIGN_OPTION(cache_max_dirty_age); + ASSIGN_OPTION(cache_max_dirty_object); + ASSIGN_OPTION(cache_block_writes_upfront); + ASSIGN_OPTION(concurrent_management_ops); + ASSIGN_OPTION(balance_snap_reads); + ASSIGN_OPTION(localize_snap_reads); + ASSIGN_OPTION(balance_parent_reads); + ASSIGN_OPTION(localize_parent_reads); + ASSIGN_OPTION(readahead_trigger_requests); + ASSIGN_OPTION(readahead_max_bytes); + ASSIGN_OPTION(readahead_disable_after_bytes); + ASSIGN_OPTION(clone_copy_on_read); + ASSIGN_OPTION(blacklist_on_break_lock); + ASSIGN_OPTION(blacklist_expire_seconds); + ASSIGN_OPTION(request_timed_out_seconds); } } diff --git a/src/librbd/ImageCtx.h b/src/librbd/ImageCtx.h index 32cb6a785b4a..e82111cf917a 100644 --- a/src/librbd/ImageCtx.h +++ b/src/librbd/ImageCtx.h @@ -132,27 +132,27 @@ namespace librbd { // Configuration static const string METADATA_CONF_PREFIX; - bool rbd_cache; - bool rbd_cache_writethrough_until_flush; - uint64_t rbd_cache_size; - uint64_t rbd_cache_max_dirty; - uint64_t rbd_cache_target_dirty; - double rbd_cache_max_dirty_age; - uint32_t rbd_cache_max_dirty_object; - bool rbd_cache_block_writes_upfront; - uint32_t rbd_concurrent_management_ops; - bool rbd_balance_snap_reads; - bool rbd_localize_snap_reads; - bool rbd_balance_parent_reads; - bool rbd_localize_parent_reads; - uint32_t rbd_readahead_trigger_requests; - uint64_t rbd_readahead_max_bytes; - uint64_t rbd_readahead_disable_after_bytes; - bool rbd_clone_copy_on_read; - bool rbd_blacklist_on_break_lock; - uint32_t rbd_blacklist_expire_seconds; - uint32_t rbd_request_timed_out_seconds; - static bool _filter_metadata_confs(const string &prefix, const std::vector &configs, + bool cache; + bool cache_writethrough_until_flush; + uint64_t cache_size; + uint64_t cache_max_dirty; + uint64_t cache_target_dirty; + double cache_max_dirty_age; + uint32_t cache_max_dirty_object; + bool cache_block_writes_upfront; + uint32_t concurrent_management_ops; + bool balance_snap_reads; + bool localize_snap_reads; + bool balance_parent_reads; + bool localize_parent_reads; + uint32_t readahead_trigger_requests; + uint64_t readahead_max_bytes; + uint64_t readahead_disable_after_bytes; + bool clone_copy_on_read; + bool blacklist_on_break_lock; + uint32_t blacklist_expire_seconds; + uint32_t request_timed_out_seconds; + static bool _filter_metadata_confs(const string &prefix, std::map &configs, map &pairs, map *res); /** diff --git a/src/librbd/ImageWatcher.cc b/src/librbd/ImageWatcher.cc index ed8bfcf50077..df5706cf38bc 100644 --- a/src/librbd/ImageWatcher.cc +++ b/src/librbd/ImageWatcher.cc @@ -153,12 +153,12 @@ int ImageWatcher::try_lock() { } } - if (m_image_ctx.rbd_blacklist_on_break_lock) { + if (m_image_ctx.blacklist_on_break_lock) { ldout(m_image_ctx.cct, 1) << "blacklisting client: " << locker << "@" << locker_address << dendl; librados::Rados rados(m_image_ctx.md_ctx); r = rados.blacklist_add(locker_address, - m_image_ctx.rbd_blacklist_expire_seconds); + m_image_ctx.blacklist_expire_seconds); if (r < 0) { lderr(m_image_ctx.cct) << "unable to blacklist client: " << cpp_strerror(r) << dendl; @@ -662,7 +662,7 @@ void ImageWatcher::schedule_async_request_timed_out(const AsyncRequestId &id) { Task task(TASK_CODE_ASYNC_REQUEST, id); m_task_finisher->cancel(task); - m_task_finisher->add_event_after(task, m_image_ctx.rbd_request_timed_out_seconds, ctx); + m_task_finisher->add_event_after(task, m_image_ctx.request_timed_out_seconds, ctx); } void ImageWatcher::async_request_timed_out(const AsyncRequestId &id) { diff --git a/src/librbd/internal.cc b/src/librbd/internal.cc index 77d1e29ba15e..66fc735f181b 100644 --- a/src/librbd/internal.cc +++ b/src/librbd/internal.cc @@ -303,7 +303,7 @@ namespace librbd { int r; CephContext *cct = ictx->cct; - SimpleThrottle throttle(ictx->rbd_concurrent_management_ops, true); + SimpleThrottle throttle(ictx->concurrent_management_ops, true); for (uint64_t i = 0; i < numseg; i++) { string oid = ictx->get_object_name(i); @@ -1395,9 +1395,9 @@ reprotect_and_return_err: ictx->parent = new ImageCtx("", parent_image_id, NULL, p_ioctx, true); // set rados flags for reading the parent image - if (ictx->rbd_balance_parent_reads) + if (ictx->balance_parent_reads) ictx->parent->set_read_flag(librados::OPERATION_BALANCE_READS); - else if (ictx->rbd_localize_parent_reads) + else if (ictx->localize_parent_reads) ictx->parent->set_read_flag(librados::OPERATION_LOCALIZE_READS); r = open_image(ictx->parent); @@ -2316,7 +2316,7 @@ reprotect_and_return_err: return r; } - SimpleThrottle throttle(src->rbd_concurrent_management_ops, false); + SimpleThrottle throttle(src->concurrent_management_ops, false); uint64_t period = src->get_stripe_period(); for (uint64_t offset = 0; offset < src_size; offset += period) { uint64_t len = min(period, src_size - offset); @@ -2704,7 +2704,7 @@ reprotect_and_return_err: return -EINVAL; } - if (ictx->rbd_blacklist_on_break_lock) { + if (ictx->blacklist_on_break_lock) { typedef std::map Lockers; Lockers lockers; @@ -2734,7 +2734,7 @@ reprotect_and_return_err: RWLock::RLocker locker(ictx->md_lock); librados::Rados rados(ictx->md_ctx); r = rados.blacklist_add(client_address, - ictx->rbd_blacklist_expire_seconds); + ictx->blacklist_expire_seconds); if (r < 0) { lderr(ictx->cct) << "unable to blacklist client: " << cpp_strerror(r) << dendl; @@ -3640,8 +3640,8 @@ reprotect_and_return_err: total_bytes += p->second; } ictx->md_lock.get_write(); - bool abort = ictx->rbd_readahead_disable_after_bytes != 0 && - ictx->total_bytes_read > ictx->rbd_readahead_disable_after_bytes; + bool abort = ictx->readahead_disable_after_bytes != 0 && + ictx->total_bytes_read > ictx->readahead_disable_after_bytes; ictx->total_bytes_read += total_bytes; ictx->snap_lock.get_read(); uint64_t image_size = ictx->get_image_size(ictx->snap_id); @@ -3686,7 +3686,7 @@ reprotect_and_return_err: } // readahead - if (ictx->object_cacher && ictx->rbd_readahead_max_bytes > 0 && + if (ictx->object_cacher && ictx->readahead_max_bytes > 0 && !(op_flags & LIBRADOS_OP_FLAG_FADVISE_RANDOM)) { readahead(ictx, image_extents); } diff --git a/src/test/librbd/test_internal.cc b/src/test/librbd/test_internal.cc index 7952c127165f..e6f8907c3894 100644 --- a/src/test/librbd/test_internal.cc +++ b/src/test/librbd/test_internal.cc @@ -366,10 +366,11 @@ TEST_F(TestInternal, MultipleResize) { TEST_F(TestInternal, MetadatConfig) { REQUIRE_FEATURE(RBD_FEATURE_LAYERING); - const vector test_confs = boost::assign::list_of( - "aaaaaaa")( - "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")( - "cccccccccccccc"); + map test_confs = boost::assign::map_list_of( + "aaaaaaa", false)( + "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", false)( + "cccccccccccccc", false); + map::iterator it = test_confs.begin(); const string prefix = "test_config_"; bool is_continue; librbd::ImageCtx *ictx; @@ -377,18 +378,26 @@ TEST_F(TestInternal, MetadatConfig) { librbd::Image image1; map pairs, res; - pairs[prefix+test_confs[0]].append("value1"); - pairs[prefix+test_confs[1]].append("value2"); - pairs[prefix+test_confs[2]].append("value3"); + pairs[prefix+it->first].append("value1"); + it++; + pairs[prefix+it->first].append("value2"); + it++; + pairs[prefix+it->first].append("value3"); pairs[prefix+"asdfsdaf"].append("value6"); pairs[prefix+"zxvzxcv123"].append("value5"); is_continue = ictx->_filter_metadata_confs(prefix, test_confs, pairs, &res); ASSERT_TRUE(is_continue); ASSERT_TRUE(res.size() == 3U); - ASSERT_TRUE(res.count(test_confs[0])); - ASSERT_TRUE(res.count(test_confs[1])); - ASSERT_TRUE(res.count(test_confs[2])); + it = test_confs.begin(); + ASSERT_TRUE(res.count(it->first)); + ASSERT_TRUE(it->second); + it++; + ASSERT_TRUE(res.count(it->first)); + ASSERT_TRUE(it->second); + it++; + ASSERT_TRUE(res.count(it->first)); + ASSERT_TRUE(it->second); res.clear(); pairs["zzzzzzzz"].append("value7");