From 84358a04b5f05e13d3c247c4279f3300fd6fa490 Mon Sep 17 00:00:00 2001 From: Sage Weil Date: Tue, 16 Oct 2018 13:43:33 -0500 Subject: [PATCH] osd: Mutex::Locker -> std::lock_guard Signed-off-by: Sage Weil --- src/osd/ClassHandler.cc | 4 +- src/osd/ClassHandler.h | 6 +- src/osd/OSD.cc | 182 +++++++++++++++++++-------------------- src/osd/OSD.h | 98 ++++++++++----------- src/osd/OSDMapMapping.cc | 2 +- src/osd/OSDMapMapping.h | 10 +-- src/osd/OpRequest.cc | 2 +- src/osd/PG.cc | 32 +++---- src/osd/PG.h | 10 +-- src/osd/PrimaryLogPG.cc | 4 +- src/osd/PrimaryLogPG.h | 6 +- src/osd/Session.cc | 6 +- src/osd/Session.h | 6 +- src/osd/Watch.cc | 20 ++--- 14 files changed, 194 insertions(+), 194 deletions(-) diff --git a/src/osd/ClassHandler.cc b/src/osd/ClassHandler.cc index 51a8fdb510f..1b7f66865b9 100644 --- a/src/osd/ClassHandler.cc +++ b/src/osd/ClassHandler.cc @@ -36,7 +36,7 @@ void ClassHandler::add_embedded_class(const string& cname) int ClassHandler::open_class(const string& cname, ClassData **pcls) { - Mutex::Locker lock(mutex); + std::lock_guard lock(mutex); ClassData *cls = _get_class(cname, true); if (!cls) return -EPERM; @@ -283,7 +283,7 @@ ClassHandler::ClassMethod *ClassHandler::ClassData::_get_method(const char *mnam int ClassHandler::ClassData::get_method_flags(const char *mname) { - Mutex::Locker l(handler->mutex); + std::lock_guard l(handler->mutex); ClassMethod *method = _get_method(mname); if (!method) return -ENOENT; diff --git a/src/osd/ClassHandler.h b/src/osd/ClassHandler.h index 64393a7eb97..58a14225eee 100644 --- a/src/osd/ClassHandler.h +++ b/src/osd/ClassHandler.h @@ -28,7 +28,7 @@ public: void unregister(); int get_flags() { - Mutex::Locker l(cls->handler->mutex); + std::lock_guard l(cls->handler->mutex); return flags; } @@ -84,14 +84,14 @@ public: void unregister_filter(ClassFilter *method); ClassMethod *get_method(const char *mname) { - Mutex::Locker l(handler->mutex); + std::lock_guard l(handler->mutex); return _get_method(mname); } int get_method_flags(const char *mname); ClassFilter *get_filter(const std::string &filter_name) { - Mutex::Locker l(handler->mutex); + std::lock_guard l(handler->mutex); std::map::iterator i = filters_map.find(filter_name); if (i == filters_map.end()) { return NULL; diff --git a/src/osd/OSD.cc b/src/osd/OSD.cc index a711a5b23bc..737545dd18f 100644 --- a/src/osd/OSD.cc +++ b/src/osd/OSD.cc @@ -300,7 +300,7 @@ OSDService::~OSDService() #ifdef PG_DEBUG_REFS void OSDService::add_pgid(spg_t pgid, PG *pg){ - Mutex::Locker l(pgid_lock); + std::lock_guard l(pgid_lock); if (!pgid_tracker.count(pgid)) { live_pgs[pgid] = pg; } @@ -308,7 +308,7 @@ void OSDService::add_pgid(spg_t pgid, PG *pg){ } void OSDService::remove_pgid(spg_t pgid, PG *pg) { - Mutex::Locker l(pgid_lock); + std::lock_guard l(pgid_lock); ceph_assert(pgid_tracker.count(pgid)); ceph_assert(pgid_tracker[pgid] > 0); pgid_tracker[pgid]--; @@ -319,7 +319,7 @@ void OSDService::remove_pgid(spg_t pgid, PG *pg) } void OSDService::dump_live_pgids() { - Mutex::Locker l(pgid_lock); + std::lock_guard l(pgid_lock); derr << "live pgids:" << dendl; for (map::const_iterator i = pgid_tracker.cbegin(); i != pgid_tracker.cend(); @@ -436,12 +436,12 @@ void OSDService::need_heartbeat_peer_update() void OSDService::start_shutdown() { { - Mutex::Locker l(agent_timer_lock); + std::lock_guard l(agent_timer_lock); agent_timer.shutdown(); } { - Mutex::Locker l(sleep_lock); + std::lock_guard l(sleep_lock); sleep_timer.shutdown(); } } @@ -455,7 +455,7 @@ void OSDService::shutdown_reserver() void OSDService::shutdown() { { - Mutex::Locker l(watch_lock); + std::lock_guard l(watch_lock); watch_timer.shutdown(); } @@ -466,7 +466,7 @@ void OSDService::shutdown() } { - Mutex::Locker l(recovery_request_lock); + std::lock_guard l(recovery_request_lock); recovery_request_timer.shutdown(); } @@ -585,7 +585,7 @@ void OSDService::agent_entry() void OSDService::agent_stop() { { - Mutex::Locker l(agent_lock); + std::lock_guard l(agent_lock); // By this time all ops should be cancelled ceph_assert(agent_ops == 0); @@ -686,7 +686,7 @@ float OSDService::get_failsafe_full_ratio() void OSDService::check_full_status(float ratio) { - Mutex::Locker l(full_status_lock); + std::lock_guard l(full_status_lock); cur_ratio = ratio; @@ -786,7 +786,7 @@ bool OSDService::need_fullness_update() bool OSDService::_check_full(DoutPrefixProvider *dpp, s_names type) const { - Mutex::Locker l(full_status_lock); + std::lock_guard l(full_status_lock); if (injectfull && injectfull_state >= type) { // injectfull is either a count of the number of times to return failsafe full @@ -826,31 +826,31 @@ bool OSDService::check_nearfull(DoutPrefixProvider *dpp) const bool OSDService::is_failsafe_full() const { - Mutex::Locker l(full_status_lock); + std::lock_guard l(full_status_lock); return cur_state == FAILSAFE; } bool OSDService::is_full() const { - Mutex::Locker l(full_status_lock); + std::lock_guard l(full_status_lock); return cur_state >= FULL; } bool OSDService::is_backfillfull() const { - Mutex::Locker l(full_status_lock); + std::lock_guard l(full_status_lock); return cur_state >= BACKFILLFULL; } bool OSDService::is_nearfull() const { - Mutex::Locker l(full_status_lock); + std::lock_guard l(full_status_lock); return cur_state >= NEARFULL; } void OSDService::set_injectfull(s_names type, int64_t count) { - Mutex::Locker l(full_status_lock); + std::lock_guard l(full_status_lock); injectfull_state = type; injectfull = count; } @@ -865,7 +865,7 @@ void OSDService::set_statfs(const struct store_statfs_t &stbuf) osd->logger->set(l_osd_stat_bytes_used, used); osd->logger->set(l_osd_stat_bytes_avail, avail); - Mutex::Locker l(stat_lock); + std::lock_guard l(stat_lock); osd_stat.kb = bytes >> 10; osd_stat.kb_used = used >> 10; osd_stat.kb_avail = avail >> 10; @@ -877,7 +877,7 @@ void OSDService::set_statfs(const struct store_statfs_t &stbuf) osd_stat_t OSDService::set_osd_stat(vector& hb_peers, int num_pgs) { - Mutex::Locker l(stat_lock); + std::lock_guard l(stat_lock); osd_stat.hb_peers.swap(hb_peers); osd->op_tracker.get_age_ms_histogram(&osd_stat.op_queue_age_hist); osd_stat.num_pgs = num_pgs; @@ -959,7 +959,7 @@ void OSDService::queue_want_pg_temp(pg_t pgid, const vector& want, bool forced) { - Mutex::Locker l(pg_temp_lock); + std::lock_guard l(pg_temp_lock); auto p = pg_temp_pending.find(pgid); if (p == pg_temp_pending.end() || p->second.acting != want || @@ -970,7 +970,7 @@ void OSDService::queue_want_pg_temp(pg_t pgid, void OSDService::remove_want_pg_temp(pg_t pgid) { - Mutex::Locker l(pg_temp_lock); + std::lock_guard l(pg_temp_lock); pg_temp_wanted.erase(pgid); pg_temp_pending.erase(pgid); } @@ -988,7 +988,7 @@ void OSDService::_sent_pg_temp() void OSDService::requeue_pg_temp() { - Mutex::Locker l(pg_temp_lock); + std::lock_guard l(pg_temp_lock); // wanted overrides pending. note that remove_want_pg_temp // clears the item out of both. unsigned old_wanted = pg_temp_wanted.size(); @@ -1011,7 +1011,7 @@ std::ostream& operator<<(std::ostream& out, void OSDService::send_pg_temp() { - Mutex::Locker l(pg_temp_lock); + std::lock_guard l(pg_temp_lock); if (pg_temp_wanted.empty()) return; dout(10) << "send_pg_temp " << pg_temp_wanted << dendl; @@ -1045,7 +1045,7 @@ void OSDService::send_pg_created(pg_t pgid) epoch_t OSDService::get_peer_epoch(int peer) { - Mutex::Locker l(peer_map_epoch_lock); + std::lock_guard l(peer_map_epoch_lock); map::iterator p = peer_map_epoch.find(peer); if (p == peer_map_epoch.end()) return 0; @@ -1054,7 +1054,7 @@ epoch_t OSDService::get_peer_epoch(int peer) epoch_t OSDService::note_peer_epoch(int peer, epoch_t e) { - Mutex::Locker l(peer_map_epoch_lock); + std::lock_guard l(peer_map_epoch_lock); map::iterator p = peer_map_epoch.find(peer); if (p != peer_map_epoch.end()) { if (p->second < e) { @@ -1073,7 +1073,7 @@ epoch_t OSDService::note_peer_epoch(int peer, epoch_t e) void OSDService::forget_peer_epoch(int peer, epoch_t as_of) { - Mutex::Locker l(peer_map_epoch_lock); + std::lock_guard l(peer_map_epoch_lock); map::iterator p = peer_map_epoch.find(peer); if (p != peer_map_epoch.end()) { if (p->second <= as_of) { @@ -1193,7 +1193,7 @@ void OSDService::share_map_peer(int peer, Connection *con, OSDMapRef map) bool OSDService::can_inc_scrubs_pending() { bool can_inc = false; - Mutex::Locker l(sched_scrub_lock); + std::lock_guard l(sched_scrub_lock); if (scrubs_pending + scrubs_active < cct->_conf->osd_max_scrubs) { dout(20) << __func__ << " " << scrubs_pending << " -> " << (scrubs_pending+1) @@ -1267,7 +1267,7 @@ void OSDService::dec_scrubs_active() void OSDService::retrieve_epochs(epoch_t *_boot_epoch, epoch_t *_up_epoch, epoch_t *_bind_epoch) const { - Mutex::Locker l(epoch_lock); + std::lock_guard l(epoch_lock); if (_boot_epoch) *_boot_epoch = boot_epoch; if (_up_epoch) @@ -1279,7 +1279,7 @@ void OSDService::retrieve_epochs(epoch_t *_boot_epoch, epoch_t *_up_epoch, void OSDService::set_epochs(const epoch_t *_boot_epoch, const epoch_t *_up_epoch, const epoch_t *_bind_epoch) { - Mutex::Locker l(epoch_lock); + std::lock_guard l(epoch_lock); if (_boot_epoch) { ceph_assert(*_boot_epoch == 0 || *_boot_epoch >= boot_epoch); boot_epoch = *_boot_epoch; @@ -1296,7 +1296,7 @@ void OSDService::set_epochs(const epoch_t *_boot_epoch, const epoch_t *_up_epoch bool OSDService::prepare_to_stop() { - Mutex::Locker l(is_stopping_lock); + std::lock_guard l(is_stopping_lock); if (get_state() != NOT_STOPPING) return false; @@ -1327,7 +1327,7 @@ bool OSDService::prepare_to_stop() void OSDService::got_stop_ack() { - Mutex::Locker l(is_stopping_lock); + std::lock_guard l(is_stopping_lock); if (get_state() == PREPARING_TO_STOP) { dout(0) << __func__ << " starting shutdown" << dendl; set_state(STOPPING); @@ -1424,7 +1424,7 @@ bool OSDService::_get_map_bl(epoch_t e, bufferlist& bl) bool OSDService::get_inc_map_bl(epoch_t e, bufferlist& bl) { - Mutex::Locker l(map_cache_lock); + std::lock_guard l(map_cache_lock); bool found = map_bl_inc_cache.lookup(e, &bl); if (found) { if (logger) @@ -1466,7 +1466,7 @@ void OSDService::_add_map_inc_bl(epoch_t e, bufferlist& bl) int OSDService::get_deleted_pool_pg_num(int64_t pool) { - Mutex::Locker l(map_cache_lock); + std::lock_guard l(map_cache_lock); auto p = deleted_pool_pg_nums.find(pool); if (p != deleted_pool_pg_nums.end()) { return p->second; @@ -1505,7 +1505,7 @@ OSDMapRef OSDService::_add_map(OSDMap *o) OSDMapRef OSDService::try_get_map(epoch_t epoch) { - Mutex::Locker l(map_cache_lock); + std::lock_guard l(map_cache_lock); OSDMapRef retval = map_cache.lookup(epoch); if (retval) { dout(30) << "get_map " << epoch << " -cached" << dendl; @@ -1696,7 +1696,7 @@ bool OSDService::try_finish_pg_delete(PG *pg, unsigned old_pg_num) void OSDService::set_ready_to_merge_source(PG *pg) { - Mutex::Locker l(merge_lock); + std::lock_guard l(merge_lock); dout(10) << __func__ << " " << pg->pg_id << dendl; ready_to_merge_source.insert(pg->pg_id.pgid); assert(not_ready_to_merge_source.count(pg->pg_id.pgid) == 0); @@ -1705,7 +1705,7 @@ void OSDService::set_ready_to_merge_source(PG *pg) void OSDService::set_ready_to_merge_target(PG *pg, epoch_t last_epoch_clean) { - Mutex::Locker l(merge_lock); + std::lock_guard l(merge_lock); dout(10) << __func__ << " " << pg->pg_id << dendl; ready_to_merge_target.insert(make_pair(pg->pg_id.pgid, last_epoch_clean)); assert(not_ready_to_merge_target.count(pg->pg_id.pgid) == 0); @@ -1714,7 +1714,7 @@ void OSDService::set_ready_to_merge_target(PG *pg, epoch_t last_epoch_clean) void OSDService::set_not_ready_to_merge_source(pg_t source) { - Mutex::Locker l(merge_lock); + std::lock_guard l(merge_lock); dout(10) << __func__ << " " << source << dendl; not_ready_to_merge_source.insert(source); assert(ready_to_merge_source.count(source) == 0); @@ -1723,7 +1723,7 @@ void OSDService::set_not_ready_to_merge_source(pg_t source) void OSDService::set_not_ready_to_merge_target(pg_t target, pg_t source) { - Mutex::Locker l(merge_lock); + std::lock_guard l(merge_lock); dout(10) << __func__ << " " << target << " source " << source << dendl; not_ready_to_merge_target[target] = source; assert(ready_to_merge_target.count(target) == 0); @@ -1732,7 +1732,7 @@ void OSDService::set_not_ready_to_merge_target(pg_t target, pg_t source) void OSDService::send_ready_to_merge() { - Mutex::Locker l(merge_lock); + std::lock_guard l(merge_lock); _send_ready_to_merge(); } @@ -1785,7 +1785,7 @@ void OSDService::_send_ready_to_merge() void OSDService::clear_ready_to_merge(PG *pg) { - Mutex::Locker l(merge_lock); + std::lock_guard l(merge_lock); dout(10) << __func__ << " " << pg->pg_id << dendl; ready_to_merge_source.erase(pg->pg_id.pgid); ready_to_merge_target.erase(pg->pg_id.pgid); @@ -1796,13 +1796,13 @@ void OSDService::clear_ready_to_merge(PG *pg) void OSDService::clear_sent_ready_to_merge() { - Mutex::Locker l(merge_lock); + std::lock_guard l(merge_lock); sent_ready_to_merge_source.clear(); } void OSDService::prune_sent_ready_to_merge(OSDMapRef& osdmap) { - Mutex::Locker l(merge_lock); + std::lock_guard l(merge_lock); auto i = sent_ready_to_merge_source.begin(); while (i != sent_ready_to_merge_source.end()) { if (!osdmap->pg_exists(*i)) { @@ -2167,7 +2167,7 @@ void OSD::handle_signal(int signum) int OSD::pre_init() { - Mutex::Locker lock(osd_lock); + std::lock_guard lock(osd_lock); if (is_stopping()) return 0; @@ -2565,7 +2565,7 @@ float OSD::get_osd_recovery_sleep() int OSD::init() { CompatSet initial, diff; - Mutex::Locker lock(osd_lock); + std::lock_guard lock(osd_lock); if (is_stopping()) return 0; @@ -2746,7 +2746,7 @@ int OSD::init() // initialize osdmap references in sharded wq for (auto& shard : shards) { - Mutex::Locker l(shard->osdmap_lock); + std::lock_guard l(shard->osdmap_lock); shard->shard_osdmap = osdmap; } @@ -2839,7 +2839,7 @@ int OSD::init() tick_timer.add_event_after(get_tick_interval(), new C_Tick(this)); { - Mutex::Locker l(tick_timer_lock); + std::lock_guard l(tick_timer_lock); tick_timer_without_osd_lock.add_event_after(get_tick_interval(), new C_Tick_WithoutOSDLock(this)); } @@ -3561,7 +3561,7 @@ int OSD::shutdown() tick_timer.shutdown(); { - Mutex::Locker l(tick_timer_lock); + std::lock_guard l(tick_timer_lock); tick_timer_without_osd_lock.shutdown(); } @@ -3635,7 +3635,7 @@ int OSD::shutdown() osdmap = OSDMapRef(); for (auto s : shards) { - Mutex::Locker l(s->osdmap_lock); + std::lock_guard l(s->osdmap_lock); s->shard_osdmap = OSDMapRef(); } service.shutdown(); @@ -3947,7 +3947,7 @@ void OSD::_get_pgs(vector *v, bool clear_too) { v->clear(); for (auto& s : shards) { - Mutex::Locker l(s->shard_lock); + std::lock_guard l(s->shard_lock); for (auto& j : s->pg_slots) { if (j.second->pg && !j.second->pg->is_deleted()) { @@ -3964,7 +3964,7 @@ void OSD::_get_pgids(vector *v) { v->clear(); for (auto& s : shards) { - Mutex::Locker l(s->shard_lock); + std::lock_guard l(s->shard_lock); for (auto& j : s->pg_slots) { if (j.second->pg && !j.second->pg->is_deleted()) { @@ -3979,7 +3979,7 @@ void OSD::register_pg(PGRef pg) spg_t pgid = pg->get_pgid(); uint32_t shard_index = pgid.hash_to_shard(num_shards); auto sdata = shards[shard_index]; - Mutex::Locker l(sdata->shard_lock); + std::lock_guard l(sdata->shard_lock); auto r = sdata->pg_slots.emplace(pgid, make_unique()); ceph_assert(r.second); auto *slot = r.first->second.get(); @@ -3992,7 +3992,7 @@ bool OSD::try_finish_pg_delete(PG *pg, unsigned old_pg_num) auto sdata = pg->osd_shard; ceph_assert(sdata); { - Mutex::Locker l(sdata->shard_lock); + std::lock_guard l(sdata->shard_lock); auto p = sdata->pg_slots.find(pg->pg_id); if (p == sdata->pg_slots.end() || !p->second->pg) { @@ -4026,7 +4026,7 @@ PGRef OSD::_lookup_pg(spg_t pgid) { uint32_t shard_index = pgid.hash_to_shard(num_shards); auto sdata = shards[shard_index]; - Mutex::Locker l(sdata->shard_lock); + std::lock_guard l(sdata->shard_lock); auto p = sdata->pg_slots.find(pgid); if (p == sdata->pg_slots.end()) { return nullptr; @@ -4524,7 +4524,7 @@ void OSD::maybe_update_heartbeat_peers() return; heartbeat_clear_peers_need_update(); - Mutex::Locker l(heartbeat_lock); + std::lock_guard l(heartbeat_lock); dout(10) << "maybe_update_heartbeat_peers updating" << dendl; @@ -4609,7 +4609,7 @@ void OSD::reset_heartbeat_peers() { ceph_assert(osd_lock.is_locked()); dout(10) << "reset_heartbeat_peers" << dendl; - Mutex::Locker l(heartbeat_lock); + std::lock_guard l(heartbeat_lock); while (!heartbeat_peers.empty()) { HeartbeatInfo& hi = heartbeat_peers.begin()->second; hi.con_back->mark_down(); @@ -4805,7 +4805,7 @@ void OSD::handle_osd_ping(MOSDPing *m) void OSD::heartbeat_entry() { - Mutex::Locker l(heartbeat_lock); + std::lock_guard l(heartbeat_lock); if (is_stopping()) return; while (!heartbeat_stop) { @@ -5012,7 +5012,7 @@ void OSD::tick() start_boot(); if (is_waiting_for_healthy()) { // failed to boot - Mutex::Locker l(heartbeat_lock); + std::lock_guard l(heartbeat_lock); utime_t now = ceph_clock_now(); if (now - last_mon_heartbeat > cct->_conf->osd_mon_heartbeat_interval) { last_mon_heartbeat = now; @@ -5053,7 +5053,7 @@ void OSD::tick_without_osd_lock() heartbeat_lock.Unlock(); map_lock.get_read(); - Mutex::Locker l(mon_report_lock); + std::lock_guard l(mon_report_lock); // mon report? utime_t now = ceph_clock_now(); @@ -5087,7 +5087,7 @@ void OSD::tick_without_osd_lock() const auto now = ceph::coarse_mono_clock::now(); { // borrow lec lock to pretect last_sent_beacon from changing - Mutex::Locker l{min_last_epoch_clean_lock}; + std::lock_guard l{min_last_epoch_clean_lock}; const auto elapsed = now - last_sent_beacon; if (chrono::duration_cast(elapsed).count() > cct->_conf->osd_beacon_report_interval) { @@ -5333,7 +5333,7 @@ void OSD::ms_handle_connect(Connection *con) { dout(10) << __func__ << " con " << con << dendl; if (con->get_peer_type() == CEPH_ENTITY_TYPE_MON) { - Mutex::Locker l(osd_lock); + std::lock_guard l(osd_lock); if (is_stopping()) return; dout(10) << __func__ << " on mon" << dendl; @@ -5344,7 +5344,7 @@ void OSD::ms_handle_connect(Connection *con) _send_boot(); // resend boot message } else { map_lock.get_read(); - Mutex::Locker l2(mon_report_lock); + std::lock_guard l2(mon_report_lock); utime_t now = ceph_clock_now(); last_mon_report = now; @@ -5490,7 +5490,7 @@ void OSD::start_boot() void OSD::_got_mon_epochs(epoch_t oldest, epoch_t newest) { - Mutex::Locker l(osd_lock); + std::lock_guard l(osd_lock); if (is_preboot()) { _preboot(oldest, newest); } @@ -5535,7 +5535,7 @@ void OSD::_preboot(epoch_t oldest, epoch_t newest) boot_finisher.queue( new FunctionContext( [this](int r) { - Mutex::Locker l(osd_lock); + std::lock_guard l(osd_lock); if (is_preboot()) { dout(10) << __func__ << " waiting for peering work to drain" << dendl; @@ -5595,7 +5595,7 @@ bool OSD::_is_healthy() } if (is_waiting_for_healthy()) { - Mutex::Locker l(heartbeat_lock); + std::lock_guard l(heartbeat_lock); utime_t now = ceph_clock_now(); int num = 0, up = 0; for (map::iterator p = heartbeat_peers.begin(); @@ -5726,7 +5726,7 @@ void OSD::queue_want_up_thru(epoch_t want) { map_lock.get_read(); epoch_t cur = osdmap->get_up_thru(whoami); - Mutex::Locker l(mon_report_lock); + std::lock_guard l(mon_report_lock); if (want > up_thru_wanted) { dout(10) << "queue_want_up_thru now " << want << " (was " << up_thru_wanted << ")" << ", currently " << cur @@ -5810,7 +5810,7 @@ void OSD::got_full_map(epoch_t e) void OSD::requeue_failures() { - Mutex::Locker l(heartbeat_lock); + std::lock_guard l(heartbeat_lock); unsigned old_queue = failure_queue.size(); unsigned old_pending = failure_pending.size(); for (auto p = failure_pending.begin(); p != failure_pending.end(); ) { @@ -5825,7 +5825,7 @@ void OSD::send_failures() { ceph_assert(map_lock.is_locked()); ceph_assert(mon_report_lock.is_locked()); - Mutex::Locker l(heartbeat_lock); + std::lock_guard l(heartbeat_lock); utime_t now = ceph_clock_now(); while (!failure_queue.empty()) { int osd = failure_queue.begin()->first; @@ -5863,7 +5863,7 @@ void OSD::send_beacon(const ceph::coarse_mono_clock::time_point& now) dout(20) << __func__ << " sending" << dendl; MOSDBeacon* beacon = nullptr; { - Mutex::Locker l{min_last_epoch_clean_lock}; + std::lock_guard l{min_last_epoch_clean_lock}; beacon = new MOSDBeacon(osdmap->get_epoch(), min_last_epoch_clean); std::swap(beacon->pgs, min_last_epoch_clean_pgs); last_sent_beacon = now; @@ -6829,7 +6829,7 @@ void OSD::ms_fast_dispatch(Message *m) // them to an spg_t while preserving delivery order. auto priv = m->get_connection()->get_priv(); if (auto session = static_cast(priv.get()); session) { - Mutex::Locker l{session->session_dispatch_lock}; + std::lock_guard l{session->session_dispatch_lock}; op->get(); session->waiting_on_map.push_back(*op); OSDMapRef nextmap = service.get_nextmap_reserved(); @@ -7266,7 +7266,7 @@ MPGStats* OSD::collect_pg_stats() auto m = new MPGStats(monc->get_fsid(), osdmap->get_epoch(), had_for); m->osd_stat = cur_stat; - Mutex::Locker lec{min_last_epoch_clean_lock}; + std::lock_guard lec{min_last_epoch_clean_lock}; min_last_epoch_clean = osdmap->get_epoch(); min_last_epoch_clean_pgs.clear(); vector pgs; @@ -7391,7 +7391,7 @@ struct C_OnMapCommit : public Context { void OSD::osdmap_subscribe(version_t epoch, bool force_request) { - Mutex::Locker l(osdmap_subscribe_lock); + std::lock_guard l(osdmap_subscribe_lock); if (latest_subscribed_epoch >= epoch && !force_request) return; @@ -7754,7 +7754,7 @@ void OSD::_committed_osd_maps(epoch_t first, epoch_t last, MOSDMap *m) dout(10) << __func__ << " bailing, we are shutting down" << dendl; return; } - Mutex::Locker l(osd_lock); + std::lock_guard l(osd_lock); if (is_stopping()) { dout(10) << __func__ << " bailing, we are shutting down" << dendl; return; @@ -7987,7 +7987,7 @@ void OSD::_committed_osd_maps(epoch_t first, epoch_t last, MOSDMap *m) if (do_shutdown) { if (network_error) { - Mutex::Locker l(heartbeat_lock); + std::lock_guard l(heartbeat_lock); auto it = failure_pending.begin(); while (it != failure_pending.end()) { dout(10) << "handle_osd_ping canceling in-flight failure report for osd." @@ -8116,7 +8116,7 @@ void OSD::_finish_splits(set& pgs) bool OSD::add_merge_waiter(OSDMapRef nextmap, spg_t target, PGRef src, unsigned need) { - Mutex::Locker l(merge_lock); + std::lock_guard l(merge_lock); auto& p = merge_waiters[nextmap->get_epoch()][target]; p[src->pg_id] = src; dout(10) << __func__ << " added merge_waiter " << src->pg_id @@ -8173,7 +8173,7 @@ bool OSD::advance_pg( pg->on_shutdown(); OSDShard *sdata = pg->osd_shard; { - Mutex::Locker l(sdata->shard_lock); + std::lock_guard l(sdata->shard_lock); if (pg->pg_slot) { sdata->_detach_pg(pg->pg_slot); // update pg count now since we might not get an osdmap @@ -8210,7 +8210,7 @@ bool OSD::advance_pg( << dendl; map sources; { - Mutex::Locker l(merge_lock); + std::lock_guard l(merge_lock); auto& s = merge_waiters[nextmap->get_epoch()][pg->pg_id]; unsigned need = children.size(); dout(20) << __func__ << " have " << s.size() << "/" @@ -9161,14 +9161,14 @@ void OSD::do_recovery( */ float recovery_sleep = get_osd_recovery_sleep(); { - Mutex::Locker l(service.sleep_lock); + std::lock_guard l(service.sleep_lock); if (recovery_sleep > 0 && service.recovery_needs_sleep) { PGRef pgref(pg); auto recovery_requeue_callback = new FunctionContext([this, pgref, queued, reserved_pushes](int r) { dout(20) << "do_recovery wake up at " << ceph_clock_now() << ", re-queuing recovery" << dendl; - Mutex::Locker l(service.sleep_lock); + std::lock_guard l(service.sleep_lock); service.recovery_needs_sleep = false; service.queue_recovery_after_sleep(pgref.get(), queued, reserved_pushes); }); @@ -9190,7 +9190,7 @@ void OSD::do_recovery( { { - Mutex::Locker l(service.sleep_lock); + std::lock_guard l(service.sleep_lock); service.recovery_needs_sleep = true; } @@ -9222,7 +9222,7 @@ void OSD::do_recovery( void OSDService::start_recovery_op(PG *pg, const hobject_t& soid) { - Mutex::Locker l(recovery_lock); + std::lock_guard l(recovery_lock); dout(10) << "start_recovery_op " << *pg << " " << soid << " (" << recovery_ops_active << "/" << cct->_conf->osd_recovery_max_active << " rops)" @@ -9238,7 +9238,7 @@ void OSDService::start_recovery_op(PG *pg, const hobject_t& soid) void OSDService::finish_recovery_op(PG *pg, const hobject_t& soid, bool dequeue) { - Mutex::Locker l(recovery_lock); + std::lock_guard l(recovery_lock); dout(10) << "finish_recovery_op " << *pg << " " << soid << " dequeue=" << dequeue << " (" << recovery_ops_active << "/" << cct->_conf->osd_recovery_max_active << " rops)" @@ -9264,7 +9264,7 @@ bool OSDService::is_recovery_active() void OSDService::release_reserved_pushes(uint64_t pushes) { - Mutex::Locker l(recovery_lock); + std::lock_guard l(recovery_lock); dout(10) << __func__ << "(" << pushes << "), recovery_ops_reserved " << recovery_ops_reserved << " -> " << (recovery_ops_reserved-pushes) << dendl; @@ -9831,7 +9831,7 @@ void OSDShard::_detach_pg(OSDShardPGSlot *slot) void OSDShard::update_pg_epoch(OSDShardPGSlot *slot, epoch_t e) { - Mutex::Locker l(shard_lock); + std::lock_guard l(shard_lock); dout(30) << "min was " << pg_slots_by_epoch.begin()->epoch << " on " << pg_slots_by_epoch.begin()->pg->pg_id << dendl; pg_slots_by_epoch.erase(pg_slots_by_epoch.iterator_to(*slot)); @@ -9847,7 +9847,7 @@ void OSDShard::update_pg_epoch(OSDShardPGSlot *slot, epoch_t e) epoch_t OSDShard::get_min_pg_epoch() { - Mutex::Locker l(shard_lock); + std::lock_guard l(shard_lock); auto p = pg_slots_by_epoch.begin(); if (p == pg_slots_by_epoch.end()) { return 0; @@ -9857,7 +9857,7 @@ epoch_t OSDShard::get_min_pg_epoch() void OSDShard::wait_min_pg_epoch(epoch_t need) { - Mutex::Locker l(shard_lock); + std::lock_guard l(shard_lock); ++waiting_for_min_pg_epoch; while (!pg_slots_by_epoch.empty() && pg_slots_by_epoch.begin()->epoch < need) { @@ -9870,7 +9870,7 @@ void OSDShard::wait_min_pg_epoch(epoch_t need) epoch_t OSDShard::get_max_waiting_epoch() { - Mutex::Locker l(shard_lock); + std::lock_guard l(shard_lock); epoch_t r = 0; for (auto& i : pg_slots) { if (!i.second->waiting_peering.empty()) { @@ -9884,10 +9884,10 @@ void OSDShard::consume_map( OSDMapRef& new_osdmap, unsigned *pushes_to_free) { - Mutex::Locker l(shard_lock); + std::lock_guard l(shard_lock); OSDMapRef old_osdmap; { - Mutex::Locker l(osdmap_lock); + std::lock_guard l(osdmap_lock); old_osdmap = std::move(shard_osdmap); shard_osdmap = new_osdmap; } @@ -10006,7 +10006,7 @@ void OSDShard::identify_splits_and_merges( set> *split_pgs, set> *merge_pgs) { - Mutex::Locker l(shard_lock); + std::lock_guard l(shard_lock); if (shard_osdmap) { for (auto& i : pg_slots) { const spg_t& pgid = i.first; @@ -10031,7 +10031,7 @@ void OSDShard::identify_splits_and_merges( void OSDShard::prime_splits(const OSDMapRef& as_of_osdmap, set> *pgids) { - Mutex::Locker l(shard_lock); + std::lock_guard l(shard_lock); _prime_splits(pgids); if (shard_osdmap->get_epoch() > as_of_osdmap->get_epoch()) { set> newer_children; @@ -10085,7 +10085,7 @@ void OSDShard::_prime_splits(set> *pgids) void OSDShard::prime_merges(const OSDMapRef& as_of_osdmap, set> *merge_pgs) { - Mutex::Locker l(shard_lock); + std::lock_guard l(shard_lock); dout(20) << __func__ << " checking shard " << shard_id << " for remaining merge pgs " << merge_pgs << dendl; auto p = merge_pgs->begin(); @@ -10134,7 +10134,7 @@ void OSDShard::register_and_wake_split_child(PG *pg) { epoch_t epoch; { - Mutex::Locker l(shard_lock); + std::lock_guard l(shard_lock); dout(10) << pg->pg_id << " " << pg << dendl; auto p = pg_slots.find(pg->pg_id); ceph_assert(p != pg_slots.end()); @@ -10172,7 +10172,7 @@ void OSDShard::register_and_wake_split_child(PG *pg) void OSDShard::unprime_split_children(spg_t parent, unsigned old_pg_num) { - Mutex::Locker l(shard_lock); + std::lock_guard l(shard_lock); vector to_delete; for (auto& i : pg_slots) { if (i.first != parent && diff --git a/src/osd/OSD.h b/src/osd/OSD.h index ba5465af21d..685f64cc5a0 100644 --- a/src/osd/OSD.h +++ b/src/osd/OSD.h @@ -301,11 +301,11 @@ private: public: OSDSuperblock get_superblock() { - Mutex::Locker l(publish_lock); + std::lock_guard l(publish_lock); return superblock; } void publish_superblock(const OSDSuperblock &block) { - Mutex::Locker l(publish_lock); + std::lock_guard l(publish_lock); superblock = block; } @@ -317,15 +317,15 @@ private: public: OSDMapRef get_osdmap() { - Mutex::Locker l(publish_lock); + std::lock_guard l(publish_lock); return osdmap; } epoch_t get_osdmap_epoch() { - Mutex::Locker l(publish_lock); + std::lock_guard l(publish_lock); return osdmap ? osdmap->get_epoch() : 0; } void publish_map(OSDMapRef map) { - Mutex::Locker l(publish_lock); + std::lock_guard l(publish_lock); osdmap = map; } @@ -349,7 +349,7 @@ private: public: void pre_publish_map(OSDMapRef map) { - Mutex::Locker l(pre_publish_lock); + std::lock_guard l(pre_publish_lock); next_osdmap = std::move(map); } @@ -359,7 +359,7 @@ public: /// gets ref to next_osdmap and registers the epoch as reserved OSDMapRef get_nextmap_reserved() { - Mutex::Locker l(pre_publish_lock); + std::lock_guard l(pre_publish_lock); if (!next_osdmap) return OSDMapRef(); epoch_t e = next_osdmap->get_epoch(); @@ -370,7 +370,7 @@ public: } /// releases reservation on map void release_map(OSDMapRef osdmap) { - Mutex::Locker l(pre_publish_lock); + std::lock_guard l(pre_publish_lock); map::iterator i = map_reservations.find(osdmap->get_epoch()); ceph_assert(i != map_reservations.end()); @@ -382,7 +382,7 @@ public: } /// blocks until there are no reserved maps prior to next_osdmap void await_reserved_maps() { - Mutex::Locker l(pre_publish_lock); + std::lock_guard l(pre_publish_lock); ceph_assert(next_osdmap); while (true) { map::const_iterator i = map_reservations.cbegin(); @@ -394,7 +394,7 @@ public: } } OSDMapRef get_next_osdmap() { - Mutex::Locker l(pre_publish_lock); + std::lock_guard l(pre_publish_lock); if (!next_osdmap) return OSDMapRef(); return next_osdmap; @@ -467,17 +467,17 @@ public: double pool_scrub_max_interval, bool must) { ScrubJob scrub(cct, pgid, t, pool_scrub_min_interval, pool_scrub_max_interval, must); - Mutex::Locker l(sched_scrub_lock); + std::lock_guard l(sched_scrub_lock); sched_scrub_pg.insert(scrub); return scrub.sched_time; } void unreg_pg_scrub(spg_t pgid, utime_t t) { - Mutex::Locker l(sched_scrub_lock); + std::lock_guard l(sched_scrub_lock); size_t removed = sched_scrub_pg.erase(ScrubJob(cct, pgid, t)); ceph_assert(removed); } bool first_scrub_stamp(ScrubJob *out) { - Mutex::Locker l(sched_scrub_lock); + std::lock_guard l(sched_scrub_lock); if (sched_scrub_pg.empty()) return false; set::iterator iter = sched_scrub_pg.begin(); @@ -486,7 +486,7 @@ public: } bool next_scrub_stamp(const ScrubJob& next, ScrubJob *out) { - Mutex::Locker l(sched_scrub_lock); + std::lock_guard l(sched_scrub_lock); if (sched_scrub_pg.empty()) return false; set::const_iterator iter = sched_scrub_pg.lower_bound(next); @@ -501,7 +501,7 @@ public: void dumps_scrub(Formatter *f) { ceph_assert(f != nullptr); - Mutex::Locker l(sched_scrub_lock); + std::lock_guard l(sched_scrub_lock); f->open_array_section("scrubs"); for (const auto &i: sched_scrub_pg) { @@ -579,13 +579,13 @@ public: /// enable agent for a pg void agent_enable_pg(PG *pg, uint64_t priority) { - Mutex::Locker l(agent_lock); + std::lock_guard l(agent_lock); _enqueue(pg, priority); } /// adjust priority for an enagled pg void agent_adjust_pg(PG *pg, uint64_t old_priority, uint64_t new_priority) { - Mutex::Locker l(agent_lock); + std::lock_guard l(agent_lock); ceph_assert(new_priority != old_priority); _enqueue(pg, new_priority); _dequeue(pg, old_priority); @@ -593,19 +593,19 @@ public: /// disable agent for a pg void agent_disable_pg(PG *pg, uint64_t old_priority) { - Mutex::Locker l(agent_lock); + std::lock_guard l(agent_lock); _dequeue(pg, old_priority); } /// note start of an async (evict) op void agent_start_evict_op() { - Mutex::Locker l(agent_lock); + std::lock_guard l(agent_lock); ++agent_ops; } /// note finish or cancellation of an async (evict) op void agent_finish_evict_op() { - Mutex::Locker l(agent_lock); + std::lock_guard l(agent_lock); ceph_assert(agent_ops > 0); --agent_ops; agent_cond.Signal(); @@ -613,7 +613,7 @@ public: /// note start of an async (flush) op void agent_start_op(const hobject_t& oid) { - Mutex::Locker l(agent_lock); + std::lock_guard l(agent_lock); ++agent_ops; ceph_assert(agent_oids.count(oid) == 0); agent_oids.insert(oid); @@ -621,7 +621,7 @@ public: /// note finish or cancellation of an async (flush) op void agent_finish_op(const hobject_t& oid) { - Mutex::Locker l(agent_lock); + std::lock_guard l(agent_lock); ceph_assert(agent_ops > 0); --agent_ops; ceph_assert(agent_oids.count(oid) == 1); @@ -631,23 +631,23 @@ public: /// check if we are operating on an object bool agent_is_active_oid(const hobject_t& oid) { - Mutex::Locker l(agent_lock); + std::lock_guard l(agent_lock); return agent_oids.count(oid); } /// get count of active agent ops int agent_get_num_ops() { - Mutex::Locker l(agent_lock); + std::lock_guard l(agent_lock); return agent_ops; } void agent_inc_high_count() { - Mutex::Locker l(agent_lock); + std::lock_guard l(agent_lock); flush_mode_high_count ++; } void agent_dec_high_count() { - Mutex::Locker l(agent_lock); + std::lock_guard l(agent_lock); flush_mode_high_count --; } @@ -687,7 +687,7 @@ public: SafeTimer watch_timer; uint64_t next_notif_id; uint64_t get_next_id(epoch_t cur_epoch) { - Mutex::Locker l(watch_lock); + std::lock_guard l(watch_lock); return (((uint64_t)cur_epoch) << 32) | ((uint64_t)(next_notif_id++)); } @@ -786,24 +786,24 @@ public: defer_recovery_until += defer_for; } void pause_recovery() { - Mutex::Locker l(recovery_lock); + std::lock_guard l(recovery_lock); recovery_paused = true; } bool recovery_is_paused() { - Mutex::Locker l(recovery_lock); + std::lock_guard l(recovery_lock); return recovery_paused; } void unpause_recovery() { - Mutex::Locker l(recovery_lock); + std::lock_guard l(recovery_lock); recovery_paused = false; _maybe_queue_recovery(); } void kick_recovery_queue() { - Mutex::Locker l(recovery_lock); + std::lock_guard l(recovery_lock); _maybe_queue_recovery(); } void clear_queued_recovery(PG *pg) { - Mutex::Locker l(recovery_lock); + std::lock_guard l(recovery_lock); awaiting_throttle.remove_if( [pg](decltype(awaiting_throttle)::const_reference awaiting ) { return awaiting.second.get() == pg; @@ -811,7 +811,7 @@ public: } // delayed pg activation void queue_for_recovery(PG *pg) { - Mutex::Locker l(recovery_lock); + std::lock_guard l(recovery_lock); if (pg->is_forced_recovery_or_backfill()) { awaiting_throttle.push_front(make_pair(pg->get_osdmap()->get_epoch(), pg)); @@ -821,7 +821,7 @@ public: _maybe_queue_recovery(); } void queue_recovery_after_sleep(PG *pg, epoch_t queued, uint64_t reserved_pushes) { - Mutex::Locker l(recovery_lock); + std::lock_guard l(recovery_lock); _queue_for_recovery(make_pair(queued, pg), reserved_pushes); } @@ -841,24 +841,24 @@ public: return ret; } OSDMapRef add_map(OSDMap *o) { - Mutex::Locker l(map_cache_lock); + std::lock_guard l(map_cache_lock); return _add_map(o); } OSDMapRef _add_map(OSDMap *o); void add_map_bl(epoch_t e, bufferlist& bl) { - Mutex::Locker l(map_cache_lock); + std::lock_guard l(map_cache_lock); return _add_map_bl(e, bl); } void _add_map_bl(epoch_t e, bufferlist& bl); bool get_map_bl(epoch_t e, bufferlist& bl) { - Mutex::Locker l(map_cache_lock); + std::lock_guard l(map_cache_lock); return _get_map_bl(e, bl); } bool _get_map_bl(epoch_t e, bufferlist& bl); void add_map_inc_bl(epoch_t e, bufferlist& bl) { - Mutex::Locker l(map_cache_lock); + std::lock_guard l(map_cache_lock); return _add_map_inc_bl(e, bl); } void _add_map_inc_bl(epoch_t e, bufferlist& bl); @@ -868,7 +868,7 @@ public: int get_deleted_pool_pg_num(int64_t pool); void store_deleted_pool_pg_num(int64_t pool, int pg_num) { - Mutex::Locker l(map_cache_lock); + std::lock_guard l(map_cache_lock); deleted_pool_pg_nums[pool] = pg_num; } @@ -905,14 +905,14 @@ public: void set_statfs(const struct store_statfs_t &stbuf); osd_stat_t set_osd_stat(vector& hb_peers, int num_pgs); osd_stat_t get_osd_stat() { - Mutex::Locker l(stat_lock); + std::lock_guard l(stat_lock); ++seq; osd_stat.up_from = up_epoch; osd_stat.seq = ((uint64_t)osd_stat.up_from << 32) + seq; return osd_stat; } uint64_t get_osd_stat_seq() { - Mutex::Locker l(stat_lock); + std::lock_guard l(stat_lock); return osd_stat.seq; } @@ -1137,7 +1137,7 @@ struct OSDShard { OSDMapRef shard_osdmap; OSDMapRef get_osdmap() { - Mutex::Locker l(osdmap_lock); + std::lock_guard l(osdmap_lock); return shard_osdmap; } @@ -1475,15 +1475,15 @@ private: /// Caller assumes refs for included Sessions void get_sessions_waiting_for_map(set *out) { - Mutex::Locker l(session_waiting_lock); + std::lock_guard l(session_waiting_lock); out->swap(session_waiting_for_map); } void register_session_waiting_on_map(SessionRef session) { - Mutex::Locker l(session_waiting_lock); + std::lock_guard l(session_waiting_lock); session_waiting_for_map.insert(session); } void clear_session_waiting_on_map(SessionRef session) { - Mutex::Locker l(session_waiting_lock); + std::lock_guard l(session_waiting_lock); session_waiting_for_map.erase(session); } void dispatch_sessions_waiting_on_map() { @@ -1492,13 +1492,13 @@ private: for (auto i = sessions_to_check.begin(); i != sessions_to_check.end(); sessions_to_check.erase(i++)) { - Mutex::Locker l{(*i)->session_dispatch_lock}; + std::lock_guard l{(*i)->session_dispatch_lock}; SessionRef session = *i; dispatch_session_waiting(session, osdmap); } } void session_handle_reset(SessionRef session) { - Mutex::Locker l(session->session_dispatch_lock); + std::lock_guard l(session->session_dispatch_lock); clear_session_waiting_on_map(session); session->clear_backoffs(); @@ -1608,7 +1608,7 @@ private: void need_heartbeat_peer_update(); void heartbeat_kick() { - Mutex::Locker l(heartbeat_lock); + std::lock_guard l(heartbeat_lock); heartbeat_cond.Signal(); } @@ -1789,7 +1789,7 @@ protected: uint32_t shard_index = thread_index % osd->num_shards; auto &&sdata = osd->shards[shard_index]; ceph_assert(sdata); - Mutex::Locker l(sdata->shard_lock); + std::lock_guard l(sdata->shard_lock); if (thread_index < osd->num_shards) { return sdata->pqueue->empty() && sdata->context_queue.empty(); } else { diff --git a/src/osd/OSDMapMapping.cc b/src/osd/OSDMapMapping.cc index 649ac6c4332..6640d83dd8a 100644 --- a/src/osd/OSDMapMapping.cc +++ b/src/osd/OSDMapMapping.cc @@ -129,7 +129,7 @@ void ParallelPGMapper::Job::finish_one() { Context *fin = nullptr; { - Mutex::Locker l(lock); + std::lock_guard l(lock); if (--shards == 0) { if (!aborted) { finish = ceph_clock_now(); diff --git a/src/osd/OSDMapMapping.h b/src/osd/OSDMapMapping.h index e85e85dc6e0..e2a52797458 100644 --- a/src/osd/OSDMapMapping.h +++ b/src/osd/OSDMapMapping.h @@ -48,14 +48,14 @@ public: } } bool is_done() { - Mutex::Locker l(lock); + std::lock_guard l(lock); return shards == 0; } utime_t get_duration() { return finish - start; } void wait() { - Mutex::Locker l(lock); + std::lock_guard l(lock); while (shards > 0) { cond.Wait(lock); } @@ -63,7 +63,7 @@ public: bool wait_for(double duration) { utime_t until = start; until += duration; - Mutex::Locker l(lock); + std::lock_guard l(lock); while (shards > 0) { if (ceph_clock_now() >= until) { return false; @@ -75,7 +75,7 @@ public: void abort() { Context *fin = nullptr; { - Mutex::Locker l(lock); + std::lock_guard l(lock); aborted = true; fin = onfinish; onfinish = nullptr; @@ -89,7 +89,7 @@ public: } void start_one() { - Mutex::Locker l(lock); + std::lock_guard l(lock); ++shards; } void finish_one(); diff --git a/src/osd/OpRequest.cc b/src/osd/OpRequest.cc index d595b1bc9ab..a33c1391abe 100644 --- a/src/osd/OpRequest.cc +++ b/src/osd/OpRequest.cc @@ -59,7 +59,7 @@ void OpRequest::_dump(Formatter *f) const } { f->open_array_section("events"); - Mutex::Locker l(lock); + std::lock_guard l(lock); for (auto& i : events) { f->dump_object("event", i); } diff --git a/src/osd/PG.cc b/src/osd/PG.cc index 3202abead4c..927dbdf394d 100644 --- a/src/osd/PG.cc +++ b/src/osd/PG.cc @@ -154,7 +154,7 @@ void PG::get(const char* tag) { ref++; #ifdef PG_DEBUG_REFS - Mutex::Locker l(_ref_id_lock); + std::lock_guard l(_ref_id_lock); _tag_counts[tag]++; #endif } @@ -163,7 +163,7 @@ void PG::put(const char* tag) { #ifdef PG_DEBUG_REFS { - Mutex::Locker l(_ref_id_lock); + std::lock_guard l(_ref_id_lock); auto tag_counts_entry = _tag_counts.find(tag); ceph_assert(tag_counts_entry != _tag_counts.end()); --tag_counts_entry->second; @@ -180,7 +180,7 @@ void PG::put(const char* tag) uint64_t PG::get_with_id() { ref++; - Mutex::Locker l(_ref_id_lock); + std::lock_guard l(_ref_id_lock); uint64_t id = ++_ref_id; BackTrace bt(0); stringstream ss; @@ -195,7 +195,7 @@ void PG::put_with_id(uint64_t id) { dout(20) << __func__ << ": " << info.pgid << " put id " << id << " (current) ref==" << ref << dendl; { - Mutex::Locker l(_ref_id_lock); + std::lock_guard l(_ref_id_lock); ceph_assert(_live_ids.count(id)); _live_ids.erase(id); } @@ -205,7 +205,7 @@ void PG::put_with_id(uint64_t id) void PG::dump_live_ids() { - Mutex::Locker l(_ref_id_lock); + std::lock_guard l(_ref_id_lock); dout(0) << "\t" << __func__ << ": " << info.pgid << " live ids:" << dendl; for (map::iterator i = _live_ids.begin(); i != _live_ids.end(); @@ -2793,7 +2793,7 @@ void PG::add_backoff(SessionRef s, const hobject_t& begin, const hobject_t& end) << " " << *b << dendl; ceph_abort(); } - Mutex::Locker l(backoff_lock); + std::lock_guard l(backoff_lock); { b = new Backoff(info.pgid, this, s, ++s->backoff_seq, begin, end); backoffs[begin].insert(b); @@ -2815,7 +2815,7 @@ void PG::release_backoffs(const hobject_t& begin, const hobject_t& end) dout(10) << __func__ << " [" << begin << "," << end << ")" << dendl; vector bv; { - Mutex::Locker l(backoff_lock); + std::lock_guard l(backoff_lock); auto p = backoffs.lower_bound(begin); while (p != backoffs.end()) { int r = cmp(p->first, end); @@ -2846,7 +2846,7 @@ void PG::release_backoffs(const hobject_t& begin, const hobject_t& end) } } for (auto b : bv) { - Mutex::Locker l(b->lock); + std::lock_guard l(b->lock); dout(10) << __func__ << " " << *b << dendl; if (b->session) { ceph_assert(b->pg == this); @@ -2877,12 +2877,12 @@ void PG::clear_backoffs() dout(10) << __func__ << " " << dendl; map> ls; { - Mutex::Locker l(backoff_lock); + std::lock_guard l(backoff_lock); ls.swap(backoffs); } for (auto& p : ls) { for (auto& b : p.second) { - Mutex::Locker l(b->lock); + std::lock_guard l(b->lock); dout(10) << __func__ << " " << *b << dendl; if (b->session) { ceph_assert(b->pg == this); @@ -2902,7 +2902,7 @@ void PG::clear_backoffs() void PG::rm_backoff(BackoffRef b) { dout(10) << __func__ << " " << *b << dendl; - Mutex::Locker l(backoff_lock); + std::lock_guard l(backoff_lock); ceph_assert(b->lock.is_locked_by_me()); ceph_assert(b->pg == this); auto p = backoffs.find(b->begin); @@ -2993,7 +2993,7 @@ void PG::purge_strays() void PG::set_probe_targets(const set &probe_set) { - Mutex::Locker l(heartbeat_peer_lock); + std::lock_guard l(heartbeat_peer_lock); probe_targets.clear(); for (set::iterator i = probe_set.begin(); i != probe_set.end(); @@ -3004,7 +3004,7 @@ void PG::set_probe_targets(const set &probe_set) void PG::clear_probe_targets() { - Mutex::Locker l(heartbeat_peer_lock); + std::lock_guard l(heartbeat_peer_lock); probe_targets.clear(); } @@ -4465,7 +4465,7 @@ void PG::reject_reservation() void PG::schedule_backfill_retry(float delay) { - Mutex::Locker lock(osd->recovery_request_lock); + std::lock_guard lock(osd->recovery_request_lock); osd->recovery_request_timer.add_event_after( delay, new QueuePeeringEvt( @@ -4475,7 +4475,7 @@ void PG::schedule_backfill_retry(float delay) void PG::schedule_recovery_retry(float delay) { - Mutex::Locker lock(osd->recovery_request_lock); + std::lock_guard lock(osd->recovery_request_lock); osd->recovery_request_timer.add_event_after( delay, new QueuePeeringEvt( @@ -4916,7 +4916,7 @@ void PG::scrub(epoch_t queued, ThreadPool::TPHandle &handle) pg->scrubber.sleep_start = utime_t(); pg->unlock(); }); - Mutex::Locker l(osd->sleep_lock); + std::lock_guard l(osd->sleep_lock); osd->sleep_timer.add_event_after(cct->_conf->osd_scrub_sleep, scrub_requeue_callback); scrubber.sleeping = true; diff --git a/src/osd/PG.h b/src/osd/PG.h index dd1ba00ce32..c24583c9b1c 100644 --- a/src/osd/PG.h +++ b/src/osd/PG.h @@ -154,11 +154,11 @@ class PGRecoveryStats { PGRecoveryStats() : lock("PGRecoverStats::lock") {} void reset() { - Mutex::Locker l(lock); + std::lock_guard l(lock); info.clear(); } void dump(ostream& out) { - Mutex::Locker l(lock); + std::lock_guard l(lock); for (map::iterator p = info.begin(); p != info.end(); ++p) { per_state_info& i = p->second; out << i.enter << "\t" << i.exit << "\t" @@ -170,7 +170,7 @@ class PGRecoveryStats { } void dump_formatted(Formatter *f) { - Mutex::Locker l(lock); + std::lock_guard l(lock); f->open_array_section("pg_recovery_stats"); for (map::iterator p = info.begin(); p != info.end(); ++p) { @@ -197,11 +197,11 @@ class PGRecoveryStats { } void log_enter(const char *s) { - Mutex::Locker l(lock); + std::lock_guard l(lock); info[s].enter++; } void log_exit(const char *s, utime_t dur, uint64_t events, utime_t event_dur) { - Mutex::Locker l(lock); + std::lock_guard l(lock); per_state_info &i = info[s]; i.exit++; i.total_time += dur; diff --git a/src/osd/PrimaryLogPG.cc b/src/osd/PrimaryLogPG.cc index c0ccd802e12..1e944a105ff 100644 --- a/src/osd/PrimaryLogPG.cc +++ b/src/osd/PrimaryLogPG.cc @@ -11272,7 +11272,7 @@ SnapSetContext *PrimaryLogPG::get_snapset_context( const map *attrs, bool oid_existed) { - Mutex::Locker l(snapset_contexts_lock); + std::lock_guard l(snapset_contexts_lock); SnapSetContext *ssc; map::iterator p = snapset_contexts.find( oid.get_snapdir()); @@ -11318,7 +11318,7 @@ SnapSetContext *PrimaryLogPG::get_snapset_context( void PrimaryLogPG::put_snapset_context(SnapSetContext *ssc) { - Mutex::Locker l(snapset_contexts_lock); + std::lock_guard l(snapset_contexts_lock); --ssc->ref; if (ssc->ref == 0) { if (ssc->registered) diff --git a/src/osd/PrimaryLogPG.h b/src/osd/PrimaryLogPG.h index 3707bb98473..53957f096c4 100644 --- a/src/osd/PrimaryLogPG.h +++ b/src/osd/PrimaryLogPG.h @@ -1001,7 +1001,7 @@ protected: bool oid_existed = true //indicate this oid whether exsited in backend ); void register_snapset_context(SnapSetContext *ssc) { - Mutex::Locker l(snapset_contexts_lock); + std::lock_guard l(snapset_contexts_lock); _register_snapset_context(ssc); } void _register_snapset_context(SnapSetContext *ssc) { @@ -1613,7 +1613,7 @@ private: }; auto *pg = context< SnapTrimmer >().pg; if (pg->cct->_conf->osd_snap_trim_sleep > 0) { - Mutex::Locker l(pg->osd->sleep_lock); + std::lock_guard l(pg->osd->sleep_lock); wakeup = pg->osd->sleep_timer.add_event_after( pg->cct->_conf->osd_snap_trim_sleep, new OnTimer{pg, pg->get_osdmap()->get_epoch()}); @@ -1625,7 +1625,7 @@ private: context< SnapTrimmer >().log_exit(state_name, enter_time); auto *pg = context< SnapTrimmer >().pg; if (wakeup) { - Mutex::Locker l(pg->osd->sleep_lock); + std::lock_guard l(pg->osd->sleep_lock); pg->osd->sleep_timer.cancel_event(wakeup); wakeup = nullptr; } diff --git a/src/osd/Session.cc b/src/osd/Session.cc index 82f10e2d0ab..44b5817a374 100644 --- a/src/osd/Session.cc +++ b/src/osd/Session.cc @@ -13,14 +13,14 @@ void Session::clear_backoffs() { map>> ls; { - Mutex::Locker l(backoff_lock); + std::lock_guard l(backoff_lock); ls.swap(backoffs); backoff_count = 0; } for (auto& i : ls) { for (auto& p : i.second) { for (auto& b : p.second) { - Mutex::Locker l(b->lock); + std::lock_guard l(b->lock); if (b->pg) { ceph_assert(b->session == this); ceph_assert(b->is_new() || b->is_acked()); @@ -44,7 +44,7 @@ void Session::ack_backoff( const hobject_t& begin, const hobject_t& end) { - Mutex::Locker l(backoff_lock); + std::lock_guard l(backoff_lock); auto p = backoffs.find(pgid); if (p == backoffs.end()) { dout(20) << __func__ << " " << pgid << " " << id << " [" << begin << "," diff --git a/src/osd/Session.h b/src/osd/Session.h index ae76397f8f2..be35af61d11 100644 --- a/src/osd/Session.h +++ b/src/osd/Session.h @@ -175,7 +175,7 @@ struct Session : public RefCountedObject { if (!backoff_count.load()) { return nullptr; } - Mutex::Locker l(backoff_lock); + std::lock_guard l(backoff_lock); ceph_assert(!backoff_count == backoffs.empty()); auto i = backoffs.find(pgid); if (i == backoffs.end()) { @@ -203,7 +203,7 @@ struct Session : public RefCountedObject { CephContext *cct, spg_t pgid, const hobject_t& oid, const Message *m); void add_backoff(BackoffRef b) { - Mutex::Locker l(backoff_lock); + std::lock_guard l(backoff_lock); ceph_assert(!backoff_count == backoffs.empty()); backoffs[b->pgid][b->begin].insert(b); ++backoff_count; @@ -211,7 +211,7 @@ struct Session : public RefCountedObject { // called by PG::release_*_backoffs and PG::clear_backoffs() void rm_backoff(BackoffRef b) { - Mutex::Locker l(backoff_lock); + std::lock_guard l(backoff_lock); ceph_assert(b->lock.is_locked_by_me()); ceph_assert(b->session == this); auto i = backoffs.find(b->pgid); diff --git a/src/osd/Watch.cc b/src/osd/Watch.cc index 29d325aeb9e..bb25b4487c1 100644 --- a/src/osd/Watch.cc +++ b/src/osd/Watch.cc @@ -147,14 +147,14 @@ void Notify::unregister_cb() void Notify::start_watcher(WatchRef watch) { - Mutex::Locker l(lock); + std::lock_guard l(lock); dout(10) << "start_watcher" << dendl; watchers.insert(watch); } void Notify::complete_watcher(WatchRef watch, bufferlist& reply_bl) { - Mutex::Locker l(lock); + std::lock_guard l(lock); dout(10) << "complete_watcher" << dendl; if (is_discarded()) return; @@ -168,7 +168,7 @@ void Notify::complete_watcher(WatchRef watch, bufferlist& reply_bl) void Notify::complete_watcher_remove(WatchRef watch) { - Mutex::Locker l(lock); + std::lock_guard l(lock); dout(10) << __func__ << dendl; if (is_discarded()) return; @@ -209,7 +209,7 @@ void Notify::maybe_complete_notify() void Notify::discard() { - Mutex::Locker l(lock); + std::lock_guard l(lock); discarded = true; unregister_cb(); watchers.clear(); @@ -217,7 +217,7 @@ void Notify::discard() void Notify::init() { - Mutex::Locker l(lock); + std::lock_guard l(lock); register_cb(); maybe_complete_notify(); } @@ -322,7 +322,7 @@ Context *Watch::get_delayed_cb() void Watch::register_cb() { - Mutex::Locker l(osd->watch_lock); + std::lock_guard l(osd->watch_lock); if (cb) { dout(15) << "re-registering callback, timeout: " << timeout << dendl; cb->cancel(); @@ -344,7 +344,7 @@ void Watch::unregister_cb() dout(15) << "actually registered, cancelling" << dendl; cb->cancel(); { - Mutex::Locker l(osd->watch_lock); + std::lock_guard l(osd->watch_lock); osd->watch_timer.cancel_event(cb); // harmless if not registered with timer } cb = nullptr; @@ -504,13 +504,13 @@ WatchRef Watch::makeWatchRef( void WatchConState::addWatch(WatchRef watch) { - Mutex::Locker l(lock); + std::lock_guard l(lock); watches.insert(watch); } void WatchConState::removeWatch(WatchRef watch) { - Mutex::Locker l(lock); + std::lock_guard l(lock); watches.erase(watch); } @@ -518,7 +518,7 @@ void WatchConState::reset(Connection *con) { set _watches; { - Mutex::Locker l(lock); + std::lock_guard l(lock); _watches.swap(watches); } for (set::iterator i = _watches.begin(); -- 2.39.5