From b5c9948e38d3fce792e2f63a17aa099c29544598 Mon Sep 17 00:00:00 2001 From: Sage Weil Date: Fri, 14 Sep 2018 10:54:21 -0500 Subject: [PATCH] common: Mutex::Locker -> std::lock_guard Signed-off-by: Sage Weil --- src/common/AsyncOpTracker.cc | 10 +++--- src/common/AsyncReserver.h | 12 +++---- src/common/Cond.h | 6 ++-- src/common/ContextCompletion.cc | 6 ++-- src/common/LogClient.cc | 12 +++---- src/common/OutputDataSocket.cc | 2 +- src/common/PluginRegistry.cc | 4 +-- src/common/Readahead.cc | 4 +-- src/common/RefCountedObj.h | 4 +-- src/common/Throttle.cc | 10 +++--- src/common/Throttle.h | 2 +- src/common/TracepointProvider.cc | 2 +- src/common/TrackedOp.cc | 24 ++++++------- src/common/TrackedOp.h | 6 ++-- src/common/WorkQueue.cc | 2 +- src/common/WorkQueue.h | 32 +++++++++--------- src/common/ceph_context.cc | 6 ++-- src/common/config_proxy.h | 58 ++++++++++++++++---------------- src/common/dns_resolve.cc | 8 ++--- src/common/lru_map.h | 8 ++--- src/common/perf_counters.cc | 12 +++---- 21 files changed, 115 insertions(+), 115 deletions(-) diff --git a/src/common/AsyncOpTracker.cc b/src/common/AsyncOpTracker.cc index 1223873b15463..6d78368f8e723 100644 --- a/src/common/AsyncOpTracker.cc +++ b/src/common/AsyncOpTracker.cc @@ -9,19 +9,19 @@ AsyncOpTracker::AsyncOpTracker() } AsyncOpTracker::~AsyncOpTracker() { - Mutex::Locker locker(m_lock); + std::lock_guard locker(m_lock); ceph_assert(m_pending_ops == 0); } void AsyncOpTracker::start_op() { - Mutex::Locker locker(m_lock); + std::lock_guard locker(m_lock); ++m_pending_ops; } void AsyncOpTracker::finish_op() { Context *on_finish = nullptr; { - Mutex::Locker locker(m_lock); + std::lock_guard locker(m_lock); ceph_assert(m_pending_ops > 0); if (--m_pending_ops == 0) { std::swap(on_finish, m_on_finish); @@ -35,7 +35,7 @@ void AsyncOpTracker::finish_op() { void AsyncOpTracker::wait_for_ops(Context *on_finish) { { - Mutex::Locker locker(m_lock); + std::lock_guard locker(m_lock); ceph_assert(m_on_finish == nullptr); if (m_pending_ops > 0) { m_on_finish = on_finish; @@ -46,7 +46,7 @@ void AsyncOpTracker::wait_for_ops(Context *on_finish) { } bool AsyncOpTracker::empty() { - Mutex::Locker locker(m_lock); + std::lock_guard locker(m_lock); return (m_pending_ops == 0); } diff --git a/src/common/AsyncReserver.h b/src/common/AsyncReserver.h index c88061e9647f3..231e56ea0e44d 100644 --- a/src/common/AsyncReserver.h +++ b/src/common/AsyncReserver.h @@ -132,19 +132,19 @@ public: lock("AsyncReserver::lock") {} void set_max(unsigned max) { - Mutex::Locker l(lock); + std::lock_guard l(lock); max_allowed = max; do_queues(); } void set_min_priority(unsigned min) { - Mutex::Locker l(lock); + std::lock_guard l(lock); min_priority = min; do_queues(); } void dump(Formatter *f) { - Mutex::Locker l(lock); + std::lock_guard l(lock); _dump(f); } void _dump(Formatter *f) { @@ -183,7 +183,7 @@ public: unsigned prio, ///< [in] priority Context *on_preempt = 0 ///< [in] callback to be called if we are preempted (optional) ) { - Mutex::Locker l(lock); + std::lock_guard l(lock); Reservation r(item, prio, on_reserved, on_preempt); rdout(10) << __func__ << " queue " << r << dendl; ceph_assert(!queue_pointers.count(item) && @@ -204,7 +204,7 @@ public: void cancel_reservation( T item ///< [in] key for reservation to cancel ) { - Mutex::Locker l(lock); + std::lock_guard l(lock); auto i = queue_pointers.find(item); if (i != queue_pointers.end()) { unsigned prio = i->second.first; @@ -240,7 +240,7 @@ public: * Return true if there are reservations in progress */ bool has_reservation() { - Mutex::Locker l(lock); + std::lock_guard l(lock); return !in_progress.empty(); } static const unsigned MAX_PRIORITY = (unsigned)-1; diff --git a/src/common/Cond.h b/src/common/Cond.h index c74fcfd37872e..0c7870051af69 100644 --- a/src/common/Cond.h +++ b/src/common/Cond.h @@ -183,7 +183,7 @@ public: /// We overload complete in order to not delete the context void complete(int r) override { - Mutex::Locker l(lock); + std::lock_guard l(lock); done = true; rval = r; cond.Signal(); @@ -191,7 +191,7 @@ public: /// Returns rval once the Context is called int wait() { - Mutex::Locker l(lock); + std::lock_guard l(lock); while (!done) cond.Wait(lock); return rval; @@ -201,7 +201,7 @@ public: int wait_for(double secs) { utime_t interval; interval.set_from_double(secs); - Mutex::Locker l{lock}; + std::lock_guard l{lock}; if (done) { return rval; } diff --git a/src/common/ContextCompletion.cc b/src/common/ContextCompletion.cc index d5ff9f2204c43..8059121992600 100644 --- a/src/common/ContextCompletion.cc +++ b/src/common/ContextCompletion.cc @@ -14,7 +14,7 @@ ContextCompletion::ContextCompletion(Context *ctx, bool ignore_enoent) void ContextCompletion::finish_adding_requests() { bool complete; { - Mutex::Locker l(m_lock); + std::lock_guard l(m_lock); m_building = false; complete = (m_current_ops == 0); } @@ -25,14 +25,14 @@ void ContextCompletion::finish_adding_requests() { } void ContextCompletion::start_op() { - Mutex::Locker l(m_lock); + std::lock_guard l(m_lock); ++m_current_ops; } void ContextCompletion::finish_op(int r) { bool complete; { - Mutex::Locker l(m_lock); + std::lock_guard l(m_lock); if (r < 0 && m_ret == 0 && (!m_ignore_enoent || r != -ENOENT)) { m_ret = r; } diff --git a/src/common/LogClient.cc b/src/common/LogClient.cc index 15f188590ca7a..7ae871484668c 100644 --- a/src/common/LogClient.cc +++ b/src/common/LogClient.cc @@ -212,7 +212,7 @@ void LogChannel::do_log(clog_type prio, std::stringstream& ss) void LogChannel::do_log(clog_type prio, const std::string& s) { - Mutex::Locker l(channel_lock); + std::lock_guard l(channel_lock); if (CLOG_ERROR == prio) { ldout(cct,-1) << "log " << prio << " : " << s << dendl; } else { @@ -250,7 +250,7 @@ void LogChannel::do_log(clog_type prio, const std::string& s) Message *LogClient::get_mon_log_message(bool flush) { - Mutex::Locker l(log_lock); + std::lock_guard l(log_lock); if (flush) { if (log_queue.empty()) return nullptr; @@ -262,7 +262,7 @@ Message *LogClient::get_mon_log_message(bool flush) bool LogClient::are_pending() { - Mutex::Locker l(log_lock); + std::lock_guard l(log_lock); return last_log > last_log_sent; } @@ -324,7 +324,7 @@ void LogClient::_send_to_mon() version_t LogClient::queue(LogEntry &entry) { - Mutex::Locker l(log_lock); + std::lock_guard l(log_lock); entry.seq = ++last_log; log_queue.push_back(entry); @@ -337,7 +337,7 @@ version_t LogClient::queue(LogEntry &entry) uint64_t LogClient::get_next_seq() { - Mutex::Locker l(log_lock); + std::lock_guard l(log_lock); return ++last_log; } @@ -358,7 +358,7 @@ const EntityName& LogClient::get_myname() bool LogClient::handle_log_ack(MLogAck *m) { - Mutex::Locker l(log_lock); + std::lock_guard l(log_lock); ldout(cct,10) << "handle_log_ack " << *m << dendl; version_t last = m->last; diff --git a/src/common/OutputDataSocket.cc b/src/common/OutputDataSocket.cc index 9752ce318cc2a..c417107796ac3 100644 --- a/src/common/OutputDataSocket.cc +++ b/src/common/OutputDataSocket.cc @@ -389,7 +389,7 @@ void OutputDataSocket::shutdown() void OutputDataSocket::append_output(bufferlist& bl) { - Mutex::Locker l(m_lock); + std::lock_guard l(m_lock); if (data_size + bl.length() > data_max_backlog) { ldout(m_cct, 20) << "dropping data output, max backlog reached" << dendl; diff --git a/src/common/PluginRegistry.cc b/src/common/PluginRegistry.cc index a96c98cbd5cbf..fd937df0a6ef2 100644 --- a/src/common/PluginRegistry.cc +++ b/src/common/PluginRegistry.cc @@ -101,7 +101,7 @@ int PluginRegistry::add(const std::string& type, Plugin *PluginRegistry::get_with_load(const std::string& type, const std::string& name) { - Mutex::Locker l(lock); + std::lock_guard l(lock); Plugin* ret = get(type, name); if (!ret) { int err = load(type, name); @@ -218,7 +218,7 @@ int ErasureCodePluginRegistry::preload(const std::string &plugins, const std::string &directory, ostream &ss) { - Mutex::Locker l(lock); + std::lock_guard l(lock); list plugins_list; get_str_list(plugins, plugins_list); for (list::iterator i = plugins_list.begin(); diff --git a/src/common/Readahead.cc b/src/common/Readahead.cc index 1b06c730dcc39..5927c037fe356 100644 --- a/src/common/Readahead.cc +++ b/src/common/Readahead.cc @@ -168,12 +168,12 @@ void Readahead::set_trigger_requests(int trigger_requests) { } uint64_t Readahead::get_min_readahead_size(void) { - Mutex::Locker lock(m_lock); + std::lock_guard lock(m_lock); return m_readahead_min_bytes; } uint64_t Readahead::get_max_readahead_size(void) { - Mutex::Locker lock(m_lock); + std::lock_guard lock(m_lock); return m_readahead_max_bytes; } diff --git a/src/common/RefCountedObj.h b/src/common/RefCountedObj.h index 33f2824cfd633..b1c0aea4f7898 100644 --- a/src/common/RefCountedObj.h +++ b/src/common/RefCountedObj.h @@ -90,7 +90,7 @@ struct RefCountedCond : public RefCountedObject { RefCountedCond() : complete(false), lock("RefCountedCond"), rval(0) {} int wait() { - Mutex::Locker l(lock); + std::lock_guard l(lock); while (!complete) { cond.Wait(lock); } @@ -98,7 +98,7 @@ struct RefCountedCond : public RefCountedObject { } void done(int r) { - Mutex::Locker l(lock); + std::lock_guard l(lock); rval = r; complete = true; cond.SignalAll(); diff --git a/src/common/Throttle.cc b/src/common/Throttle.cc index 4dac8fb7444f5..9a4a10c1b1558 100644 --- a/src/common/Throttle.cc +++ b/src/common/Throttle.cc @@ -700,7 +700,7 @@ TokenBucketThrottle::TokenBucketThrottle( m_avg(avg), m_timer(timer), m_timer_lock(timer_lock), m_lock("token_bucket_throttle_lock") { - Mutex::Locker timer_locker(*m_timer_lock); + std::lock_guard timer_locker(*m_timer_lock); schedule_timer(); } @@ -708,13 +708,13 @@ TokenBucketThrottle::~TokenBucketThrottle() { // cancel the timer events. { - Mutex::Locker timer_locker(*m_timer_lock); + std::lock_guard timer_locker(*m_timer_lock); cancel_timer(); } list tmp_blockers; { - Mutex::Locker blockers_lock(m_lock); + std::lock_guard blockers_lock(m_lock); tmp_blockers.splice(tmp_blockers.begin(), m_blockers, m_blockers.begin(), m_blockers.end()); } @@ -724,7 +724,7 @@ TokenBucketThrottle::~TokenBucketThrottle() } void TokenBucketThrottle::set_max(uint64_t m) { - Mutex::Locker lock(m_lock); + std::lock_guard lock(m_lock); m_throttle.set_max(m); } @@ -736,7 +736,7 @@ void TokenBucketThrottle::add_tokens() { list tmp_blockers; { // put m_avg tokens into bucket. - Mutex::Locker lock(m_lock); + std::lock_guard lock(m_lock); m_throttle.put(m_avg); // check the m_blockers from head to tail, if blocker can get // enough tokens, let it go. diff --git a/src/common/Throttle.h b/src/common/Throttle.h index c28eb6efdf506..6c24ff193148f 100644 --- a/src/common/Throttle.h +++ b/src/common/Throttle.h @@ -389,7 +389,7 @@ public: bool wait = false; uint64_t got = 0; - Mutex::Locker lock(m_lock); + std::lock_guard lock(m_lock); if (!m_blockers.empty()) { // Keep the order of requests, add item after previous blocked requests. wait = true; diff --git a/src/common/TracepointProvider.cc b/src/common/TracepointProvider.cc index 4c89038ced943..8a9b1e6a9647e 100644 --- a/src/common/TracepointProvider.cc +++ b/src/common/TracepointProvider.cc @@ -27,7 +27,7 @@ void TracepointProvider::handle_conf_change( } void TracepointProvider::verify_config(const ConfigProxy& conf) { - Mutex::Locker locker(m_lock); + std::lock_guard locker(m_lock); if (m_handle) { return; } diff --git a/src/common/TrackedOp.cc b/src/common/TrackedOp.cc index 22f4eed25a80e..722213c3ff6b4 100644 --- a/src/common/TrackedOp.cc +++ b/src/common/TrackedOp.cc @@ -63,7 +63,7 @@ void OpHistory::on_shutdown() { opsvc.break_thread(); opsvc.join(); - Mutex::Locker history_lock(ops_history_lock); + std::lock_guard history_lock(ops_history_lock); arrived.clear(); duration.clear(); slow_op.clear(); @@ -72,7 +72,7 @@ void OpHistory::on_shutdown() void OpHistory::_insert_delayed(const utime_t& now, TrackedOpRef op) { - Mutex::Locker history_lock(ops_history_lock); + std::lock_guard history_lock(ops_history_lock); if (shutdown) return; double opduration = op->get_duration(); @@ -110,7 +110,7 @@ void OpHistory::cleanup(utime_t now) void OpHistory::dump_ops(utime_t now, Formatter *f, set filters, bool by_duration) { - Mutex::Locker history_lock(ops_history_lock); + std::lock_guard history_lock(ops_history_lock); cleanup(now); f->open_object_section("op_history"); f->dump_int("size", history_size); @@ -179,7 +179,7 @@ bool OpTracker::dump_historic_ops(Formatter *f, bool by_duration, set fi void OpHistory::dump_slow_ops(utime_t now, Formatter *f, set filters) { - Mutex::Locker history_lock(ops_history_lock); + std::lock_guard history_lock(ops_history_lock); cleanup(now); f->open_object_section("OpHistory slow ops"); f->dump_int("num to keep", history_slow_op_size); @@ -225,7 +225,7 @@ bool OpTracker::dump_ops_in_flight(Formatter *f, bool print_only_blocked, setops_in_flight_lock_sharded); + std::lock_guard locker(sdata->ops_in_flight_lock_sharded); for (auto& op : sdata->ops_in_flight_sharded) { if (print_only_blocked && (now - op.get_initiated() <= complaint_time)) break; @@ -258,7 +258,7 @@ bool OpTracker::register_inflight_op(TrackedOp *i) ShardedTrackingData* sdata = sharded_in_flight_list[shard_index]; ceph_assert(NULL != sdata); { - Mutex::Locker locker(sdata->ops_in_flight_lock_sharded); + std::lock_guard locker(sdata->ops_in_flight_lock_sharded); sdata->ops_in_flight_sharded.push_back(*i); i->seq = current_seq; } @@ -274,7 +274,7 @@ void OpTracker::unregister_inflight_op(TrackedOp* const i) ShardedTrackingData* sdata = sharded_in_flight_list[shard_index]; ceph_assert(NULL != sdata); { - Mutex::Locker locker(sdata->ops_in_flight_lock_sharded); + std::lock_guard locker(sdata->ops_in_flight_lock_sharded); auto p = sdata->ops_in_flight_sharded.iterator_to(*i); sdata->ops_in_flight_sharded.erase(p); } @@ -299,7 +299,7 @@ bool OpTracker::visit_ops_in_flight(utime_t* oldest_secs, RWLock::RLocker l(lock); for (const auto sdata : sharded_in_flight_list) { ceph_assert(sdata); - Mutex::Locker locker(sdata->ops_in_flight_lock_sharded); + std::lock_guard locker(sdata->ops_in_flight_lock_sharded); if (!sdata->ops_in_flight_sharded.empty()) { utime_t oldest_op_tmp = sdata->ops_in_flight_sharded.front().get_initiated(); @@ -322,7 +322,7 @@ bool OpTracker::visit_ops_in_flight(utime_t* oldest_secs, for (uint32_t iter = 0; iter < num_optracker_shards; iter++) { ShardedTrackingData* sdata = sharded_in_flight_list[iter]; ceph_assert(NULL != sdata); - Mutex::Locker locker(sdata->ops_in_flight_lock_sharded); + std::lock_guard locker(sdata->ops_in_flight_lock_sharded); for (auto& op : sdata->ops_in_flight_sharded) { if (!visit(op)) break; @@ -420,7 +420,7 @@ void OpTracker::get_age_ms_histogram(pow2_hist_t *h) for (uint32_t iter = 0; iter < num_optracker_shards; iter++) { ShardedTrackingData* sdata = sharded_in_flight_list[iter]; ceph_assert(NULL != sdata); - Mutex::Locker locker(sdata->ops_in_flight_lock_sharded); + std::lock_guard locker(sdata->ops_in_flight_lock_sharded); for (auto& i : sdata->ops_in_flight_sharded) { utime_t age = now - i.get_initiated(); @@ -440,7 +440,7 @@ void TrackedOp::mark_event_string(const string &event, utime_t stamp) return; { - Mutex::Locker l(lock); + std::lock_guard l(lock); events.emplace_back(stamp, event); current = events.back().c_str(); } @@ -458,7 +458,7 @@ void TrackedOp::mark_event(const char *event, utime_t stamp) return; { - Mutex::Locker l(lock); + std::lock_guard l(lock); events.emplace_back(stamp, event); current = event; } diff --git a/src/common/TrackedOp.h b/src/common/TrackedOp.h index 054e621fcf323..f4403eec71374 100644 --- a/src/common/TrackedOp.h +++ b/src/common/TrackedOp.h @@ -342,7 +342,7 @@ public: const char *get_desc() const { if (!desc || want_new_desc.load()) { - Mutex::Locker l(lock); + std::lock_guard l(lock); _gen_desc(); } return desc; @@ -365,7 +365,7 @@ public: } double get_duration() const { - Mutex::Locker l(lock); + std::lock_guard l(lock); if (!events.empty() && events.rbegin()->compare("done") == 0) return events.rbegin()->stamp - get_initiated(); else @@ -382,7 +382,7 @@ public: } virtual const char *state_string() const { - Mutex::Locker l(lock); + std::lock_guard l(lock); return events.rbegin()->c_str(); } diff --git a/src/common/WorkQueue.cc b/src/common/WorkQueue.cc index 98453acf73e7e..6067bf53cb28c 100644 --- a/src/common/WorkQueue.cc +++ b/src/common/WorkQueue.cc @@ -263,7 +263,7 @@ void ThreadPool::drain(WorkQueue_* wq) void ThreadPool::set_ioprio(int cls, int priority) { - Mutex::Locker l(_lock); + std::lock_guard l(_lock); ioprio_class = cls; ioprio_priority = priority; for (set::iterator p = _threads.begin(); diff --git a/src/common/WorkQueue.h b/src/common/WorkQueue.h index a678f7150f418..5486e67b509e2 100644 --- a/src/common/WorkQueue.h +++ b/src/common/WorkQueue.h @@ -192,7 +192,7 @@ public: void *_void_dequeue() override { { - Mutex::Locker l(_lock); + std::lock_guard l(_lock); if (_empty()) return 0; U u = _dequeue(); @@ -235,12 +235,12 @@ public: pool->remove_work_queue(this); } void queue(T item) { - Mutex::Locker l(pool->_lock); + std::lock_guard l(pool->_lock); _enqueue(item); pool->_cond.SignalOne(); } void queue_front(T item) { - Mutex::Locker l(pool->_lock); + std::lock_guard l(pool->_lock); _enqueue_front(item); pool->_cond.SignalOne(); } @@ -354,7 +354,7 @@ public: { // if this queue is empty and not processing, don't wait for other // queues to finish processing - Mutex::Locker l(m_pool->_lock); + std::lock_guard l(m_pool->_lock); if (m_processing == 0 && m_items.empty()) { return; } @@ -362,12 +362,12 @@ public: m_pool->drain(this); } void queue(T *item) { - Mutex::Locker l(m_pool->_lock); + std::lock_guard l(m_pool->_lock); m_items.push_back(item); m_pool->_cond.SignalOne(); } bool empty() { - Mutex::Locker l(m_pool->_lock); + std::lock_guard l(m_pool->_lock); return _empty(); } protected: @@ -407,7 +407,7 @@ public: virtual void process(T *item) = 0; void process_finish() { - Mutex::Locker locker(m_pool->_lock); + std::lock_guard locker(m_pool->_lock); _void_process_finish(nullptr); } @@ -419,12 +419,12 @@ public: return m_items.front(); } void requeue(T *item) { - Mutex::Locker pool_locker(m_pool->_lock); + std::lock_guard pool_locker(m_pool->_lock); _void_process_finish(nullptr); m_items.push_front(item); } void signal() { - Mutex::Locker pool_locker(m_pool->_lock); + std::lock_guard pool_locker(m_pool->_lock); m_pool->_cond.SignalOne(); } Mutex &get_pool_lock() { @@ -465,18 +465,18 @@ public: /// return number of threads currently running int get_num_threads() { - Mutex::Locker l(_lock); + std::lock_guard l(_lock); return _num_threads; } /// assign a work queue to this thread pool void add_work_queue(WorkQueue_* wq) { - Mutex::Locker l(_lock); + std::lock_guard l(_lock); work_queues.push_back(wq); } /// remove a work queue from this thread pool void remove_work_queue(WorkQueue_* wq) { - Mutex::Locker l(_lock); + std::lock_guard l(_lock); unsigned i = 0; while (work_queues[i] != wq) i++; @@ -506,7 +506,7 @@ public: } /// wake up a waiter (without lock held) void wake() { - Mutex::Locker l(_lock); + std::lock_guard l(_lock); _cond.Signal(); } void _wait() { @@ -585,7 +585,7 @@ public: void queue(Context *ctx, int result = 0) { if (result != 0) { - Mutex::Locker locker(m_lock); + std::lock_guard locker(m_lock); m_context_results[ctx] = result; } ThreadPool::PointerWQ::queue(ctx); @@ -594,14 +594,14 @@ protected: void _clear() override { ThreadPool::PointerWQ::_clear(); - Mutex::Locker locker(m_lock); + std::lock_guard locker(m_lock); m_context_results.clear(); } void process(Context *ctx) override { int result = 0; { - Mutex::Locker locker(m_lock); + std::lock_guard locker(m_lock); ceph::unordered_map::iterator it = m_context_results.find(ctx); if (it != m_context_results.end()) { diff --git a/src/common/ceph_context.cc b/src/common/ceph_context.cc index 41d1f47bf11ae..81245039fcf0f 100644 --- a/src/common/ceph_context.cc +++ b/src/common/ceph_context.cc @@ -176,7 +176,7 @@ public: void *entry() override { while (1) { - Mutex::Locker l(_lock); + std::lock_guard l(_lock); if (_cct->_conf->heartbeat_interval) { utime_t interval(_cct->_conf->heartbeat_interval, 0); @@ -202,14 +202,14 @@ public: void reopen_logs() { - Mutex::Locker l(_lock); + std::lock_guard l(_lock); _reopen_logs = true; _cond.Signal(); } void exit_thread() { - Mutex::Locker l(_lock); + std::lock_guard l(_lock); _exit_thread = true; _cond.Signal(); } diff --git a/src/common/config_proxy.h b/src/common/config_proxy.h index e9b6b39b6263a..9c943c4ec446a 100644 --- a/src/common/config_proxy.h +++ b/src/common/config_proxy.h @@ -37,21 +37,21 @@ public: return &values; } int get_val(const std::string& key, char** buf, int len) const { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; return config.get_val(values, key, buf, len); } int get_val(const std::string &key, std::string *val) const { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; return config.get_val(values, key, val); } template const T get_val(const std::string& key) const { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; return config.template get_val(values, key); } template auto with_val(const string& key, Callback&& cb, Args&&... args) const { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; return config.template with_val(values, key, std::forward(cb), std::forward(args)...); @@ -71,21 +71,21 @@ public: return config.find_option(name); } void diff(Formatter *f, const std::string& name=string{}) const { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; return config.diff(values, f, name); } void get_my_sections(std::vector §ions) const { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; config.get_my_sections(values, sections); } int get_all_sections(std::vector& sections) const { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; return config.get_all_sections(sections); } int get_val_from_conf_file(const std::vector& sections, const std::string& key, std::string& out, bool emeta) const { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; return config.get_val_from_conf_file(values, sections, key, out, emeta); } @@ -94,27 +94,27 @@ public: } void early_expand_meta(std::string &val, std::ostream *oss) const { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; return config.early_expand_meta(values, val, oss); } // for those want to reexpand special meta, e.g, $pid void finalize_reexpand_meta() { - Mutex::Locker l(lock); + std::lock_guard l(lock); if (config.finalize_reexpand_meta(values, obs_mgr)) { obs_mgr.apply_changes(values.changed, *this, nullptr); values.changed.clear(); } } void add_observer(md_config_obs_t* obs) { - Mutex::Locker l(lock); + std::lock_guard l(lock); obs_mgr.add_observer(obs); } void remove_observer(md_config_obs_t* obs) { - Mutex::Locker l(lock); + std::lock_guard l(lock); obs_mgr.remove_observer(obs); } void call_all_observers() { - Mutex::Locker l(lock); + std::lock_guard l(lock); // Have the scope of the lock extend to the scope of // handle_conf_change since that function expects to be called with // the lock held. (And the comment in config.h says that is the @@ -132,24 +132,24 @@ public: config._clear_safe_to_start_threads(); } void show_config(std::ostream& out) { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; config.show_config(values, out); } void show_config(Formatter *f) { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; config.show_config(values, f); } void config_options(Formatter *f) { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; config.config_options(f); } int rm_val(const std::string& key) { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; return config.rm_val(values, key); } // Expand all metavariables. Make any pending observer callbacks. void apply_changes(std::ostream* oss) { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; // apply changes until the cluster name is assigned if (!values.cluster.empty()) { // meta expands could have modified anything. Copy it all out again. @@ -159,44 +159,44 @@ public: } int set_val(const std::string& key, const std::string& s, std::stringstream* err_ss=nullptr) { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; return config.set_val(values, obs_mgr, key, s); } void set_val_default(const std::string& key, const std::string& val) { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; config.set_val_default(values, obs_mgr, key, val); } void set_val_or_die(const std::string& key, const std::string& val) { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; config.set_val_or_die(values, obs_mgr, key, val); } int set_mon_vals(CephContext *cct, const map& kv, md_config_t::config_callback config_cb) { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; int ret = config.set_mon_vals(cct, values, obs_mgr, kv, config_cb); obs_mgr.apply_changes(values.changed, *this, nullptr); values.changed.clear(); return ret; } int injectargs(const std::string &s, std::ostream *oss) { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; int ret = config.injectargs(values, obs_mgr, s, oss); obs_mgr.apply_changes(values.changed, *this, oss); values.changed.clear(); return ret; } void parse_env(const char *env_var = "CEPH_ARGS") { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; config.parse_env(values, obs_mgr, env_var); } int parse_argv(std::vector& args, int level=CONF_CMDLINE) { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; return config.parse_argv(values, obs_mgr, args, level); } int parse_config_files(const char *conf_files, std::ostream *warnings, int flags) { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; return config.parse_config_files(values, obs_mgr, conf_files, warnings, flags); } @@ -207,17 +207,17 @@ public: return config.complain_about_parse_errors(cct); } void do_argv_commands() const { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; config.do_argv_commands(values); } void get_config_bl(uint64_t have_version, bufferlist *bl, uint64_t *got_version) { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; config.get_config_bl(values, have_version, bl, got_version); } void get_defaults_bl(bufferlist *bl) { - Mutex::Locker l{lock}; + std::lock_guard l{lock}; config.get_defaults_bl(values, bl); } }; diff --git a/src/common/dns_resolve.cc b/src/common/dns_resolve.cc index f73529ed3bccb..05521d73a559b 100644 --- a/src/common/dns_resolve.cc +++ b/src/common/dns_resolve.cc @@ -86,7 +86,7 @@ int DNSResolver::get_state(CephContext *cct, res_state *ps) void DNSResolver::put_state(res_state s) { - Mutex::Locker l(lock); + std::lock_guard l(lock); states.push_back(s); } #endif @@ -122,7 +122,7 @@ int DNSResolver::resolve_cname(CephContext *cct, const string& hostname, #else { # ifndef HAVE_THREAD_SAFE_RES_QUERY - Mutex::Locker l(lock); + std::lock_guard l(lock); # endif len = resolv_h->res_query(origname, ns_c_in, ns_t_cname, buf, sizeof(buf)); } @@ -219,7 +219,7 @@ int DNSResolver::resolve_ip_addr(CephContext *cct, res_state *res, const string& #else { # ifndef HAVE_THREAD_SAFE_RES_QUERY - Mutex::Locker l(lock); + std::lock_guard l(lock); # endif len = resolv_h->res_query(hostname.c_str(), ns_c_in, type, nsbuf, sizeof(nsbuf)); } @@ -295,7 +295,7 @@ int DNSResolver::resolve_srv_hosts(CephContext *cct, const string& service_name, #else { # ifndef HAVE_THREAD_SAFE_RES_QUERY - Mutex::Locker l(lock); + std::lock_guard l(lock); # endif len = resolv_h->res_search(query_str.c_str(), ns_c_in, ns_t_srv, nsbuf, sizeof(nsbuf)); diff --git a/src/common/lru_map.h b/src/common/lru_map.h index 7dac49b4587d1..3b0bb543f06dc 100644 --- a/src/common/lru_map.h +++ b/src/common/lru_map.h @@ -74,14 +74,14 @@ bool lru_map::_find(const K& key, V *value, UpdateContext *ctx) template bool lru_map::find(const K& key, V& value) { - Mutex::Locker l(lock); + std::lock_guard l(lock); return _find(key, &value, NULL); } template bool lru_map::find_and_update(const K& key, V *value, UpdateContext *ctx) { - Mutex::Locker l(lock); + std::lock_guard l(lock); return _find(key, value, ctx); } @@ -112,14 +112,14 @@ void lru_map::_add(const K& key, V& value) template void lru_map::add(const K& key, V& value) { - Mutex::Locker l(lock); + std::lock_guard l(lock); _add(key, value); } template void lru_map::erase(const K& key) { - Mutex::Locker l(lock); + std::lock_guard l(lock); typename std::map::iterator iter = entries.find(key); if (iter == entries.end()) return; diff --git a/src/common/perf_counters.cc b/src/common/perf_counters.cc index 5fb9fa098cd1a..dc7050fe4b93e 100644 --- a/src/common/perf_counters.cc +++ b/src/common/perf_counters.cc @@ -32,7 +32,7 @@ PerfCountersCollection::~PerfCountersCollection() void PerfCountersCollection::add(class PerfCounters *l) { - Mutex::Locker lck(m_lock); + std::lock_guard lck(m_lock); // make sure the name is unique perf_counters_set_t::iterator i; @@ -59,7 +59,7 @@ void PerfCountersCollection::add(class PerfCounters *l) void PerfCountersCollection::remove(class PerfCounters *l) { - Mutex::Locker lck(m_lock); + std::lock_guard lck(m_lock); for (unsigned int i = 0; i < l->m_data.size(); ++i) { PerfCounters::perf_counter_data_any_d &data = l->m_data[i]; @@ -78,7 +78,7 @@ void PerfCountersCollection::remove(class PerfCounters *l) void PerfCountersCollection::clear() { - Mutex::Locker lck(m_lock); + std::lock_guard lck(m_lock); perf_counters_set_t::iterator i = m_loggers.begin(); perf_counters_set_t::iterator i_end = m_loggers.end(); for (; i != i_end; ) { @@ -91,7 +91,7 @@ void PerfCountersCollection::clear() bool PerfCountersCollection::reset(const std::string &name) { bool result = false; - Mutex::Locker lck(m_lock); + std::lock_guard lck(m_lock); perf_counters_set_t::iterator i = m_loggers.begin(); perf_counters_set_t::iterator i_end = m_loggers.end(); @@ -135,7 +135,7 @@ void PerfCountersCollection::dump_formatted_generic( const std::string &logger, const std::string &counter) { - Mutex::Locker lck(m_lock); + std::lock_guard lck(m_lock); f->open_object_section("perfcounter_collection"); for (perf_counters_set_t::iterator l = m_loggers.begin(); @@ -151,7 +151,7 @@ void PerfCountersCollection::dump_formatted_generic( void PerfCountersCollection::with_counters(std::function fn) const { - Mutex::Locker lck(m_lock); + std::lock_guard lck(m_lock); fn(by_path); } -- 2.39.5