namespace librados {
TestMemCluster::File::File()
- : snap_id(), exists(true), lock("TestMemCluster::File::lock") {
+ : snap_id(), exists(true) {
}
TestMemCluster::File::File(const File &rhs)
: data(rhs.data),
mtime(rhs.mtime),
snap_id(rhs.snap_id),
- exists(rhs.exists),
- lock("TestMemCluster::File::lock") {
+ exists(rhs.exists) {
}
-TestMemCluster::Pool::Pool()
- : file_lock("TestMemCluster::Pool::file_lock") {
-}
+TestMemCluster::Pool::Pool() = default;
TestMemCluster::TestMemCluster()
- : m_lock("TestMemCluster::m_lock"),
- m_next_nonce(static_cast<uint32_t>(reinterpret_cast<uint64_t>(this))) {
+ : m_next_nonce(static_cast<uint32_t>(reinterpret_cast<uint64_t>(this))) {
}
TestMemCluster::~TestMemCluster() {
int TestMemCluster::register_object_handler(int64_t pool_id,
const ObjectLocator& locator,
ObjectHandler* object_handler) {
- Mutex::Locker locker(m_lock);
+ std::lock_guard locker{m_lock};
auto pool = get_pool(m_lock, pool_id);
if (pool == nullptr) {
return -ENOENT;
}
- RWLock::WLocker pool_locker(pool->file_lock);
+ std::unique_lock pool_locker{pool->file_lock};
auto file_it = pool->files.find(locator);
if (file_it == pool->files.end()) {
return -ENOENT;
void TestMemCluster::unregister_object_handler(int64_t pool_id,
const ObjectLocator& locator,
ObjectHandler* object_handler) {
- Mutex::Locker locker(m_lock);
+ std::lock_guard locker{m_lock};
auto pool = get_pool(m_lock, pool_id);
if (pool == nullptr) {
return;
}
- RWLock::WLocker pool_locker(pool->file_lock);
+ std::unique_lock pool_locker{pool->file_lock};
auto handlers_it = pool->file_handlers.find(locator);
if (handlers_it == pool->file_handlers.end()) {
return;
}
int TestMemCluster::pool_create(const std::string &pool_name) {
- Mutex::Locker locker(m_lock);
+ std::lock_guard locker{m_lock};
if (m_pools.find(pool_name) != m_pools.end()) {
return -EEXIST;
}
}
int TestMemCluster::pool_delete(const std::string &pool_name) {
- Mutex::Locker locker(m_lock);
+ std::lock_guard locker{m_lock};
Pools::iterator iter = m_pools.find(pool_name);
if (iter == m_pools.end()) {
return -ENOENT;
}
int TestMemCluster::pool_list(std::list<std::pair<int64_t, std::string> >& v) {
- Mutex::Locker locker(m_lock);
+ std::lock_guard locker{m_lock};
v.clear();
for (Pools::iterator iter = m_pools.begin(); iter != m_pools.end(); ++iter) {
v.push_back(std::make_pair(iter->second->pool_id, iter->first));
}
int64_t TestMemCluster::pool_lookup(const std::string &pool_name) {
- Mutex::Locker locker(m_lock);
+ std::lock_guard locker{m_lock};
Pools::iterator iter = m_pools.find(pool_name);
if (iter == m_pools.end()) {
return -ENOENT;
}
int TestMemCluster::pool_reverse_lookup(int64_t id, std::string *name) {
- Mutex::Locker locker(m_lock);
+ std::lock_guard locker{m_lock};
for (Pools::iterator iter = m_pools.begin(); iter != m_pools.end(); ++iter) {
if (iter->second->pool_id == id) {
*name = iter->first;
}
TestMemCluster::Pool *TestMemCluster::get_pool(int64_t pool_id) {
- Mutex::Locker locker(m_lock);
+ std::lock_guard locker{m_lock};
return get_pool(m_lock, pool_id);
}
-TestMemCluster::Pool *TestMemCluster::get_pool(const Mutex& lock,
+TestMemCluster::Pool *TestMemCluster::get_pool(const ceph::mutex& lock,
int64_t pool_id) {
for (auto &pool_pair : m_pools) {
if (pool_pair.second->pool_id == pool_id) {
}
TestMemCluster::Pool *TestMemCluster::get_pool(const std::string &pool_name) {
- Mutex::Locker locker(m_lock);
+ std::lock_guard locker{m_lock};
Pools::iterator iter = m_pools.find(pool_name);
if (iter != m_pools.end()) {
return iter->second;
}
void TestMemCluster::allocate_client(uint32_t *nonce, uint64_t *global_id) {
- Mutex::Locker locker(m_lock);
+ std::lock_guard locker{m_lock};
*nonce = m_next_nonce++;
*global_id = m_next_global_id++;
}
void TestMemCluster::deallocate_client(uint32_t nonce) {
- Mutex::Locker locker(m_lock);
+ std::lock_guard locker{m_lock};
m_blacklist.erase(nonce);
}
bool TestMemCluster::is_blacklisted(uint32_t nonce) const {
- Mutex::Locker locker(m_lock);
+ std::lock_guard locker{m_lock};
return (m_blacklist.find(nonce) != m_blacklist.end());
}
void TestMemCluster::blacklist(uint32_t nonce) {
m_watch_notify.blacklist(nonce);
- Mutex::Locker locker(m_lock);
+ std::lock_guard locker{m_lock};
m_blacklist.insert(nonce);
}
void TestMemCluster::transaction_start(const ObjectLocator& locator) {
- Mutex::Locker locker(m_lock);
- while (m_transactions.count(locator)) {
- m_transaction_cond.Wait(m_lock);
- }
+ std::unique_lock locker{m_lock};
+ m_transaction_cond.wait(locker, [&locator, this] {
+ return m_transactions.count(locator) == 0;
+ });
auto result = m_transactions.insert(locator);
ceph_assert(result.second);
}
void TestMemCluster::transaction_finish(const ObjectLocator& locator) {
- Mutex::Locker locker(m_lock);
+ std::lock_guard locker{m_lock};
size_t count = m_transactions.erase(locator);
ceph_assert(count == 1);
- m_transaction_cond.Signal();
+ m_transaction_cond.notify_all();
}
} // namespace librados
interval_set<uint64_t> snap_overlap;
bool exists;
- RWLock lock;
+ ceph::shared_mutex lock =
+ ceph::make_shared_mutex("TestMemCluster::File::lock");
};
typedef boost::shared_ptr<File> SharedFile;
SnapSeqs snap_seqs;
uint64_t snap_id = 1;
- RWLock file_lock;
+ ceph::shared_mutex file_lock =
+ ceph::make_shared_mutex("TestMemCluster::Pool::file_lock");
Files files;
FileOMaps file_omaps;
FileTMaps file_tmaps;
typedef std::map<std::string, Pool*> Pools;
typedef std::set<uint32_t> Blacklist;
- mutable Mutex m_lock;
+ mutable ceph::mutex m_lock =
+ ceph::make_mutex("TestMemCluster::m_lock");
Pools m_pools;
int64_t m_pool_id = 0;
Blacklist m_blacklist;
- Cond m_transaction_cond;
+ ceph::condition_variable m_transaction_cond;
std::set<ObjectLocator> m_transactions;
- Pool *get_pool(const Mutex& lock, int64_t pool_id);
+ Pool *get_pool(const ceph::mutex& lock, int64_t pool_id);
};
TestMemCluster::SharedFile file;
{
- RWLock::WLocker l(m_pool->file_lock);
+ std::unique_lock l{m_pool->file_lock};
file = get_file(oid, true, snapc);
}
- RWLock::WLocker l(file->lock);
+ std::unique_lock l{file->lock};
auto off = file->data.length();
ensure_minimum_length(off + bl.length(), &file->data);
file->data.copy_in(off, bl.length(), bl);
return -EBLACKLISTED;
}
- RWLock::RLocker l(m_pool->file_lock);
+ std::shared_lock l{m_pool->file_lock};
TestMemCluster::SharedFile file = get_file(oid, false, get_snap_context());
if (file == NULL) {
return -ENOENT;
return -EBLACKLISTED;
}
- RWLock::WLocker l(m_pool->file_lock);
+ std::unique_lock l{m_pool->file_lock};
get_file(oid, true, snapc);
return 0;
}
out_snaps->seq = 0;
out_snaps->clones.clear();
- RWLock::RLocker l(m_pool->file_lock);
+ std::shared_lock l{m_pool->file_lock};
TestMemCluster::Files::iterator it = m_pool->files.find(
{get_namespace(), oid});
if (it == m_pool->files.end()) {
// Include the SNAP_HEAD
TestMemCluster::File &file = *file_snaps.back();
if (file.exists) {
- RWLock::RLocker l2(file.lock);
+ std::shared_lock l2{file.lock};
if (out_snaps->seq == 0 && !include_head) {
out_snaps->seq = file.snap_id;
}
TestMemCluster::SharedFile file;
{
- RWLock::RLocker l(m_pool->file_lock);
+ std::shared_lock l{m_pool->file_lock};
file = get_file(oid, false, get_snap_context());
if (file == NULL) {
return -ENOENT;
out_vals->clear();
- RWLock::RLocker l(file->lock);
+ std::shared_lock l{file->lock};
TestMemCluster::FileOMaps::iterator o_it = m_pool->file_omaps.find(
{get_namespace(), oid});
if (o_it == m_pool->file_omaps.end()) {
TestMemCluster::SharedFile file;
{
- RWLock::WLocker l(m_pool->file_lock);
+ std::unique_lock l{m_pool->file_lock};
file = get_file(oid, true, get_snap_context());
if (file == NULL) {
return -ENOENT;
}
}
- RWLock::WLocker l(file->lock);
+ std::unique_lock l{file->lock};
for (std::set<std::string>::iterator it = keys.begin();
it != keys.end(); ++it) {
m_pool->file_omaps[{get_namespace(), oid}].erase(*it);
TestMemCluster::SharedFile file;
{
- RWLock::WLocker l(m_pool->file_lock);
+ std::unique_lock l{m_pool->file_lock};
file = get_file(oid, true, get_snap_context());
if (file == NULL) {
return -ENOENT;
}
}
- RWLock::WLocker l(file->lock);
+ std::unique_lock l{file->lock};
for (std::map<std::string, bufferlist>::const_iterator it = map.begin();
it != map.end(); ++it) {
bufferlist bl;
TestMemCluster::SharedFile file;
{
- RWLock::RLocker l(m_pool->file_lock);
+ std::shared_lock l{m_pool->file_lock};
file = get_file(oid, false, get_snap_context());
if (file == NULL) {
return -ENOENT;
}
}
- RWLock::RLocker l(file->lock);
+ std::shared_lock l{file->lock};
if (len == 0) {
len = file->data.length();
}
return -EBLACKLISTED;
}
- RWLock::WLocker l(m_pool->file_lock);
+ std::unique_lock l{m_pool->file_lock};
TestMemCluster::SharedFile file = get_file(oid, false, snapc);
if (file == NULL) {
return -ENOENT;
file = get_file(oid, true, snapc);
{
- RWLock::WLocker l2(file->lock);
+ std::unique_lock l2{file->lock};
file->exists = false;
}
return -EBLACKLISTED;
}
- RWLock::WLocker l(m_pool->file_lock);
+ std::unique_lock l{m_pool->file_lock};
*snapid = ++m_pool->snap_id;
m_pool->snap_seqs.insert(*snapid);
return 0;
return -EBLACKLISTED;
}
- RWLock::WLocker l(m_pool->file_lock);
+ std::unique_lock l{m_pool->file_lock};
TestMemCluster::SnapSeqs::iterator it =
m_pool->snap_seqs.find(snapid);
if (it == m_pool->snap_seqs.end()) {
return -EBLACKLISTED;
}
- RWLock::WLocker l(m_pool->file_lock);
+ std::unique_lock l{m_pool->file_lock};
TestMemCluster::SharedFile file;
TestMemCluster::Files::iterator f_it = m_pool->files.find(
}
{
- RWLock::WLocker l(m_pool->file_lock);
+ std::unique_lock l{m_pool->file_lock};
get_file(oid, true, snapc);
}
// TODO verify correctness
TestMemCluster::SharedFile file;
{
- RWLock::RLocker l(m_pool->file_lock);
+ std::shared_lock l{m_pool->file_lock};
file = get_file(oid, false, get_snap_context());
if (file == NULL) {
return -ENOENT;
}
}
- RWLock::RLocker l(file->lock);
+ std::shared_lock l{file->lock};
len = clip_io(off, len, file->data.length());
// TODO support sparse read
if (m != NULL) {
TestMemCluster::SharedFile file;
{
- RWLock::RLocker l(m_pool->file_lock);
+ std::shared_lock l{m_pool->file_lock};
file = get_file(oid, false, get_snap_context());
if (file == NULL) {
return -ENOENT;
}
}
- RWLock::RLocker l(file->lock);
+ std::shared_lock l{file->lock};
if (psize != NULL) {
*psize = file->data.length();
}
TestMemCluster::SharedFile file;
{
- RWLock::WLocker l(m_pool->file_lock);
+ std::unique_lock l{m_pool->file_lock};
file = get_file(oid, true, snapc);
}
- RWLock::WLocker l(file->lock);
+ std::unique_lock l{file->lock};
bufferlist bl(size);
interval_set<uint64_t> is;
TestMemCluster::SharedFile file;
{
- RWLock::WLocker l(m_pool->file_lock);
+ std::unique_lock l{m_pool->file_lock};
file = get_file(oid, true, snapc);
}
- RWLock::WLocker l(file->lock);
+ std::unique_lock l{file->lock};
if (len > 0) {
interval_set<uint64_t> is;
is.insert(off, len);
TestMemCluster::SharedFile file;
{
- RWLock::WLocker l(m_pool->file_lock);
+ std::unique_lock l{m_pool->file_lock};
file = get_file(oid, true, snapc);
if (file == NULL) {
return -ENOENT;
}
}
- RWLock::WLocker l(file->lock);
+ std::unique_lock l{file->lock};
if (bl.length() > 0) {
interval_set<uint64_t> is;
is.insert(0, bl.length());
TestMemCluster::SharedFile file;
{
- RWLock::WLocker l(m_pool->file_lock);
+ std::unique_lock l{m_pool->file_lock};
file = get_file(oid, true, snapc);
}
- RWLock::WLocker l(file->lock);
+ std::unique_lock l{file->lock};
if (len > 0) {
interval_set<uint64_t> is;
is.insert(off, len);
TestMemCluster::SharedFile file;
{
- RWLock::RLocker l(m_pool->file_lock);
+ std::shared_lock l{m_pool->file_lock};
file = get_file(oid, false, get_snap_context());
if (file == NULL) {
return cmpext_compare(cmp_bl, read_bl);
}
}
- RWLock::RLocker l(file->lock);
+ std::shared_lock l{file->lock};
if (off >= file->data.length()) {
len = 0;
} else if (off + len > file->data.length()) {
}
TestMemCluster::SharedFile file;
- RWLock::RLocker l(m_pool->file_lock);
+ std::shared_lock l{m_pool->file_lock};
TestMemCluster::FileXAttrs::iterator it = m_pool->file_xattrs.find(
{get_namespace(), oid});
if (it == m_pool->file_xattrs.end()) {
return -EBLACKLISTED;
}
- RWLock::WLocker l(m_pool->file_lock);
+ std::unique_lock l{m_pool->file_lock};
m_pool->file_xattrs[{get_namespace(), oid}][name] = bl;
return 0;
}
bool truncate_redirect = false;
TestMemCluster::SharedFile file;
{
- RWLock::WLocker l(m_pool->file_lock);
+ std::unique_lock l{m_pool->file_lock};
file = get_file(oid, false, snapc);
if (!file) {
return 0;
}
file = get_file(oid, true, snapc);
- RWLock::RLocker l2(file->lock);
+ std::shared_lock l2{file->lock};
if (len > 0 && off + len >= file->data.length()) {
// Zero -> Truncate logic embedded in OSD
truncate_redirect = true;
auto pool = m_mem_cluster->get_pool(pool_id);
if (pool != nullptr) {
- RWLock::RLocker file_locker(pool->file_lock);
+ std::shared_lock file_locker{pool->file_lock};
for (auto &file_pair : pool->files) {
Object obj;
obj.oid = file_pair.first.name;
int TestWatchNotify::list_watchers(int64_t pool_id, const std::string& nspace,
const std::string& o,
std::list<obj_watch_t> *out_watchers) {
- Mutex::Locker lock(m_lock);
+ std::lock_guard lock{m_lock};
SharedWatcher watcher = get_watcher(pool_id, nspace, o);
if (!watcher) {
return -ENOENT;
CephContext *cct = rados_client->cct();
ldout(cct, 20) << "notify_id=" << notify_id << ", handle=" << handle
<< ", gid=" << gid << dendl;
- Mutex::Locker lock(m_lock);
+ std::lock_guard lock{m_lock};
WatcherID watcher_id = std::make_pair(gid, handle);
ack_notify(rados_client, pool_id, nspace, o, notify_id, watcher_id, bl);
finish_notify(rados_client, pool_id, nspace, o, notify_id);
ldout(cct, 20) << "handle=" << handle << dendl;
{
- Mutex::Locker locker(m_lock);
+ std::lock_guard locker{m_lock};
for (FileWatchers::iterator it = m_file_watchers.begin();
it != m_file_watchers.end(); ++it) {
SharedWatcher watcher = it->second;
}
void TestWatchNotify::blacklist(uint32_t nonce) {
- Mutex::Locker locker(m_lock);
+ std::lock_guard locker{m_lock};
for (auto file_it = m_file_watchers.begin();
file_it != m_file_watchers.end(); ) {
void TestWatchNotify::handle_object_removed(int64_t pool_id,
const std::string& nspace,
const std::string& oid) {
- Mutex::Locker locker(m_lock);
+ std::lock_guard locker{m_lock};
auto it = m_file_watchers.find({pool_id, nspace, oid});
if (it == m_file_watchers.end()) {
return;
librbd::MockTestImageCtx *dst_image_ctx, const SnapMap &snap_map,
uint64_t object_number, bool flatten, Context *on_finish) {
ceph_assert(s_instance != nullptr);
- Mutex::Locker locker(s_instance->lock);
+ std::lock_guard locker{s_instance->lock};
s_instance->snap_map = &snap_map;
s_instance->object_contexts[object_number] = on_finish;
- s_instance->cond.Signal();
+ s_instance->cond.notify_all();
return s_instance;
}
MOCK_METHOD0(send, void());
- Mutex lock;
- Cond cond;
+ ceph::mutex lock = ceph::make_mutex("lock");
+ ceph::condition_variable cond;
const SnapMap *snap_map = nullptr;
std::map<uint64_t, Context *> object_contexts;
- ObjectCopyRequest() : lock("lock") {
+ ObjectCopyRequest() {
s_instance = this;
}
};
bool complete_object_copy(MockObjectCopyRequest &mock_object_copy_request,
uint64_t object_num, Context **object_ctx, int r) {
- Mutex::Locker locker(mock_object_copy_request.lock);
+ std::unique_lock locker{mock_object_copy_request.lock};
while (mock_object_copy_request.object_contexts.count(object_num) == 0) {
- if (mock_object_copy_request.cond.WaitInterval(mock_object_copy_request.lock,
- utime_t(10, 0)) != 0) {
+ if (mock_object_copy_request.cond.wait_for(locker, 10s) ==
+ std::cv_status::timeout) {
return false;
}
}
}
SnapMap wait_for_snap_map(MockObjectCopyRequest &mock_object_copy_request) {
- Mutex::Locker locker(mock_object_copy_request.lock);
+ std::unique_lock locker{mock_object_copy_request.lock};
while (mock_object_copy_request.snap_map == nullptr) {
- if (mock_object_copy_request.cond.WaitInterval(mock_object_copy_request.lock,
- utime_t(10, 0)) != 0) {
+ if (mock_object_copy_request.cond.wait_for(locker, 10s) ==
+ std::cv_status::timeout) {
return SnapMap();
}
}
Return(true)));
} else {
expect.WillOnce(DoAll(WithArg<7>(Invoke([&mock_image_ctx, snap_id, state](Context *ctx) {
- ceph_assert(mock_image_ctx.image_ctx->image_lock.is_locked());
+ ceph_assert(ceph_mutex_is_locked(mock_image_ctx.image_ctx->image_lock));
mock_image_ctx.image_ctx->object_map->aio_update<Context>(
snap_id, 0, 1, state, boost::none, {}, false, ctx);
})),
}
void expect_test_features(MockTestImageCtx &mock_image_ctx, uint64_t features,
- RWLock &lock, bool enabled) {
+ ceph::shared_mutex &lock, bool enabled) {
EXPECT_CALL(mock_image_ctx, test_features(features, _))
.WillOnce(Return(enabled));
}
librbd::ImageCtx *ictx;
ASSERT_EQ(0, open_image(m_image_name, &ictx));
- ictx->image_lock.get_write();
+ ictx->image_lock.lock();
ictx->add_snap(cls::rbd::UserSnapshotNamespace(), "2", 2, ictx->size,
ictx->parent_md, RBD_PROTECTION_STATUS_UNPROTECTED,
0, {});
ictx->parent_md, RBD_PROTECTION_STATUS_UNPROTECTED,
0, {});
ictx->snapc = {2, {2, 1}};
- ictx->image_lock.put_write();
+ ictx->image_lock.unlock();
MockTestImageCtx mock_parent_image_ctx(*ictx->parent);
MockTestImageCtx mock_image_ctx(*ictx, &mock_parent_image_ctx);
librbd::ImageCtx *ictx;
ASSERT_EQ(0, open_image(m_image_name, &ictx));
- ictx->image_lock.get_write();
+ ictx->image_lock.lock();
ictx->add_snap(cls::rbd::UserSnapshotNamespace(), "1", 1, ictx->size,
ictx->parent_md, RBD_PROTECTION_STATUS_UNPROTECTED,
0, {});
ictx->snapc = {1, {1}};
- ictx->image_lock.put_write();
+ ictx->image_lock.unlock();
MockTestImageCtx mock_parent_image_ctx(*ictx->parent);
MockTestImageCtx mock_image_ctx(*ictx, &mock_parent_image_ctx);
librbd::ImageCtx *ictx;
ASSERT_EQ(0, open_image(m_image_name, &ictx));
- ictx->image_lock.get_write();
+ ictx->image_lock.lock();
ictx->add_snap(cls::rbd::UserSnapshotNamespace(), "3", 3, ictx->size,
ictx->parent_md, RBD_PROTECTION_STATUS_UNPROTECTED,
0, {});
ictx->parent_md, RBD_PROTECTION_STATUS_UNPROTECTED,
0, {});
ictx->snapc = {3, {3, 2, 1}};
- ictx->image_lock.put_write();
+ ictx->image_lock.unlock();
MockTestImageCtx mock_parent_image_ctx(*ictx->parent);
MockTestImageCtx mock_image_ctx(*ictx, &mock_parent_image_ctx);
librbd::ImageCtx *ictx;
ASSERT_EQ(0, open_image(m_image_name, &ictx));
- ictx->image_lock.get_write();
+ ictx->image_lock.lock();
ictx->add_snap(cls::rbd::UserSnapshotNamespace(), "4", 4, ictx->size,
ictx->parent_md, RBD_PROTECTION_STATUS_UNPROTECTED,
0, {});
ictx->parent_md, RBD_PROTECTION_STATUS_UNPROTECTED,
0, {});
ictx->snapc = {4, {4, 3, 2, 1}};
- ictx->image_lock.put_write();
+ ictx->image_lock.unlock();
MockTestImageCtx mock_parent_image_ctx(*ictx->parent);
MockTestImageCtx mock_image_ctx(*ictx, &mock_parent_image_ctx);
librbd::ImageCtx *ictx;
ASSERT_EQ(0, open_image(m_image_name, &ictx));
- ictx->image_lock.get_write();
+ ictx->image_lock.lock();
ictx->add_snap(cls::rbd::UserSnapshotNamespace(), "1", 1, ictx->size,
ictx->parent_md, RBD_PROTECTION_STATUS_UNPROTECTED,
0, {});
ictx->snapc = {1, {1}};
- ictx->image_lock.put_write();
+ ictx->image_lock.unlock();
MockTestImageCtx mock_parent_image_ctx(*ictx->parent);
MockTestImageCtx mock_image_ctx(*ictx, &mock_parent_image_ctx);
MockImageWriteRequest mock_aio_image_write_1(mock_image_ctx, aio_comp_1,
{{0, 1}}, std::move(bl), 0, {});
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_aio_image_write_1.send();
}
ASSERT_EQ(0, aio_comp_ctx_1.wait());
MockImageWriteRequest mock_aio_image_write_2(mock_image_ctx, aio_comp_2,
{{0, 1}}, std::move(bl), 0, {});
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_aio_image_write_2.send();
}
ASSERT_EQ(0, aio_comp_ctx_2.wait());
MockImageReadRequest mock_aio_image_read_1(mock_image_ctx, aio_comp_1,
{{0, 1}}, std::move(rr), 0, {});
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_aio_image_read_1.send();
}
ASSERT_EQ(1, aio_comp_ctx_1.wait());
MockImageReadRequest mock_aio_image_read_2(mock_image_ctx, aio_comp_2,
{{0, 1}}, std::move(rr), 0, {});
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_aio_image_read_2.send();
}
ASSERT_EQ(1, aio_comp_ctx_2.wait());
mock_image_ctx, aio_comp, {{16, 63}, {84, 100}},
ictx->discard_granularity_bytes, {});
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_aio_image_discard.send();
}
ASSERT_EQ(0, aio_comp_ctx.wait());
{{ictx->layout.object_size - 1024, 1024}},
ictx->discard_granularity_bytes, {});
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_aio_image_discard.send();
}
ASSERT_EQ(0, aio_comp_ctx.wait());
{{16, 63}, {96, 31}, {84, 100}, {ictx->layout.object_size - 33, 33}},
ictx->discard_granularity_bytes, {});
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_aio_image_discard.send();
}
ASSERT_EQ(0, aio_comp_ctx.wait());
MockImageWriteRequest mock_aio_image_write(mock_image_ctx, aio_comp,
{{0, 1}}, std::move(bl), 0, {});
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_aio_image_write.send();
}
ASSERT_EQ(0, aio_comp_ctx.wait());
MockImageDiscardRequest mock_aio_image_discard(
mock_image_ctx, aio_comp, {{0, 1}}, ictx->discard_granularity_bytes, {});
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_aio_image_discard.send();
}
ASSERT_EQ(0, aio_comp_ctx.wait());
MockImageFlushRequest mock_aio_image_flush(mock_image_ctx, aio_comp,
FLUSH_SOURCE_USER, {});
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_aio_image_flush.send();
}
ASSERT_EQ(0, aio_comp_ctx.wait());
{{0, 1}}, std::move(bl), 0,
{});
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_aio_image_writesame.send();
}
ASSERT_EQ(0, aio_comp_ctx.wait());
&mismatch_offset,
0, {});
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_aio_image_write.send();
}
ASSERT_EQ(0, aio_comp_ctx.wait());
typedef librbd::io::ImageDispatchSpec<librbd::MockTestImageCtx> ImageDispatchSpec;
static PointerWQ* s_instance;
- Mutex m_lock;
+ ceph::mutex m_lock;
PointerWQ(const std::string &name, time_t, int, ThreadPool *)
- : m_lock(name) {
+ : m_lock(ceph::make_mutex(name)) {
s_instance = this;
}
virtual ~PointerWQ() {
void register_work_queue() {
// no-op
}
- Mutex &get_pool_lock() {
+ ceph::mutex &get_pool_lock() {
return m_lock;
}
void* invoke_dequeue() {
- Mutex::Locker locker(m_lock);
+ std::lock_guard locker{m_lock};
return _void_dequeue();
}
void invoke_process(ImageDispatchSpec *image_request) {
typedef SimpleSchedulerObjectDispatch<librbd::MockTestImageCtx> MockSimpleSchedulerObjectDispatch;
MockSafeTimer m_mock_timer;
- Mutex m_mock_timer_lock;
+ ceph::mutex m_mock_timer_lock =
+ ceph::make_mutex("TestMockIoSimpleSchedulerObjectDispatch::Mutex");
- TestMockIoSimpleSchedulerObjectDispatch()
- : m_mock_timer_lock("TestMockIoSimpleSchedulerObjectDispatch::Mutex") {
+ TestMockIoSimpleSchedulerObjectDispatch() {
MockTestImageCtx::set_timer_instance(&m_mock_timer, &m_mock_timer_lock);
EXPECT_EQ(0, _rados.conf_set("rbd_io_scheduler_simple_max_delay", "1"));
}
void expect_add_timer_task(Context **timer_task) {
EXPECT_CALL(m_mock_timer, add_event_at(_, _))
- .WillOnce(Invoke([timer_task](utime_t, Context *task) {
+ .WillOnce(Invoke([timer_task](ceph::real_clock::time_point, Context *task) {
*timer_task = task;
return task;
}));
}
void run_timer_task(Context *timer_task) {
- Mutex::Locker timer_locker(m_mock_timer_lock);
+ std::lock_guard timer_locker{m_mock_timer_lock};
timer_task->complete(0);
}
};
typedef std::list<journal::Journaler *> Journalers;
struct ReplayHandler : public journal::ReplayHandler {
- Mutex lock;
- Cond cond;
+ ceph::mutex lock = ceph::make_mutex("ReplayHandler::lock");
+ ceph::condition_variable cond;
bool entries_available;
bool complete;
ReplayHandler()
- : lock("ReplayHandler::lock"), entries_available(false), complete(false) {
+ : entries_available(false), complete(false) {
}
void get() override {
}
void handle_entries_available() override {
- Mutex::Locker locker(lock);
+ std::lock_guard locker{lock};
entries_available = true;
- cond.Signal();
+ cond.notify_all();
}
void handle_complete(int r) override {
- Mutex::Locker locker(lock);
+ std::lock_guard locker{lock};
complete = true;
- cond.Signal();
+ cond.notify_all();
}
};
}
bool wait_for_entries_available(librbd::ImageCtx *ictx) {
- Mutex::Locker locker(m_replay_handler.lock);
+ std::unique_lock locker{m_replay_handler.lock};
while (!m_replay_handler.entries_available) {
- if (m_replay_handler.cond.WaitInterval(m_replay_handler.lock,
- utime_t(10, 0)) != 0) {
+ if (m_replay_handler.cond.wait_for(locker, 10s) == std::cv_status::timeout) {
return false;
}
}
int when_acquired_lock(librbd::ImageCtx *ictx) {
C_SaferCond lock_ctx;
{
- RWLock::WLocker owner_locker(ictx->owner_lock);
+ std::unique_lock owner_locker{ictx->owner_lock};
ictx->exclusive_lock->acquire_lock(&lock_ctx);
}
int r = lock_ctx.wait();
C_SaferCond ctx;
librbd::journal::EventEntry event_entry(event);
{
- RWLock::RLocker owner_locker(ictx->owner_lock);
+ std::shared_lock owner_locker{ictx->owner_lock};
uint64_t tid = ictx->journal->append_io_event(std::move(event_entry),0, 0,
true, 0);
ictx->journal->wait_event(tid, &ctx);
ASSERT_EQ(1, current_entry);
{
- RWLock::RLocker image_locker(ictx->image_lock);
+ std::shared_lock image_locker{ictx->image_lock};
ASSERT_NE(CEPH_NOSNAP, ictx->get_snap_id(cls::rbd::UserSnapshotNamespace(),
"snap"));
}
"snap"));
uint64_t snap_id;
{
- RWLock::RLocker image_locker(ictx->image_lock);
+ std::shared_lock image_locker{ictx->image_lock};
snap_id = ictx->get_snap_id(cls::rbd::UserSnapshotNamespace(), "snap");
ASSERT_NE(CEPH_NOSNAP, snap_id);
}
"snap"));
uint64_t snap_id;
{
- RWLock::RLocker image_locker(ictx->image_lock);
+ std::shared_lock image_locker{ictx->image_lock};
snap_id = ictx->get_snap_id(cls::rbd::UserSnapshotNamespace(), "snap");
ASSERT_NE(CEPH_NOSNAP, snap_id);
}
ASSERT_EQ(0, ictx->state->refresh());
{
- RWLock::RLocker image_locker(ictx->image_lock);
+ std::shared_lock image_locker{ictx->image_lock};
snap_id = ictx->get_snap_id(cls::rbd::UserSnapshotNamespace(), "snap2");
ASSERT_NE(CEPH_NOSNAP, snap_id);
}
ASSERT_EQ(initial_entry + 2, current_entry);
{
- RWLock::RLocker image_locker(ictx->image_lock);
+ std::shared_lock image_locker{ictx->image_lock};
uint64_t snap_id = ictx->get_snap_id(cls::rbd::UserSnapshotNamespace(),
"snap");
ASSERT_EQ(CEPH_NOSNAP, snap_id);
#include "test/librbd/test_support.h"
#include "test/librbd/mock/MockImageCtx.h"
#include "test/journal/mock/MockJournaler.h"
-#include "common/Mutex.h"
+#include "common/ceph_mutex.h"
#include "cls/journal/cls_journal_types.h"
#include "librbd/journal/OpenRequest.h"
#include "librbd/journal/Types.h"
public:
typedef OpenRequest<MockTestImageCtx> MockOpenRequest;
- TestMockJournalOpenRequest() : m_lock("m_lock") {
- }
+ TestMockJournalOpenRequest() = default;
void expect_init_journaler(::journal::MockJournaler &mock_journaler, int r) {
EXPECT_CALL(mock_journaler, init(_))
WithArg<2>(CompleteContext(r, mock_image_ctx.image_ctx->op_work_queue))));
}
- Mutex m_lock;
+ ceph::mutex m_lock = ceph::make_mutex("m_lock");
ImageClientMeta m_client_meta;
uint64_t m_tag_tid = 0;
TagData m_tag_data;
static OpenRequest *s_instance;
static OpenRequest *create(MockTestImageCtx *image_ctx,
::journal::MockJournalerProxy *journaler,
- Mutex *lock, ImageClientMeta *client_meta,
+ ceph::mutex *lock, ImageClientMeta *client_meta,
uint64_t *tag_tid, journal::TagData *tag_data,
Context *on_finish) {
ceph_assert(s_instance != nullptr);
}
ACTION_P2(NotifyInvoke, lock, cond) {
- Mutex::Locker locker(*lock);
- cond->Signal();
+ std::lock_guard locker{*lock};
+ cond->notify_all();
}
ACTION_P2(CompleteAioCompletion, r, image_ctx) {
typedef io::ImageRequest<MockReplayImageCtx> MockIoImageRequest;
typedef Replay<MockReplayImageCtx> MockJournalReplay;
- TestMockJournalReplay() : m_invoke_lock("m_invoke_lock") {
- }
+ TestMockJournalReplay() = default;
void expect_accept_ops(MockExclusiveLock &mock_exclusive_lock, bool accept) {
EXPECT_CALL(mock_exclusive_lock, accept_ops()).WillRepeatedly(
void wait_for_op_invoked(Context **on_finish, int r) {
{
- Mutex::Locker locker(m_invoke_lock);
- while (*on_finish == nullptr) {
- m_invoke_cond.Wait(m_invoke_lock);
- }
+ std::unique_lock locker{m_invoke_lock};
+ m_invoke_cond.wait(locker, [on_finish] { return *on_finish != nullptr; });
}
(*on_finish)->complete(r);
}
return bl;
}
- Mutex m_invoke_lock;
- Cond m_invoke_cond;
+ ceph::mutex m_invoke_lock = ceph::make_mutex("m_invoke_lock");
+ ceph::condition_variable m_invoke_cond;
};
TEST_F(TestMockJournalReplay, AioDiscard) {
#include "test/librbd/test_support.h"
#include "test/librbd/mock/MockImageCtx.h"
#include "test/journal/mock/MockJournaler.h"
-#include "common/Mutex.h"
#include "cls/journal/cls_journal_types.h"
#include "librbd/journal/CreateRequest.h"
#include "librbd/journal/RemoveRequest.h"
#include "test/librbd/mock/MockOperations.h"
#include "test/librados_test_stub/MockTestMemIoCtxImpl.h"
#include "test/librados_test_stub/MockTestMemRadosClient.h"
-#include "common/Mutex.h"
#include "librbd/MirroringWatcher.h"
#include "librbd/journal/PromoteRequest.h"
#include "librbd/mirror/DisableRequest.h"
#include "test/librbd/mock/MockSafeTimer.h"
static MockSafeTimer *s_timer;
-static Mutex *s_timer_lock;
+static ceph::mutex *s_timer_lock;
namespace librbd {
MockImageCtx* MockImageCtx::s_instance = nullptr;
void MockImageCtx::set_timer_instance(MockSafeTimer *timer,
- Mutex *timer_lock) {
+ ceph::mutex *timer_lock) {
s_timer = timer;
s_timer_lock = timer_lock;
}
void MockImageCtx::get_timer_instance(CephContext *cct, MockSafeTimer **timer,
- Mutex **timer_lock) {
+ ceph::mutex **timer_lock) {
*timer = s_timer;
*timer_lock = s_timer_lock;
}
}
void wait_for_async_requests() {
- async_ops_lock.Lock();
+ async_ops_lock.lock();
if (async_requests.empty()) {
- async_ops_lock.Unlock();
+ async_ops_lock.unlock();
return;
}
C_SaferCond ctx;
async_requests_waiters.push_back(&ctx);
- async_ops_lock.Unlock();
+ async_ops_lock.unlock();
ctx.wait();
}
MOCK_CONST_METHOD1(test_features, bool(uint64_t test_features));
MOCK_CONST_METHOD2(test_features, bool(uint64_t test_features,
- const RWLock &in_image_lock));
+ const ceph::shared_mutex &in_image_lock));
MOCK_CONST_METHOD1(test_op_features, bool(uint64_t op_features));
MOCK_CONST_METHOD0(get_stripe_count, uint64_t());
MOCK_CONST_METHOD0(get_stripe_period, uint64_t());
- static void set_timer_instance(MockSafeTimer *timer, Mutex *timer_lock);
+ static void set_timer_instance(MockSafeTimer *timer, ceph::mutex *timer_lock);
static void get_timer_instance(CephContext *cct, MockSafeTimer **timer,
- Mutex **timer_lock);
+ ceph::mutex **timer_lock);
ImageCtx *image_ctx;
CephContext *cct;
librados::IoCtx md_ctx;
librados::IoCtx data_ctx;
- RWLock &owner_lock;
- RWLock &image_lock;
- RWLock ×tamp_lock;
- Mutex &async_ops_lock;
- Mutex ©up_list_lock;
+ ceph::shared_mutex &owner_lock;
+ ceph::shared_mutex &image_lock;
+ ceph::shared_mutex ×tamp_lock;
+ ceph::mutex &async_ops_lock;
+ ceph::mutex ©up_list_lock;
uint8_t order;
uint64_t size;
}
MOCK_METHOD2(add_event_after, Context*(double, Context *));
- MOCK_METHOD2(add_event_at, Context*(utime_t, Context *));
+ MOCK_METHOD2(add_event_at, Context*(ceph::real_clock::time_point, Context *));
MOCK_METHOD1(cancel_event, bool(Context *));
};
.Times(0);
{
- RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker image_locker(ictx->image_lock);
+ std::shared_lock owner_locker{ictx->owner_lock};
+ std::unique_lock image_locker{ictx->image_lock};
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
.WillOnce(DoDefault());
{
- RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker image_locker(ictx->image_lock);
+ std::shared_lock owner_locker{ictx->owner_lock};
+ std::unique_lock image_locker{ictx->image_lock};
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
.WillOnce(DoDefault());
{
- RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker image_locker(ictx->image_lock);
+ std::shared_lock owner_locker{ictx->owner_lock};
+ std::unique_lock image_locker{ictx->image_lock};
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
.Times(0);
{
- RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker image_locker(ictx->image_lock);
+ std::shared_lock owner_locker{ictx->owner_lock};
+ std::unique_lock image_locker{ictx->image_lock};
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
.WillOnce(Return(-EINVAL));
{
- RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker image_locker(ictx->image_lock);
+ std::shared_lock owner_locker{ictx->owner_lock};
+ std::unique_lock image_locker{ictx->image_lock};
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
init_object_map(mock_image_ctx, &on_disk_object_map);
C_SaferCond ctx;
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
MockLockRequest mock_lock_request;
MockRefreshRequest *req = new MockRefreshRequest(
init_object_map(mock_image_ctx, &on_disk_object_map);
C_SaferCond ctx;
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
MockRefreshRequest *req = new MockRefreshRequest(
mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);
init_object_map(mock_image_ctx, &on_disk_object_map);
C_SaferCond ctx;
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
MockRefreshRequest *req = new MockRefreshRequest(
mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);
init_object_map(mock_image_ctx, &on_disk_object_map);
C_SaferCond ctx;
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
MockRefreshRequest *req = new MockRefreshRequest(
mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);
init_object_map(mock_image_ctx, &on_disk_object_map);
C_SaferCond ctx;
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
MockRefreshRequest *req = new MockRefreshRequest(
mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);
ceph::BitVector<2> small_object_map;
C_SaferCond ctx;
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
MockRefreshRequest *req = new MockRefreshRequest(
mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);
ceph::BitVector<2> small_object_map;
C_SaferCond ctx;
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
MockRefreshRequest *req = new MockRefreshRequest(
mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);
large_object_map.resize(on_disk_object_map.size() * 2);
C_SaferCond ctx;
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
MockRefreshRequest *req = new MockRefreshRequest(
mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);
ceph::BitVector<2> small_object_map;
C_SaferCond ctx;
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
MockRefreshRequest *req = new MockRefreshRequest(
mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);
init_object_map(mock_image_ctx, &on_disk_object_map);
C_SaferCond ctx;
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
MockRefreshRequest *req = new MockRefreshRequest(
mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);
ASSERT_EQ(0, open_image(m_image_name, &ictx));
ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
object_map.resize(1);
expect_resize(ictx, CEPH_NOSNAP, 0);
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
object_map.resize(1);
uint64_t snap_id = ictx->snap_id;
expect_resize(ictx, snap_id, 0);
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
object_map.resize(1);
expect_resize(ictx, CEPH_NOSNAP, -EINVAL);
expect_invalidate(ictx);
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
object_map.resize(1);
class TestMockObjectMapSnapshotCreateRequest : public TestMockFixture {
public:
void inject_snap_info(librbd::ImageCtx *ictx, uint64_t snap_id) {
- RWLock::WLocker image_locker(ictx->image_lock);
+ std::unique_lock image_locker{ictx->image_lock};
ictx->add_snap(cls::rbd::UserSnapshotNamespace(), "snap name", snap_id,
ictx->size, ictx->parent_md,
RBD_PROTECTION_STATUS_UNPROTECTED, 0, utime_t());
ASSERT_EQ(0, open_image(m_image_name, &ictx));
ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
uint64_t snap_id = 1;
AsyncRequest<> *request = new SnapshotCreateRequest(
*ictx, &object_map_lock, &object_map, snap_id, &cond_ctx);
{
- RWLock::RLocker image_locker(ictx->image_lock);
+ std::shared_lock image_locker{ictx->image_lock};
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
ASSERT_EQ(0, open_image(m_image_name, &ictx));
ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
uint64_t snap_id = 1;
AsyncRequest<> *request = new SnapshotCreateRequest(
*ictx, &object_map_lock, &object_map, snap_id, &cond_ctx);
{
- RWLock::RLocker image_locker(ictx->image_lock);
+ std::shared_lock image_locker{ictx->image_lock};
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
ASSERT_EQ(0, open_image(m_image_name, &ictx));
ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
uint64_t snap_id = 1;
AsyncRequest<> *request = new SnapshotCreateRequest(
*ictx, &object_map_lock, &object_map, snap_id, &cond_ctx);
{
- RWLock::RLocker image_locker(ictx->image_lock);
+ std::shared_lock image_locker{ictx->image_lock};
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
ASSERT_EQ(0, open_image(m_image_name, &ictx));
ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
uint64_t snap_id = 1;
AsyncRequest<> *request = new SnapshotCreateRequest(
*ictx, &object_map_lock, &object_map, snap_id, &cond_ctx);
{
- RWLock::RLocker image_locker(ictx->image_lock);
+ std::shared_lock image_locker{ictx->image_lock};
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
ASSERT_EQ(0, open_image(m_image_name, &ictx));
ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
object_map.resize(1024);
for (uint64_t i = 0; i < object_map.size(); ++i) {
AsyncRequest<> *request = new SnapshotCreateRequest(
*ictx, &object_map_lock, &object_map, snap_id, &cond_ctx);
{
- RWLock::RLocker image_locker(ictx->image_lock);
+ std::shared_lock image_locker{ictx->image_lock};
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
}
expect_remove_map(ictx, snap_id, 0);
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
C_SaferCond cond_ctx;
AsyncRequest<> *request = new SnapshotRemoveRequest(
*ictx, &object_map_lock, &object_map, snap_id, &cond_ctx);
{
- RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker image_locker(ictx->image_lock);
+ std::shared_lock owner_locker{ictx->owner_lock};
+ std::unique_lock image_locker{ictx->image_lock};
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
expect_load_map(ictx, snap_id, -ENOENT);
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
C_SaferCond cond_ctx;
AsyncRequest<> *request = new SnapshotRemoveRequest(
*ictx, &object_map_lock, &object_map, snap_id, &cond_ctx);
{
- RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker image_locker(ictx->image_lock);
+ std::shared_lock owner_locker{ictx->owner_lock};
+ std::unique_lock image_locker{ictx->image_lock};
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
{
// shouldn't invalidate the HEAD revision when we fail to load
// the already deleted snapshot
- RWLock::RLocker image_locker(ictx->image_lock);
+ std::shared_lock image_locker{ictx->image_lock};
uint64_t flags;
ASSERT_EQ(0, ictx->get_flags(CEPH_NOSNAP, &flags));
ASSERT_EQ(0U, flags & RBD_FLAG_OBJECT_MAP_INVALID);
expect_invalidate(ictx);
expect_remove_map(ictx, snap_id, 0);
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
C_SaferCond cond_ctx;
AsyncRequest<> *request = new SnapshotRemoveRequest(
*ictx, &object_map_lock, &object_map, snap_id, &cond_ctx);
{
- RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker image_locker(ictx->image_lock);
+ std::shared_lock owner_locker{ictx->owner_lock};
+ std::unique_lock image_locker{ictx->image_lock};
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
expect_remove_snapshot(ictx, -ENOENT);
expect_remove_map(ictx, snap_id, 0);
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
C_SaferCond cond_ctx;
AsyncRequest<> *request = new SnapshotRemoveRequest(
*ictx, &object_map_lock, &object_map, snap_id, &cond_ctx);
{
- RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker image_locker(ictx->image_lock);
+ std::shared_lock owner_locker{ictx->owner_lock};
+ std::unique_lock image_locker{ictx->image_lock};
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
expect_invalidate(ictx);
expect_remove_map(ictx, snap_id, 0);
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
C_SaferCond cond_ctx;
AsyncRequest<> *request = new SnapshotRemoveRequest(
*ictx, &object_map_lock, &object_map, snap_id, &cond_ctx);
{
- RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker image_locker(ictx->image_lock);
+ std::shared_lock owner_locker{ictx->owner_lock};
+ std::unique_lock image_locker{ictx->image_lock};
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
}
expect_remove_map(ictx, snap_id, -ENOENT);
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
C_SaferCond cond_ctx;
AsyncRequest<> *request = new SnapshotRemoveRequest(
*ictx, &object_map_lock, &object_map, snap_id, &cond_ctx);
{
- RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker image_locker(ictx->image_lock);
+ std::shared_lock owner_locker{ictx->owner_lock};
+ std::unique_lock image_locker{ictx->image_lock};
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
}
expect_remove_map(ictx, snap_id, -EINVAL);
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
C_SaferCond cond_ctx;
AsyncRequest<> *request = new SnapshotRemoveRequest(
*ictx, &object_map_lock, &object_map, snap_id, &cond_ctx);
{
- RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker image_locker(ictx->image_lock);
+ std::shared_lock owner_locker{ictx->owner_lock};
+ std::unique_lock image_locker{ictx->image_lock};
request->send();
}
ASSERT_EQ(-EINVAL, cond_ctx.wait());
ASSERT_EQ(0, resize(ictx, size));
// update image objectmap for snap inherit
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
object_map.resize(1024);
for (uint64_t i = 512; i < object_map.size(); ++i) {
C_SaferCond cond_ctx1;
{
librbd::ObjectMap om(*ictx, ictx->snap_id);
- RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker image_locker(ictx->image_lock);
+ std::shared_lock owner_locker{ictx->owner_lock};
+ std::unique_lock image_locker{ictx->image_lock};
om.set_object_map(object_map);
om.aio_save(&cond_ctx1);
}
AsyncRequest<> *request = new SnapshotRemoveRequest(
*ictx, &object_map_lock, &object_map, snap_id, &cond_ctx2);
{
- RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker image_locker(ictx->image_lock);
+ std::shared_lock owner_locker{ictx->owner_lock};
+ std::unique_lock image_locker{ictx->image_lock};
request->send();
}
ASSERT_EQ(0, cond_ctx2.wait());
ASSERT_EQ(0, cond_ctx.wait());
{
- RWLock::RLocker image_locker(ictx->image_lock);
+ std::shared_lock image_locker{ictx->image_lock};
uint64_t flags;
ASSERT_EQ(0, ictx->get_flags(snap_id, &flags));
ASSERT_NE(0U, flags & RBD_FLAG_OBJECT_MAP_INVALID);
ASSERT_EQ(0, cond_ctx.wait());
{
- RWLock::RLocker image_locker(ictx->image_lock);
+ std::shared_lock image_locker{ictx->image_lock};
uint64_t flags;
ASSERT_EQ(0, ictx->get_flags(snap_id, &flags));
ASSERT_EQ(0U, flags & RBD_FLAG_OBJECT_MAP_INVALID);
ASSERT_EQ(0, ictx->operations->resize(4 << ictx->order, true, no_progress));
ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
object_map.resize(4);
for (uint64_t i = 0; i < object_map.size(); ++i) {
*ictx, &object_map_lock, &object_map, CEPH_NOSNAP, 0, object_map.size(),
OBJECT_NONEXISTENT, OBJECT_EXISTS, {}, false, &cond_ctx);
{
- RWLock::RLocker image_locker(ictx->image_lock);
- RWLock::WLocker object_map_locker(object_map_lock);
+ std::shared_lock image_locker{ictx->image_lock};
+ std::unique_lock object_map_locker{object_map_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
expect_update(ictx, CEPH_NOSNAP, 0, 1, OBJECT_NONEXISTENT, OBJECT_EXISTS, 0);
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock =
+ ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
object_map.resize(1);
*ictx, &object_map_lock, &object_map, CEPH_NOSNAP, 0, object_map.size(),
OBJECT_NONEXISTENT, OBJECT_EXISTS, {}, false, &cond_ctx);
{
- RWLock::RLocker image_locker(ictx->image_lock);
- RWLock::WLocker object_map_locker(object_map_lock);
+ std::shared_lock image_locker{ictx->image_lock};
+ std::unique_lock object_map_locker{object_map_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
uint64_t snap_id = ictx->snap_id;
expect_update(ictx, snap_id, 0, 1, OBJECT_NONEXISTENT, OBJECT_EXISTS, 0);
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock =
+ ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
object_map.resize(1);
*ictx, &object_map_lock, &object_map, snap_id, 0, object_map.size(),
OBJECT_NONEXISTENT, OBJECT_EXISTS, {}, false, &cond_ctx);
{
- RWLock::RLocker image_locker(ictx->image_lock);
- RWLock::WLocker object_map_locker(object_map_lock);
+ std::shared_lock image_locker{ictx->image_lock};
+ std::unique_lock object_map_locker{object_map_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
-EINVAL);
expect_invalidate(ictx);
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
object_map.resize(1);
*ictx, &object_map_lock, &object_map, CEPH_NOSNAP, 0, object_map.size(),
OBJECT_NONEXISTENT, OBJECT_EXISTS, {}, false, &cond_ctx);
{
- RWLock::RLocker image_locker(ictx->image_lock);
- RWLock::WLocker object_map_locker(object_map_lock);
+ std::shared_lock image_locker{ictx->image_lock};
+ std::unique_lock object_map_locker{object_map_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
boost::optional<uint8_t>(), 0);
expect_unlock_exclusive_lock(*ictx);
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
object_map.resize(1);
*ictx, &object_map_lock, &object_map, snap_id, 0, object_map.size(),
OBJECT_EXISTS_CLEAN, boost::optional<uint8_t>(), {}, false, &cond_ctx);
{
- RWLock::RLocker image_locker(ictx->image_lock);
- RWLock::WLocker object_map_locker(object_map_lock);
+ std::shared_lock image_locker{ictx->image_lock};
+ std::unique_lock object_map_locker{object_map_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
OBJECT_EXISTS, 0);
expect_unlock_exclusive_lock(*ictx);
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
object_map.resize(712312);
*ictx, &object_map_lock, &object_map, CEPH_NOSNAP, 0, object_map.size(),
OBJECT_NONEXISTENT, OBJECT_EXISTS, {}, false, &cond_ctx);
{
- RWLock::RLocker image_locker(ictx->image_lock);
- RWLock::WLocker object_map_locker(object_map_lock);
+ std::shared_lock image_locker{ictx->image_lock};
+ std::unique_lock object_map_locker{object_map_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
expect_update(ictx, CEPH_NOSNAP, 0, 1, OBJECT_NONEXISTENT, OBJECT_EXISTS,
-ENOENT);
- RWLock object_map_lock("lock");
+ ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
ceph::BitVector<2> object_map;
object_map.resize(1);
*ictx, &object_map_lock, &object_map, CEPH_NOSNAP, 0, object_map.size(),
OBJECT_NONEXISTENT, OBJECT_EXISTS, {}, true, &cond_ctx);
{
- RWLock::RLocker image_locker(ictx->image_lock);
- RWLock::WLocker object_map_locker(object_map_lock);
+ std::shared_lock image_locker{ictx->image_lock};
+ std::unique_lock object_map_locker{object_map_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
MockDisableFeaturesRequest *req = new MockDisableFeaturesRequest(
mock_image_ctx, &cond_ctx, 0, features_to_disable, false);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
mock_image_ctx, &cond_ctx, 0,
RBD_FEATURE_OBJECT_MAP | RBD_FEATURE_FAST_DIFF, false);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
mock_image_ctx, &cond_ctx, 0,
RBD_FEATURE_OBJECT_MAP | RBD_FEATURE_FAST_DIFF, false);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EINVAL, cond_ctx.wait());
MockDisableFeaturesRequest *req = new MockDisableFeaturesRequest(
mock_image_ctx, &cond_ctx, 0, RBD_FEATURE_JOURNALING, false);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
MockDisableFeaturesRequest *req = new MockDisableFeaturesRequest(
mock_image_ctx, &cond_ctx, 0, RBD_FEATURE_JOURNALING, false);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
MockEnableFeaturesRequest *req = new MockEnableFeaturesRequest(
mock_image_ctx, &cond_ctx, 0, features_to_enable);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
MockEnableFeaturesRequest *req = new MockEnableFeaturesRequest(
mock_image_ctx, &cond_ctx, 0, RBD_FEATURE_OBJECT_MAP);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
MockEnableFeaturesRequest *req = new MockEnableFeaturesRequest(
mock_image_ctx, &cond_ctx, 0, RBD_FEATURE_OBJECT_MAP);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EINVAL, cond_ctx.wait());
MockEnableFeaturesRequest *req = new MockEnableFeaturesRequest(
mock_image_ctx, &cond_ctx, 0, RBD_FEATURE_OBJECT_MAP);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EINVAL, cond_ctx.wait());
MockEnableFeaturesRequest *req = new MockEnableFeaturesRequest(
mock_image_ctx, &cond_ctx, 0, RBD_FEATURE_JOURNALING);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
MockEnableFeaturesRequest *req = new MockEnableFeaturesRequest(
mock_image_ctx, &cond_ctx, 0, RBD_FEATURE_JOURNALING);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EINVAL, cond_ctx.wait());
MockEnableFeaturesRequest *req = new MockEnableFeaturesRequest(
mock_image_ctx, &cond_ctx, 0, RBD_FEATURE_JOURNALING);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
expect_send_op(*mock_request, 0);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_request->send();
}
expect_is_journal_appending(mock_journal, false);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_request->send();
}
mock_image_ctx, &cond_ctx, new_size, allow_shrink, prog_ctx,
journal_op_tid, disable_journal);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
return cond_ctx.wait();
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(),
"snap1", 0, false);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(),
"snap1", 0, false);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EINVAL, cond_ctx.wait());
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(),
"snap1", 0, false);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(),
"snap1", 0, false);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EINVAL, cond_ctx.wait());
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(),
"snap1", 0, false);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EINVAL, cond_ctx.wait());
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(),
"snap1", 0, true);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
MockSnapshotProtectRequest *req = new MockSnapshotProtectRequest(
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1");
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
MockSnapshotProtectRequest *req = new MockSnapshotProtectRequest(
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1");
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-ENOENT, cond_ctx.wait());
MockSnapshotProtectRequest *req = new MockSnapshotProtectRequest(
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1");
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EINVAL, cond_ctx.wait());
MockSnapshotProtectRequest *req = new MockSnapshotProtectRequest(
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1");
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EBUSY, cond_ctx.wait());
MockSnapshotProtectRequest *req = new MockSnapshotProtectRequest(
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1");
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EINVAL, cond_ctx.wait());
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1",
snap_id);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1",
snap_id);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1",
snap_id);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1",
snap_id);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
mock_image_ctx, &cond_ctx, cls::rbd::TrashSnapshotNamespace{}, "snap1",
snap_id);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EBUSY, cond_ctx.wait());
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1",
snap_id);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1",
snap_id);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EINVAL, cond_ctx.wait());
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1",
snap_id);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EOPNOTSUPP, cond_ctx.wait());
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1",
snap_id);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EINVAL, cond_ctx.wait());
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1",
snap_id);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-ENOENT, cond_ctx.wait());
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1",
snap_id);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EINVAL, cond_ctx.wait());
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1",
snap_id);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-ENOENT, cond_ctx.wait());
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1",
snap_id);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-ENOENT, cond_ctx.wait());
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), snap_name,
snap_id, snap_size, prog_ctx);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
return cond_ctx.wait();
MockSnapshotUnprotectRequest *req = new MockSnapshotUnprotectRequest(
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1");
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
MockSnapshotUnprotectRequest *req = new MockSnapshotUnprotectRequest(
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1");
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-ENOENT, cond_ctx.wait());
MockSnapshotUnprotectRequest *req = new MockSnapshotUnprotectRequest(
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1");
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EBADMSG, cond_ctx.wait());
MockSnapshotUnprotectRequest *req = new MockSnapshotUnprotectRequest(
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1");
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EINVAL, cond_ctx.wait());
MockSnapshotUnprotectRequest *req = new MockSnapshotUnprotectRequest(
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1");
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EINVAL, cond_ctx.wait());
MockSnapshotUnprotectRequest *req = new MockSnapshotUnprotectRequest(
mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1");
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EBUSY, cond_ctx.wait());
MockTrimRequest *req = new MockTrimRequest(
mock_image_ctx, &cond_ctx, m_image_size, 0, progress_ctx);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
MockTrimRequest *req = new MockTrimRequest(
mock_image_ctx, &cond_ctx, 2 * ictx->get_object_size(), 0, progress_ctx);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
MockTrimRequest *req = new MockTrimRequest(
mock_image_ctx, &cond_ctx, ictx->get_object_size(), 1, progress_ctx);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(0, cond_ctx.wait());
MockTrimRequest *req = new MockTrimRequest(
mock_image_ctx, &cond_ctx, m_image_size, 0, progress_ctx);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EPERM, cond_ctx.wait());
MockTrimRequest *req = new MockTrimRequest(
mock_image_ctx, &cond_ctx, 2 * ictx->get_object_size(), 0, progress_ctx);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EINVAL, cond_ctx.wait());
MockTrimRequest *req = new MockTrimRequest(
mock_image_ctx, &cond_ctx, ictx->get_object_size(), 1, progress_ctx);
{
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
req->send();
}
ASSERT_EQ(-EINVAL, cond_ctx.wait());
dst_snap_name));
uint64_t src_size, dst_size;
{
- RWLock::RLocker src_locker(m_src_ictx->image_lock);
- RWLock::RLocker dst_locker(m_dst_ictx->image_lock);
+ std::shared_lock src_locker{m_src_ictx->image_lock};
+ std::shared_lock dst_locker{m_dst_ictx->image_lock};
src_size = m_src_ictx->get_image_size(m_src_ictx->snap_id);
dst_size = m_dst_ictx->get_image_size(m_dst_ictx->snap_id);
}
if (m_dst_ictx->test_features(RBD_FEATURE_LAYERING)) {
bool flags_set;
- RWLock::RLocker dst_locker(m_dst_ictx->image_lock);
+ std::shared_lock dst_locker{m_dst_ictx->image_lock};
EXPECT_EQ(0, m_dst_ictx->test_flags(m_dst_ictx->snap_id,
RBD_FLAG_OBJECT_MAP_INVALID,
m_dst_ictx->image_lock, &flags_set));
void test_stress() {
uint64_t initial_size, size;
{
- RWLock::RLocker src_locker(m_src_ictx->image_lock);
+ std::shared_lock src_locker{m_src_ictx->image_lock};
size = initial_size = m_src_ictx->get_image_size(CEPH_NOSNAP);
}
std::cout << "resize: " << new_size << std::endl;
ASSERT_EQ(0, m_src_ictx->operations->resize(new_size, true, no_op));
{
- RWLock::RLocker src_locker(m_src_ictx->image_lock);
+ std::shared_lock src_locker{m_src_ictx->image_lock};
size = m_src_ictx->get_image_size(CEPH_NOSNAP);
}
ASSERT_EQ(new_size, size);
#include "include/rados/librados.h"
#include "include/rbd/librbd.hpp"
#include "common/Cond.h"
+#include "common/ceph_mutex.h"
#include "common/errno.h"
-#include "common/Mutex.h"
-#include "common/RWLock.h"
#include "cls/lock/cls_lock_client.h"
#include "cls/lock/cls_lock_types.h"
#include "librbd/internal.h"
class TestImageWatcher : public TestFixture {
public:
- TestImageWatcher() : m_watch_ctx(NULL), m_callback_lock("m_callback_lock")
+ TestImageWatcher() : m_watch_ctx(NULL)
{
}
<< ", " << cookie << ", " << notifier_id << std::endl;
*/
- Mutex::Locker l(m_parent.m_callback_lock);
+ std::lock_guard l{m_parent.m_callback_lock};
m_parent.m_notify_payloads[notify_op] = payload;
bufferlist reply;
if (m_parent.m_notify_acks.count(notify_op) > 0) {
reply = m_parent.m_notify_acks[notify_op];
m_parent.m_notifies += notify_op;
- m_parent.m_callback_cond.Signal();
+ m_parent.m_callback_cond.notify_all();
}
m_parent.m_ioctx.notify_ack(m_header_oid, notify_id, cookie, reply);
}
bool wait_for_notifies(librbd::ImageCtx &ictx) {
- Mutex::Locker l(m_callback_lock);
+ std::unique_lock l{m_callback_lock};
while (m_notifies.size() < m_notify_acks.size()) {
- int r = m_callback_cond.WaitInterval(m_callback_lock,
- utime_t(10, 0));
- if (r != 0) {
+ if (m_callback_cond.wait_for(l, 10s) == std::cv_status::timeout) {
break;
}
}
AsyncRequestId m_async_request_id;
- Mutex m_callback_lock;
- Cond m_callback_cond;
+ ceph::mutex m_callback_lock = ceph::make_mutex("m_callback_lock");
+ ceph::condition_variable m_callback_cond;
};
struct ProgressContext : public librbd::ProgressContext {
- Mutex mutex;
- Cond cond;
+ ceph::mutex mutex = ceph::make_mutex("ProgressContext::mutex");
+ ceph::condition_variable cond;
bool received;
uint64_t offset;
uint64_t total;
- ProgressContext() : mutex("ProgressContext::mutex"), received(false),
+ ProgressContext() : received(false),
offset(0), total(0) {}
int update_progress(uint64_t offset_, uint64_t total_) override {
- Mutex::Locker l(mutex);
+ std::lock_guard l{mutex};
offset = offset_;
total = total_;
received = true;
- cond.Signal();
+ cond.notify_all();
return 0;
}
bool wait(librbd::ImageCtx *ictx, uint64_t offset_, uint64_t total_) {
- Mutex::Locker l(mutex);
+ std::unique_lock l{mutex};
while (!received) {
- int r = cond.WaitInterval(mutex, utime_t(10, 0));
- if (r != 0) {
+ if (cond.wait_for(l, 10s) == std::cv_status::timeout) {
break;
}
}
: ictx(ictx_), progress_context(ctx), result(0) {}
void operator()() {
- RWLock::RLocker l(ictx->owner_lock);
+ std::shared_lock l{ictx->owner_lock};
C_SaferCond ctx;
ictx->image_watcher->notify_flatten(0, *progress_context, &ctx);
result = ctx.wait();
: ictx(ictx_), progress_context(ctx), result(0) {}
void operator()() {
- RWLock::RLocker l(ictx->owner_lock);
+ std::shared_lock l{ictx->owner_lock};
C_SaferCond ctx;
ictx->image_watcher->notify_resize(0, 0, true, *progress_context, &ctx);
result = ctx.wait();
: ictx(ictx_), progress_context(ctx), result(0) {}
void operator()() {
- RWLock::RLocker l(ictx->owner_lock);
+ std::shared_lock l{ictx->owner_lock};
C_SaferCond ctx;
ictx->image_watcher->notify_rebuild_object_map(0, *progress_context, &ctx);
result = ctx.wait();
m_notify_acks = {{NOTIFY_OP_SNAP_CREATE, create_response_message(0)}};
- RWLock::RLocker l(ictx->owner_lock);
+ std::shared_lock l{ictx->owner_lock};
C_SaferCond notify_ctx;
ictx->image_watcher->notify_snap_create(cls::rbd::UserSnapshotNamespace(),
"snap", ¬ify_ctx);
m_notify_acks = {{NOTIFY_OP_SNAP_CREATE, create_response_message(-EEXIST)}};
- RWLock::RLocker l(ictx->owner_lock);
+ std::shared_lock l{ictx->owner_lock};
C_SaferCond notify_ctx;
ictx->image_watcher->notify_snap_create(cls::rbd::UserSnapshotNamespace(),
"snap", ¬ify_ctx);
m_notify_acks = {{NOTIFY_OP_SNAP_RENAME, create_response_message(0)}};
- RWLock::RLocker l(ictx->owner_lock);
+ std::shared_lock l{ictx->owner_lock};
C_SaferCond notify_ctx;
ictx->image_watcher->notify_snap_rename(1, "snap-rename", ¬ify_ctx);
ASSERT_EQ(0, notify_ctx.wait());
m_notify_acks = {{NOTIFY_OP_SNAP_RENAME, create_response_message(-EEXIST)}};
- RWLock::RLocker l(ictx->owner_lock);
+ std::shared_lock l{ictx->owner_lock};
C_SaferCond notify_ctx;
ictx->image_watcher->notify_snap_rename(1, "snap-rename", ¬ify_ctx);
ASSERT_EQ(-EEXIST, notify_ctx.wait());
m_notify_acks = {{NOTIFY_OP_SNAP_REMOVE, create_response_message(0)}};
- RWLock::RLocker l(ictx->owner_lock);
+ std::shared_lock l{ictx->owner_lock};
C_SaferCond notify_ctx;
ictx->image_watcher->notify_snap_remove(cls::rbd::UserSnapshotNamespace(),
"snap",
m_notify_acks = {{NOTIFY_OP_SNAP_PROTECT, create_response_message(0)}};
- RWLock::RLocker l(ictx->owner_lock);
+ std::shared_lock l{ictx->owner_lock};
C_SaferCond notify_ctx;
ictx->image_watcher->notify_snap_protect(cls::rbd::UserSnapshotNamespace(),
"snap",
m_notify_acks = {{NOTIFY_OP_SNAP_UNPROTECT, create_response_message(0)}};
- RWLock::RLocker l(ictx->owner_lock);
+ std::shared_lock l{ictx->owner_lock};
C_SaferCond notify_ctx;
ictx->image_watcher->notify_snap_unprotect(cls::rbd::UserSnapshotNamespace(),
"snap",
m_notify_acks = {{NOTIFY_OP_RENAME, create_response_message(0)}};
- RWLock::RLocker l(ictx->owner_lock);
+ std::shared_lock l{ictx->owner_lock};
C_SaferCond notify_ctx;
ictx->image_watcher->notify_rename("new_name", ¬ify_ctx);
ASSERT_EQ(0, notify_ctx.wait());
#include "librbd/internal.h"
#include "librbd/io/ImageRequestWQ.h"
#include "librbd/io/ReadResult.h"
-
+#include "common/Cond.h"
#include <boost/scope_exit.hpp>
void register_test_migration() {
librbd::ImageCtx *dst_ictx) {
uint64_t src_size, dst_size;
{
- RWLock::RLocker src_locker(src_ictx->image_lock);
- RWLock::RLocker dst_locker(dst_ictx->image_lock);
+ std::shared_lock src_locker{src_ictx->image_lock};
+ std::shared_lock dst_locker{dst_ictx->image_lock};
src_size = src_ictx->get_image_size(src_ictx->snap_id);
dst_size = dst_ictx->get_image_size(dst_ictx->snap_id);
}
if (dst_ictx->test_features(RBD_FEATURE_LAYERING)) {
bool flags_set;
- RWLock::RLocker dst_locker(dst_ictx->image_lock);
+ std::shared_lock dst_locker{dst_ictx->image_lock};
EXPECT_EQ(0, dst_ictx->test_flags(dst_ictx->snap_id,
RBD_FLAG_OBJECT_MAP_INVALID,
dst_ictx->image_lock, &flags_set));
C_SaferCond lock_ctx;
{
- RWLock::WLocker owner_locker(ictx->owner_lock);
+ std::unique_lock owner_locker{ictx->owner_lock};
ictx->exclusive_lock->try_acquire_lock(&lock_ctx);
}
ASSERT_EQ(0, lock_ctx.wait());
C_SaferCond lock_ctx;
{
- RWLock::WLocker owner_locker(ictx->owner_lock);
+ std::unique_lock owner_locker{ictx->owner_lock};
ictx->exclusive_lock->try_acquire_lock(&lock_ctx);
}
ASSERT_EQ(0, lock_ctx.wait());
C_SaferCond lock_ctx;
{
- RWLock::WLocker owner_locker(ictx->owner_lock);
+ std::unique_lock owner_locker{ictx->owner_lock};
ictx->exclusive_lock->try_acquire_lock(&lock_ctx);
}
ASSERT_EQ(0, lock_ctx.wait());
C_SaferCond lock_ctx;
{
- RWLock::WLocker owner_locker(ictx->owner_lock);
+ std::unique_lock owner_locker{ictx->owner_lock};
ictx->exclusive_lock->try_acquire_lock(&lock_ctx);
}
ASSERT_EQ(0, lock_ctx.wait());
throttle.end_op(r);
});
- RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::RLocker image_locker(ictx->image_lock);
+ std::shared_lock owner_locker{ictx->owner_lock};
+ std::shared_lock image_locker{ictx->image_lock};
ASSERT_TRUE(ictx->object_map != nullptr);
if (!ictx->object_map->aio_update<
return r;
}
- RWLock::RLocker owner_locker(ictx.owner_lock);
+ std::shared_lock owner_locker{ictx.owner_lock};
ceph_assert(ictx.exclusive_lock != nullptr);
return ictx.exclusive_lock->is_lock_owner() ? 0 : -EINVAL;
}
#include "librbd/io/ImageRequest.h"
#include "librbd/io/ImageRequestWQ.h"
#include "osdc/Striper.h"
+#include "common/Cond.h"
#include <boost/scope_exit.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/assign/list_of.hpp>
C_SaferCond ctx;
{
- RWLock::WLocker l(ictx->owner_lock);
+ std::unique_lock l{ictx->owner_lock};
ictx->exclusive_lock->try_acquire_lock(&ctx);
}
ASSERT_EQ(0, ctx.wait());
C_SaferCond ctx;
{
- RWLock::WLocker l(ictx->owner_lock);
+ std::unique_lock l{ictx->owner_lock};
ictx->exclusive_lock->try_acquire_lock(&ctx);
}
ASSERT_EQ(0, ctx.wait());
{
- RWLock::RLocker owner_locker(ictx->owner_lock);
+ std::shared_lock owner_locker{ictx->owner_lock};
ASSERT_TRUE(ictx->exclusive_lock->is_lock_owner());
}
size -= std::min<uint64_t>(size, 1 << 18);
{
- RWLock::RLocker l(ictx->owner_lock);
+ std::shared_lock l{ictx->owner_lock};
ictx->operations->execute_resize(size, true, prog_ctx, &ctx, 0);
}
if (ictx->exclusive_lock != nullptr) {
C_SaferCond ctx;
{
- RWLock::WLocker l(ictx->owner_lock);
+ std::unique_lock l{ictx->owner_lock};
ictx->exclusive_lock->try_acquire_lock(&ctx);
}
- RWLock::RLocker owner_locker(ictx->owner_lock);
+ std::shared_lock owner_locker{ictx->owner_lock};
ASSERT_EQ(0, ctx.wait());
ASSERT_TRUE(ictx->exclusive_lock->is_lock_owner());
}
new_size = size;
}
- RWLock::RLocker l(ictx->owner_lock);
+ std::shared_lock l{ictx->owner_lock};
contexts.push_back(new C_SaferCond());
ictx->operations->execute_resize(new_size, true, prog_ctx, contexts.back(), 0);
}
object_map.open(&ctx);
ASSERT_EQ(0, ctx.wait());
- RWLock::RLocker image_locker(ictx2->image_lock);
+ std::shared_lock image_locker{ictx2->image_lock};
ASSERT_EQ(state, object_map[0]);
}
}
object_map.open(&ctx);
ASSERT_EQ(0, ctx.wait());
- RWLock::RLocker image_locker(ictx2->image_lock);
+ std::shared_lock image_locker{ictx2->image_lock};
ASSERT_EQ(state, object_map[0]);
}
}
{
// hide the parent from the snapshot
- RWLock::WLocker image_locker(ictx2->image_lock);
+ std::unique_lock image_locker{ictx2->image_lock};
ictx2->snap_info.begin()->second.parent = librbd::ParentImageInfo();
}
{
// hide the parent from the snapshot
- RWLock::WLocker image_locker(ictx2->image_lock);
+ std::unique_lock image_locker{ictx2->image_lock};
ictx2->snap_info.begin()->second.parent = librbd::ParentImageInfo();
}
#include "librbd/api/Image.h"
#include "journal/Journaler.h"
#include "journal/Settings.h"
+#include "common/Cond.h"
#include <boost/scope_exit.hpp>
#include <boost/assign/list_of.hpp>
#include <utility>
const std::string& oid, librbd::MockImageWatcher *watcher,
managed_lock::Mode mode, bool blacklist_on_break_lock,
uint32_t blacklist_expire_seconds)
- : m_lock("ManagedLock::m_lock") {
- }
+ {}
virtual ~ManagedLock() = default;
- mutable Mutex m_lock;
+ mutable ceph::mutex m_lock = ceph::make_mutex("ManagedLock::m_lock");
virtual void shutdown_handler(int r, Context *) = 0;
virtual void pre_acquire_lock_handler(Context *) = 0;
MockExclusiveLock &exclusive_lock) {
C_SaferCond ctx;
{
- RWLock::WLocker owner_locker(mock_image_ctx.owner_lock);
+ std::unique_lock owner_locker{mock_image_ctx.owner_lock};
exclusive_lock.init(mock_image_ctx.features, &ctx);
}
return ctx.wait();
MockExclusiveLock &exclusive_lock) {
C_SaferCond ctx;
{
- RWLock::WLocker owner_locker(mock_image_ctx.owner_lock);
+ std::unique_lock owner_locker{mock_image_ctx.owner_lock};
exclusive_lock.shut_down(&ctx);
}
return ctx.wait();
bool is_lock_owner(MockExclusiveLockImageCtx &mock_image_ctx,
MockExclusiveLock &exclusive_lock) {
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
return exclusive_lock.is_lock_owner();
}
};
#include "test/librbd/mock/MockJournalPolicy.h"
#include "test/librbd/mock/io/MockObjectDispatch.h"
#include "common/Cond.h"
-#include "common/Mutex.h"
+#include "common/ceph_mutex.h"
#include "cls/journal/cls_journal_types.h"
#include "journal/Journaler.h"
#include "librbd/Journal.h"
static OpenRequest *s_instance;
static OpenRequest *create(MockJournalImageCtx *image_ctx,
::journal::MockJournalerProxy *journaler,
- Mutex *lock, journal::ImageClientMeta *client_meta,
+ ceph::mutex *lock, journal::ImageClientMeta *client_meta,
uint64_t *tag_tid, journal::TagData *tag_data,
Context *on_finish) {
ceph_assert(s_instance != nullptr);
typedef std::function<void(::journal::ReplayHandler*)> ReplayAction;
typedef std::list<Context *> Contexts;
- TestMockJournal() : m_lock("lock") {
- }
-
+ TestMockJournal() = default;
~TestMockJournal() override {
ceph_assert(m_commit_contexts.empty());
}
- Mutex m_lock;
- Cond m_cond;
+ ceph::mutex m_lock = ceph::make_mutex("lock");
+ ceph::condition_variable m_cond;
Contexts m_commit_contexts;
struct C_ReplayAction : public Context {
bufferlist bl;
bl.append_zero(length);
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
return mock_journal.append_write_event(0, length, bl, false);
}
uint64_t when_append_io_event(MockJournalImageCtx &mock_image_ctx,
MockJournal &mock_journal,
int filter_ret_val) {
- RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+ std::shared_lock owner_locker{mock_image_ctx.owner_lock};
return mock_journal.append_io_event(
journal::EventEntry{journal::AioFlushEvent{}}, 0, 0, false,
filter_ret_val);
}
void save_commit_context(Context *ctx) {
- Mutex::Locker locker(m_lock);
+ std::lock_guard locker{m_lock};
m_commit_contexts.push_back(ctx);
- m_cond.Signal();
+ m_cond.notify_all();
}
void wake_up() {
- Mutex::Locker locker(m_lock);
- m_cond.Signal();
+ std::lock_guard locker{m_lock};
+ m_cond.notify_all();
}
void commit_replay(MockJournalImageCtx &mock_image_ctx, Context *on_flush,
// wait for the process callback
{
- Mutex::Locker locker(m_lock);
- while (m_commit_contexts.empty()) {
- m_cond.Wait(m_lock);
- }
+ std::unique_lock locker{m_lock};
+ m_cond.wait(locker, [this] { return !m_commit_contexts.empty(); });
}
on_ready->complete(0);
// proceed with the flush
{
// wait for on_flush callback
- Mutex::Locker locker(m_lock);
- while (on_flush == nullptr) {
- m_cond.Wait(m_lock);
- }
+ std::unique_lock locker{m_lock};
+ m_cond.wait(locker, [&] {return on_flush != nullptr;});
}
{
// wait for the on_safe process callback
- Mutex::Locker locker(m_lock);
- while (m_commit_contexts.empty()) {
- m_cond.Wait(m_lock);
- }
+ std::unique_lock locker{m_lock};
+ m_cond.wait(locker, [this] {return !m_commit_contexts.empty();});
}
m_commit_contexts.front()->complete(-EINVAL);
m_commit_contexts.clear();
};
InSequence seq;
- RWLock::RLocker image_locker(mock_image_ctx.image_lock);
+ std::shared_lock image_locker{mock_image_ctx.image_lock};
EXPECT_CALL(mock_image_ctx, get_journal_policy()).WillOnce(
Return(ictx->get_journal_policy()));
ASSERT_TRUE(mock_journal.is_journal_appending());
Context *on_finish = nullptr;
ceph::BitVector<2u> *object_map = nullptr;
static RefreshRequest *s_instance;
- static RefreshRequest *create(MockTestImageCtx &image_ctx, RWLock*,
+ static RefreshRequest *create(MockTestImageCtx &image_ctx, ceph::shared_mutex*,
ceph::BitVector<2u> *object_map,
uint64_t snap_id, Context *on_finish) {
ceph_assert(s_instance != nullptr);
struct UpdateRequest<MockTestImageCtx> {
Context *on_finish = nullptr;
static UpdateRequest *s_instance;
- static UpdateRequest *create(MockTestImageCtx &image_ctx, RWLock*,
+ static UpdateRequest *create(MockTestImageCtx &image_ctx, ceph::shared_mutex*,
ceph::BitVector<2u> *object_map,
uint64_t snap_id,
uint64_t start_object_no, uint64_t end_object_no,
C_SaferCond update_ctx1;
C_SaferCond update_ctx2;
{
- RWLock::RLocker image_locker(mock_image_ctx.image_lock);
+ std::shared_lock image_locker{mock_image_ctx.image_lock};
mock_object_map.aio_update(CEPH_NOSNAP, 0, 1, {}, {}, false, &update_ctx1);
mock_object_map.aio_update(CEPH_NOSNAP, 1, 1, {}, {}, false, &update_ctx2);
}
C_SaferCond update_ctx3;
C_SaferCond update_ctx4;
{
- RWLock::RLocker image_locker(mock_image_ctx.image_lock);
+ std::shared_lock image_locker{mock_image_ctx.image_lock};
mock_object_map.aio_update(CEPH_NOSNAP, 1, 4, 1, {}, {}, false,
&update_ctx1);
mock_object_map.aio_update(CEPH_NOSNAP, 1, 3, 1, {}, {}, false,
#include "test/librados_test_stub/MockTestMemIoCtxImpl.h"
#include "test/librados_test_stub/MockTestMemRadosClient.h"
#include "common/Cond.h"
-#include "common/Mutex.h"
+#include "common/ceph_mutex.h"
#include "librados/AioCompletionImpl.h"
#include "librbd/Watcher.h"
#include "librbd/watcher/RewatchRequest.h"
class TestMockWatcher : public TestMockFixture {
public:
- TestMockWatcher() : m_lock("TestMockWatcher::m_lock") {
- }
+ TestMockWatcher() = default;
virtual void SetUp() {
TestMockFixture::SetUp();
librados::WatchCtx2 *m_watch_ctx = nullptr;
void notify_watch() {
- Mutex::Locker locker(m_lock);
+ std::lock_guard locker{m_lock};
++m_watch_count;
- m_cond.Signal();
+ m_cond.notify_all();
}
bool wait_for_watch(MockImageCtx &mock_image_ctx, size_t count) {
- Mutex::Locker locker(m_lock);
+ std::unique_lock locker{m_lock};
while (m_watch_count < count) {
- if (m_cond.WaitInterval(m_lock, utime_t(10, 0)) != 0) {
+ if (m_cond.wait_for(locker, 10s) == std::cv_status::timeout) {
return false;
}
}
return true;
}
- Mutex m_lock;
- Cond m_cond;
+ ceph::mutex m_lock = ceph::make_mutex("TestMockWatcher::m_lock");
+ ceph::condition_variable m_cond;
size_t m_watch_count = 0;
};
struct TestMockWatcherRewatchRequest : public TestMockFixture {
typedef RewatchRequest MockRewatchRequest;
- TestMockWatcherRewatchRequest()
- : m_watch_lock("watch_lock") {
- }
+ TestMockWatcherRewatchRequest() = default;
void expect_aio_watch(MockImageCtx &mock_image_ctx, int r) {
librados::MockTestMemIoCtxImpl &mock_io_ctx(get_mock_io_ctx(
}
};
- RWLock m_watch_lock;
+ ceph::shared_mutex m_watch_lock = ceph::make_shared_mutex("watch_lock");
WatchCtx m_watch_ctx;
uint64_t m_watch_handle = 123;
};
&m_watch_handle,
&ctx);
{
- RWLock::WLocker watch_locker(m_watch_lock);
+ std::unique_lock watch_locker{m_watch_lock};
req->send();
}
ASSERT_EQ(0, ctx.wait());
&m_watch_handle,
&ctx);
{
- RWLock::WLocker watch_locker(m_watch_lock);
+ std::unique_lock watch_locker{m_watch_lock};
req->send();
}
ASSERT_EQ(0, ctx.wait());
&m_watch_handle,
&ctx);
{
- RWLock::WLocker watch_locker(m_watch_lock);
+ std::unique_lock watch_locker{m_watch_lock};
req->send();
}
ASSERT_EQ(-EBLACKLISTED, ctx.wait());
&m_watch_handle,
&ctx);
{
- RWLock::WLocker watch_locker(m_watch_lock);
+ std::unique_lock watch_locker{m_watch_lock};
req->send();
}
ASSERT_EQ(-ENOENT, ctx.wait());
&m_watch_handle,
&ctx);
{
- RWLock::WLocker watch_locker(m_watch_lock);
+ std::unique_lock watch_locker{m_watch_lock};
req->send();
}
ASSERT_EQ(-EINVAL, ctx.wait());
&m_watch_handle,
&ctx);
{
- RWLock::WLocker watch_locker(m_watch_lock);
+ std::unique_lock watch_locker{m_watch_lock};
req->send();
}
projects / ceph-ci.git / commitdiff