#undef dout_prefix
#define dout_prefix *_dout << "librados: "
-bool librados::RadosClient::ms_get_authorizer(int dest_type,
- AuthAuthorizer **authorizer) {
- //ldout(cct, 0) << "RadosClient::ms_get_authorizer type=" << dest_type << dendl;
- /* monitor authorization is being handled on different layer */
- if (dest_type == CEPH_ENTITY_TYPE_MON)
- return true;
- *authorizer = monclient.build_authorizer(dest_type);
- return *authorizer != NULL;
-}
-
librados::RadosClient::RadosClient(CephContext *cct_)
: Dispatcher(cct_->get()),
cct_deleter{cct_, [](CephContext *p) {p->put();}},
conf(cct_->_conf),
state(DISCONNECTED),
monclient(cct_),
- mgrclient(cct_, nullptr),
+ mgrclient(cct_, nullptr, &monclient.monmap),
messenger(NULL),
instance_id(0),
objecter(NULL),
- lock("librados::RadosClient::lock"),
timer(cct, lock),
refcnt(1),
log_last_version(0), log_cb(NULL), log_cb2(NULL), log_cb_arg(NULL),
objecter->set_client_incarnation(0);
objecter->start();
- lock.Lock();
+ lock.lock();
timer.init();
state = CONNECTED;
instance_id = monclient.get_global_id();
- lock.Unlock();
+ lock.unlock();
ldout(cct, 1) << "init done" << dendl;
err = 0;
void librados::RadosClient::shutdown()
{
- lock.Lock();
+ std::unique_lock l{lock};
if (state == DISCONNECTED) {
- lock.Unlock();
return;
}
state = DISCONNECTED;
instance_id = 0;
timer.shutdown(); // will drop+retake lock
- lock.Unlock();
+ l.unlock();
if (need_objecter) {
objecter->shutdown();
}
int librados::RadosClient::watch_flush()
{
ldout(cct, 10) << __func__ << " enter" << dendl;
- Mutex mylock("RadosClient::watch_flush::mylock");
- Cond cond;
+ ceph::mutex mylock = ceph::make_mutex("RadosClient::watch_flush::mylock");
+ ceph::condition_variable cond;
bool done;
- objecter->linger_callback_flush(new C_SafeCond(&mylock, &cond, &done));
-
- mylock.Lock();
- while (!done)
- cond.Wait(mylock);
- mylock.Unlock();
+ objecter->linger_callback_flush(new C_SafeCond(mylock, cond, &done));
+ std::unique_lock l{mylock};
+ cond.wait(l, [&done] { return done; });
ldout(cct, 10) << __func__ << " exit" << dendl;
return 0;
}
}
void finish(int r) override {
- c->lock.Lock();
+ c->lock.lock();
c->rval = r;
c->complete = true;
- c->cond.Signal();
+ c->cond.notify_all();
if (c->callback_complete ||
c->callback_safe) {
objecter->with_osdmap(
[require_osd_release](const OSDMap& o) {
- *require_osd_release = o.require_osd_release;
+ *require_osd_release = ceph::to_integer<int8_t>(o.require_osd_release);
});
return 0;
}
objecter->with_osdmap(
[min_compat_client, require_min_compat_client](const OSDMap& o) {
- *min_compat_client = o.get_min_compat_client();
- *require_min_compat_client = o.get_require_min_compat_client();
+ *min_compat_client =
+ ceph::to_integer<int8_t>(o.get_min_compat_client());
+ *require_min_compat_client =
+ ceph::to_integer<int8_t>(o.get_require_min_compat_client());
});
return 0;
}
bool librados::RadosClient::_dispatch(Message *m)
{
- ceph_assert(lock.is_locked());
+ ceph_assert(ceph_mutex_is_locked(lock));
switch (m->get_type()) {
// OSD
case CEPH_MSG_OSD_MAP:
- cond.Signal();
+ cond.notify_all();
m->put();
break;
int librados::RadosClient::wait_for_osdmap()
{
- ceph_assert(!lock.is_locked_by_me());
+ ceph_assert(ceph_mutex_is_not_locked_by_me(lock));
if (state != CONNECTED) {
return -ENOTCONN;
});
if (need_map) {
- std::lock_guard l(lock);
+ std::unique_lock l(lock);
ceph::timespan timeout{0};
if (cct->_conf->rados_mon_op_timeout > 0) {
ldout(cct, 10) << __func__ << " waiting" << dendl;
while (objecter->with_osdmap(std::mem_fn(&OSDMap::get_epoch)) == 0) {
if (timeout == timeout.zero()) {
- cond.Wait(lock);
+ cond.wait(l);
} else {
- int r = cond.WaitInterval(lock, timeout);
- if (r == ETIMEDOUT) {
+ if (cond.wait_for(l, timeout) == std::cv_status::timeout) {
lderr(cct) << "timed out waiting for first osdmap from monitors"
<< dendl;
return -ETIMEDOUT;
int librados::RadosClient::wait_for_latest_osdmap()
{
- Mutex mylock("RadosClient::wait_for_latest_osdmap");
- Cond cond;
+ ceph::mutex mylock = ceph::make_mutex("RadosClient::wait_for_latest_osdmap");
+ ceph::condition_variable cond;
bool done;
- objecter->wait_for_latest_osdmap(new C_SafeCond(&mylock, &cond, &done));
-
- mylock.Lock();
- while (!done)
- cond.Wait(mylock);
- mylock.Unlock();
+ objecter->wait_for_latest_osdmap(new C_SafeCond(mylock, cond, &done));
+ std::unique_lock l{mylock};
+ cond.wait(l, [&done] {return done;});
return 0;
}
map<string,::pool_stat_t> *result,
bool *per_pool)
{
- Mutex mylock("RadosClient::get_pool_stats::mylock");
- Cond cond;
+ ceph::mutex mylock = ceph::make_mutex("RadosClient::get_pool_stats::mylock");
+ ceph::condition_variable cond;
bool done;
int ret = 0;
objecter->get_pool_stats(pools, result, per_pool,
- new C_SafeCond(&mylock, &cond, &done,
+ new C_SafeCond(mylock, cond, &done,
&ret));
- mylock.Lock();
- while (!done)
- cond.Wait(mylock);
- mylock.Unlock();
-
+ unique_lock l{mylock};
+ cond.wait(l, [&done] { return done;});
return ret;
}
int librados::RadosClient::get_fs_stats(ceph_statfs& stats)
{
- Mutex mylock ("RadosClient::get_fs_stats::mylock");
- Cond cond;
+ ceph::mutex mylock = ceph::make_mutex("RadosClient::get_fs_stats::mylock");
+ ceph::condition_variable cond;
bool done;
int ret = 0;
-
- lock.Lock();
- objecter->get_fs_stats(stats, boost::optional<int64_t> (),
- new C_SafeCond(&mylock, &cond, &done, &ret));
- lock.Unlock();
-
- mylock.Lock();
- while (!done) cond.Wait(mylock);
- mylock.Unlock();
-
+ {
+ std::lock_guard l{mylock};
+ objecter->get_fs_stats(stats, boost::optional<int64_t> (),
+ new C_SafeCond(mylock, cond, &done, &ret));
+ }
+ {
+ std::unique_lock l{mylock};
+ cond.wait(l, [&done] { return done;});
+ }
return ret;
}
return r;
}
- Mutex mylock ("RadosClient::pool_create::mylock");
+ ceph::mutex mylock = ceph::make_mutex("RadosClient::pool_create::mylock");
int reply;
- Cond cond;
+ ceph::condition_variable cond;
bool done;
- Context *onfinish = new C_SafeCond(&mylock, &cond, &done, &reply);
+ Context *onfinish = new C_SafeCond(mylock, cond, &done, &reply);
reply = objecter->create_pool(name, onfinish, crush_rule);
if (reply < 0) {
delete onfinish;
} else {
- mylock.Lock();
- while(!done)
- cond.Wait(mylock);
- mylock.Unlock();
+ std::unique_lock l{mylock};
+ cond.wait(l, [&done] { return done; });
}
return reply;
}
return r;
}
- Mutex mylock("RadosClient::pool_delete::mylock");
- Cond cond;
+ ceph::mutex mylock = ceph::make_mutex("RadosClient::pool_delete::mylock");
+ ceph::condition_variable cond;
bool done;
int ret;
- Context *onfinish = new C_SafeCond(&mylock, &cond, &done, &ret);
+ Context *onfinish = new C_SafeCond(mylock, cond, &done, &ret);
ret = objecter->delete_pool(name, onfinish);
if (ret < 0) {
delete onfinish;
} else {
- mylock.Lock();
- while (!done)
- cond.Wait(mylock);
- mylock.Unlock();
+ std::unique_lock l{mylock};
+ cond.wait(l, [&done] { return done;});
}
return ret;
}
objecter->blacklist_self(set);
}
+std::string librados::RadosClient::get_addrs() const {
+ CachedStackStringStream cos;
+ *cos << messenger->get_myaddrs();
+ return std::string(cos->strv());
+}
+
int librados::RadosClient::blacklist_add(const string& client_address,
uint32_t expire_seconds)
{
bufferlist *outbl, string *outs,
Context *on_finish)
{
- lock.Lock();
+ std::lock_guard l{lock};
monclient.start_mon_command(cmd, inbl, outbl, outs, on_finish);
- lock.Unlock();
}
int librados::RadosClient::mgr_command(const vector<string>& cmd,
if (r < 0)
return r;
- lock.Unlock();
+ lock.unlock();
if (conf->rados_mon_op_timeout) {
r = cond.wait_for(conf->rados_mon_op_timeout);
} else {
r = cond.wait();
}
- lock.Lock();
+ lock.lock();
+
+ return r;
+}
+
+int librados::RadosClient::mgr_command(
+ const string& name,
+ const vector<string>& cmd,
+ const bufferlist &inbl,
+ bufferlist *outbl, string *outs)
+{
+ std::lock_guard l(lock);
+
+ C_SaferCond cond;
+ int r = mgrclient.start_tell_command(name, cmd, inbl, outbl, outs, &cond);
+ if (r < 0)
+ return r;
+
+ lock.unlock();
+ if (conf->rados_mon_op_timeout) {
+ r = cond.wait_for(conf->rados_mon_op_timeout);
+ } else {
+ r = cond.wait();
+ }
+ lock.lock();
return r;
}
const bufferlist &inbl,
bufferlist *outbl, string *outs)
{
- Mutex mylock("RadosClient::mon_command::mylock");
- Cond cond;
+ ceph::mutex mylock = ceph::make_mutex("RadosClient::mon_command::mylock");
+ ceph::condition_variable cond;
bool done;
int rval;
- lock.Lock();
- monclient.start_mon_command(rank, cmd, inbl, outbl, outs,
- new C_SafeCond(&mylock, &cond, &done, &rval));
- lock.Unlock();
- mylock.Lock();
- while (!done)
- cond.Wait(mylock);
- mylock.Unlock();
+ {
+ std::lock_guard l{mylock};
+ monclient.start_mon_command(rank, cmd, inbl, outbl, outs,
+ new C_SafeCond(mylock, cond, &done, &rval));
+ }
+ std::unique_lock l{mylock};
+ cond.wait(l, [&done] { return done;});
return rval;
}
const bufferlist &inbl,
bufferlist *outbl, string *outs)
{
- Mutex mylock("RadosClient::mon_command::mylock");
- Cond cond;
+ ceph::mutex mylock = ceph::make_mutex("RadosClient::mon_command::mylock");
+ ceph::condition_variable cond;
bool done;
int rval;
- lock.Lock();
- monclient.start_mon_command(name, cmd, inbl, outbl, outs,
- new C_SafeCond(&mylock, &cond, &done, &rval));
- lock.Unlock();
- mylock.Lock();
- while (!done)
- cond.Wait(mylock);
- mylock.Unlock();
+ {
+ std::lock_guard l{mylock};
+ monclient.start_mon_command(name, cmd, inbl, outbl, outs,
+ new C_SafeCond(mylock, cond, &done, &rval));
+ }
+ std::unique_lock l{mylock};
+ cond.wait(l, [&done] { return done;});
return rval;
}
const bufferlist& inbl,
bufferlist *poutbl, string *prs)
{
- Mutex mylock("RadosClient::osd_command::mylock");
- Cond cond;
+ ceph::mutex mylock = ceph::make_mutex("RadosClient::osd_command::mylock");
+ ceph::condition_variable cond;
bool done;
int ret;
ceph_tid_t tid;
if (osd < 0)
return -EINVAL;
- lock.Lock();
- // XXX do anything with tid?
- objecter->osd_command(osd, cmd, inbl, &tid, poutbl, prs,
- new C_SafeCond(&mylock, &cond, &done, &ret));
- lock.Unlock();
- mylock.Lock();
- while (!done)
- cond.Wait(mylock);
- mylock.Unlock();
+ {
+ std::lock_guard l{mylock};
+ // XXX do anything with tid?
+ objecter->osd_command(osd, cmd, inbl, &tid, poutbl, prs,
+ new C_SafeCond(mylock, cond, &done, &ret));
+ }
+ std::unique_lock l{mylock};
+ cond.wait(l, [&done] { return done;});
return ret;
}
const bufferlist& inbl,
bufferlist *poutbl, string *prs)
{
- Mutex mylock("RadosClient::pg_command::mylock");
- Cond cond;
+ ceph::mutex mylock = ceph::make_mutex("RadosClient::pg_command::mylock");
+ ceph::condition_variable cond;
bool done;
int ret;
ceph_tid_t tid;
- lock.Lock();
- objecter->pg_command(pgid, cmd, inbl, &tid, poutbl, prs,
- new C_SafeCond(&mylock, &cond, &done, &ret));
- lock.Unlock();
- mylock.Lock();
- while (!done)
- cond.Wait(mylock);
- mylock.Unlock();
+
+ {
+ std::lock_guard l{lock};
+ objecter->pg_command(pgid, cmd, inbl, &tid, poutbl, prs,
+ new C_SafeCond(mylock, cond, &done, &ret));
+ }
+ std::unique_lock l{mylock};
+ cond.wait(l, [&done] { return done;});
return ret;
}
void librados::RadosClient::handle_log(MLog *m)
{
- ceph_assert(lock.is_locked());
+ ceph_assert(ceph_mutex_is_locked(lock));
ldout(cct, 10) << __func__ << " version " << m->version << dendl;
if (log_last_version < m->version) {
projects / ceph.git / blobdiff