From: Haomai Wang Date: Fri, 3 Apr 2015 03:01:57 +0000 (+0800) Subject: Librbd: Discard all global config used for image X-Git-Tag: v9.0.1~147^2~5 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=b235a42a0a7be45be660656bd764d85faccf5237;p=ceph.git Librbd: Discard all global config used for image Signed-off-by: Haomai Wang --- diff --git a/src/librbd/AioRequest.cc b/src/librbd/AioRequest.cc index 3bbbab9ec6e9..38e5db74b24d 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->cct->_conf->rbd_clone_copy_on_read) && + return (ictx->rbd_clone_copy_on_read) && (!ictx->read_only) && (snap_id == CEPH_NOSNAP); } diff --git a/src/librbd/AsyncFlattenRequest.cc b/src/librbd/AsyncFlattenRequest.cc index 87c2655641f4..9c1b2b8c8fa6 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(cct->_conf->rbd_concurrent_management_ops); + throttle->start_ops(m_image_ctx.rbd_concurrent_management_ops); } bool AsyncFlattenRequest::send_update_header() { diff --git a/src/librbd/AsyncTrimRequest.cc b/src/librbd/AsyncTrimRequest.cc index d3dcd8118735..211ceffa5664 100644 --- a/src/librbd/AsyncTrimRequest.cc +++ b/src/librbd/AsyncTrimRequest.cc @@ -139,7 +139,6 @@ void AsyncTrimRequest::send() { } void AsyncTrimRequest::send_remove_objects() { - CephContext *cct = m_image_ctx.cct; ldout(m_image_ctx.cct, 5) << this << " send_remove_objects: " << " delete_start=" << m_delete_start << " num_objects=" << m_num_objects << dendl; @@ -151,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(cct->_conf->rbd_concurrent_management_ops); + throttle->start_ops(m_image_ctx.rbd_concurrent_management_ops); } void AsyncTrimRequest::send_pre_remove() { diff --git a/src/librbd/ImageCtx.cc b/src/librbd/ImageCtx.cc index fca778f61f3e..31a06c5bad2b 100644 --- a/src/librbd/ImageCtx.cc +++ b/src/librbd/ImageCtx.cc @@ -150,6 +150,7 @@ namespace librbd { } header_oid = header_name(id); + aware_metadata_confs(); r = cls_client::get_immutable_metadata(&md_ctx, header_oid, &object_prefix, &order); if (r < 0) { @@ -168,46 +169,46 @@ namespace librbd { init_layout(); } else { + aware_metadata_confs(); header_oid = old_header_name(name); } - if (cct->_conf->rbd_cache) { + if (rbd_cache) { Mutex::Locker l(cache_lock); ldout(cct, 20) << "enabling caching..." << dendl; writeback_handler = new LibrbdWriteback(this, cache_lock); - uint64_t init_max_dirty = cct->_conf->rbd_cache_max_dirty; - if (cct->_conf->rbd_cache_writethrough_until_flush) + uint64_t init_max_dirty = rbd_cache_max_dirty; + if (rbd_cache_writethrough_until_flush) init_max_dirty = 0; ldout(cct, 20) << "Initial cache settings:" - << " size=" << cct->_conf->rbd_cache_size + << " size=" << rbd_cache_size << " num_objects=" << 10 << " max_dirty=" << init_max_dirty - << " target_dirty=" << cct->_conf->rbd_cache_target_dirty + << " target_dirty=" << rbd_cache_target_dirty << " max_dirty_age=" - << cct->_conf->rbd_cache_max_dirty_age << dendl; + << rbd_cache_max_dirty_age << dendl; object_cacher = new ObjectCacher(cct, pname, *writeback_handler, cache_lock, NULL, NULL, - cct->_conf->rbd_cache_size, + rbd_cache_size, 10, /* reset this in init */ init_max_dirty, - cct->_conf->rbd_cache_target_dirty, - cct->_conf->rbd_cache_max_dirty_age, - cct->_conf->rbd_cache_block_writes_upfront); + rbd_cache_target_dirty, + rbd_cache_max_dirty_age, + rbd_cache_block_writes_upfront); object_set = new ObjectCacher::ObjectSet(NULL, data_ctx.get_id(), 0); object_set->return_enoent = true; object_cacher->start(); } - if (cct->_conf->rbd_clone_copy_on_read) { + if (rbd_clone_copy_on_read) { copyup_finisher = new Finisher(cct); copyup_finisher->start(); } - md_config_t *conf = cct->_conf; - readahead.set_trigger_requests(conf->rbd_readahead_trigger_requests); - readahead.set_max_readahead_size(conf->rbd_readahead_max_bytes); + readahead.set_trigger_requests(rbd_readahead_trigger_requests); + readahead.set_max_readahead_size(rbd_readahead_max_bytes); perf_start(pname); return 0; @@ -243,12 +244,12 @@ namespace librbd { // size object cache appropriately if (object_cacher) { - uint64_t obj = cct->_conf->rbd_cache_max_dirty_object; + uint64_t obj = rbd_cache_max_dirty_object; if (!obj) { - obj = cct->_conf->rbd_cache_size / (1ull << order); + obj = rbd_cache_size / (1ull << order); obj = obj * 4 + 10; } - ldout(cct, 10) << " cache bytes " << cct->_conf->rbd_cache_size << " order " << (int)order + ldout(cct, 10) << " cache bytes " << rbd_cache_size << " order " << (int)order << " -> about " << obj << " objects" << dendl; object_cacher->set_max_objects(obj); } @@ -312,9 +313,9 @@ namespace librbd { if (snap_id == LIBRADOS_SNAP_HEAD) return flags; - if (cct->_conf->rbd_balance_snap_reads) + if (rbd_balance_snap_reads) flags |= librados::OPERATION_BALANCE_READS; - else if (cct->_conf->rbd_localize_snap_reads) + else if (rbd_localize_snap_reads) flags |= librados::OPERATION_LOCALIZE_READS; return flags; } @@ -634,12 +635,12 @@ namespace librbd { } void ImageCtx::user_flushed() { - if (object_cacher && cct->_conf->rbd_cache_writethrough_until_flush) { + if (object_cacher && rbd_cache_writethrough_until_flush) { md_lock.get_read(); bool flushed_before = flush_encountered; md_lock.put_read(); - uint64_t max_dirty = cct->_conf->rbd_cache_max_dirty; + uint64_t max_dirty = rbd_cache_max_dirty; if (!flushed_before && max_dirty > 0) { md_lock.get_write(); flush_encountered = true; @@ -879,7 +880,29 @@ namespace librbd { } start = pairs.rbegin()->first; } while (is_continue); + cct->_conf->apply_changes(NULL); - } + 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; + } } diff --git a/src/librbd/ImageCtx.h b/src/librbd/ImageCtx.h index a372002a1938..7698805cfca8 100644 --- a/src/librbd/ImageCtx.h +++ b/src/librbd/ImageCtx.h @@ -130,7 +130,33 @@ namespace librbd { xlist async_resize_reqs; + // Configuration static const string METADATA_CONF_PREFIX; + static const char *AWARE_CONFS[]; + static const size_t AWARE_CONFS_LEN; + 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 _aware_metadata_confs(const string &prefix, const char **configs, size_t len, + map &pairs, map *res); + /** * Either image_name or image_id must be set. * If id is not known, pass the empty std::string, @@ -208,10 +234,6 @@ namespace librbd { void cancel_async_requests(); void aware_metadata_confs(); - static bool _aware_metadata_confs(const string &prefix, const char **configs, size_t len, - map &pairs, map *res); - static const char *AWARE_CONFS[]; - static const size_t AWARE_CONFS_LEN; }; } diff --git a/src/librbd/ImageWatcher.cc b/src/librbd/ImageWatcher.cc index 142c2db84233..ed8bfcf50077 100644 --- a/src/librbd/ImageWatcher.cc +++ b/src/librbd/ImageWatcher.cc @@ -153,13 +153,12 @@ int ImageWatcher::try_lock() { } } - md_config_t *conf = m_image_ctx.cct->_conf; - if (conf->rbd_blacklist_on_break_lock) { + if (m_image_ctx.rbd_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, - conf->rbd_blacklist_expire_seconds); + m_image_ctx.rbd_blacklist_expire_seconds); if (r < 0) { lderr(m_image_ctx.cct) << "unable to blacklist client: " << cpp_strerror(r) << dendl; @@ -663,9 +662,7 @@ void ImageWatcher::schedule_async_request_timed_out(const AsyncRequestId &id) { Task task(TASK_CODE_ASYNC_REQUEST, id); m_task_finisher->cancel(task); - md_config_t *conf = m_image_ctx.cct->_conf; - m_task_finisher->add_event_after(task, conf->rbd_request_timed_out_seconds, - ctx); + m_task_finisher->add_event_after(task, m_image_ctx.rbd_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 b4e0a225c121..77d1e29ba15e 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(cct->_conf->rbd_concurrent_management_ops, true); + SimpleThrottle throttle(ictx->rbd_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->cct->_conf->rbd_balance_parent_reads) + if (ictx->rbd_balance_parent_reads) ictx->parent->set_read_flag(librados::OPERATION_BALANCE_READS); - else if (ictx->cct->_conf->rbd_localize_parent_reads) + else if (ictx->rbd_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(cct->_conf->rbd_concurrent_management_ops, false); + SimpleThrottle throttle(src->rbd_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); @@ -2425,7 +2425,6 @@ reprotect_and_return_err: int r = ictx->init(); if (r < 0) goto err_close; - ictx->aware_metadata_confs(); if (!ictx->read_only) { r = ictx->register_watch(); @@ -2705,8 +2704,7 @@ reprotect_and_return_err: return -EINVAL; } - md_config_t *conf = ictx->cct->_conf; - if (conf->rbd_blacklist_on_break_lock) { + if (ictx->rbd_blacklist_on_break_lock) { typedef std::map Lockers; Lockers lockers; @@ -2736,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, - conf->rbd_blacklist_expire_seconds); + ictx->rbd_blacklist_expire_seconds); if (r < 0) { lderr(ictx->cct) << "unable to blacklist client: " << cpp_strerror(r) << dendl; @@ -3633,8 +3631,7 @@ reprotect_and_return_err: }; static void readahead(ImageCtx *ictx, - const vector >& image_extents, - const md_config_t *conf) + const vector >& image_extents) { uint64_t total_bytes = 0; for (vector >::const_iterator p = image_extents.begin(); @@ -3643,8 +3640,8 @@ reprotect_and_return_err: total_bytes += p->second; } ictx->md_lock.get_write(); - bool abort = conf->rbd_readahead_disable_after_bytes != 0 && - ictx->total_bytes_read > (uint64_t)conf->rbd_readahead_disable_after_bytes; + bool abort = ictx->rbd_readahead_disable_after_bytes != 0 && + ictx->total_bytes_read > ictx->rbd_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); @@ -3689,10 +3686,9 @@ reprotect_and_return_err: } // readahead - const md_config_t *conf = ictx->cct->_conf; - if (ictx->object_cacher && conf->rbd_readahead_max_bytes > 0 && + if (ictx->object_cacher && ictx->rbd_readahead_max_bytes > 0 && !(op_flags & LIBRADOS_OP_FLAG_FADVISE_RANDOM)) { - readahead(ictx, image_extents, conf); + readahead(ictx, image_extents); } snap_t snap_id;