monclient(mc),
objecter(objecter_),
whoami(mc->get_global_id()),
+ mount_state(CLIENT_UNMOUNTED, "Client::mountstate_lock"),
+ initialize_state(CLIENT_NEW, "Client::initstate_lock"),
async_ino_invalidator(m->cct),
async_dentry_invalidator(m->cct),
interrupt_finisher(m->cct),
int Client::init()
{
+ RWRef_t iref_writer(initialize_state, CLIENT_INITIALIZING, false);
+ ceph_assert(iref_writer.is_first_writer());
+
_pre_init();
{
std::lock_guard l{client_lock};
- ceph_assert(!initialized);
messenger->add_dispatcher_tail(this);
}
_finish_init();
+ iref_writer.update_state(CLIENT_INITIALIZED);
return 0;
}
lderr(cct) << "error registering admin socket command: "
<< cpp_strerror(-ret) << dendl;
}
-
- std::lock_guard l{client_lock};
- initialized = true;
}
void Client::shutdown()
}
objectcacher->stop(); // outside of client_lock! this does a join.
- {
- std::lock_guard l{client_lock};
- ceph_assert(initialized);
- initialized = false;
- }
+
+ /*
+ * We are shuting down the client.
+ *
+ * Just declare the state to CLIENT_NEW to block and fail any
+ * new comming "reader" and then try to wait all the in-flight
+ * "readers" to finish.
+ */
+ RWRef_t iref_writer(initialize_state, CLIENT_NEW, false);
+ if (!iref_writer.is_first_writer())
+ return;
+ iref_writer.wait_readers_done();
{
std::scoped_lock l(timer_lock);
timer.shutdown();
}
+
objecter_finisher.wait_for_empty();
objecter_finisher.stop();
while (lru.lru_get_size() != last) {
last = lru.lru_get_size();
- if (!unmounting && lru.lru_get_size() <= max) break;
+ if (!is_unmounting() && lru.lru_get_size() <= max) break;
// trim!
Dentry *dn = static_cast<Dentry*>(lru.lru_get_next_expire());
if (!dn)
break; // done
-
+
trim_dentry(dn);
}
_assign_faked_root(root);
root_ancestor = in;
cwd = root;
- } else if (!mounted) {
+ } else if (is_mounting()) {
root_parents[root_ancestor] = in;
root_ancestor = in;
}
*/
void Client::update_metadata(std::string const &k, std::string const &v)
{
+ RWRef_t iref_reader(initialize_state, CLIENT_INITIALIZED);
+ ceph_assert(iref_reader.is_state_satisfied());
+
std::lock_guard l(client_lock);
- ceph_assert(initialized);
auto it = metadata.find(k);
if (it != metadata.end()) {
renew_caps(session);
session->state = MetaSession::STATE_OPEN;
- if (unmounting)
+ if (is_unmounting())
mount_cond.notify_all();
else
connect_mds_targets(from);
request->item.remove_myself();
unregister_request(request);
}
- if (unmounting)
+ if (is_unmounting())
mount_cond.notify_all();
}
bool Client::ms_dispatch2(const MessageRef &m)
{
- std::lock_guard l(client_lock);
- if (!initialized) {
+ RWRef_t iref_reader(initialize_state, CLIENT_INITIALIZED);
+ if (!iref_reader.is_state_satisfied()) {
ldout(cct, 10) << "inactive, discarding " << *m << dendl;
return true;
}
+// if (!is_initialized())
+// return true;
+
+ std::lock_guard l(client_lock);
switch (m->get_type()) {
// mounting and mds sessions
}
// unmounting?
- if (unmounting) {
+ if (is_unmounting()) {
ldout(cct, 10) << "unmounting: trim pass, size was " << lru.lru_get_size()
<< "+" << inode_map.size() << dendl;
long unsigned size = lru.lru_get_size() + inode_map.size();
used = adjust_caps_used_for_lazyio(used, issued, implemented);
int retain = wanted | used | CEPH_CAP_PIN;
- if (!unmounting && in->nlink > 0) {
+ if (!is_unmounting() && in->nlink > 0) {
if (wanted) {
retain |= CEPH_CAP_ANY;
} else if (in->is_dir() &&
if (wanted & ~(cap.wanted | cap.issued))
goto ack;
- if (!revoking && unmounting && (cap_used == 0))
+ if (!revoking && is_unmounting() && (cap_used == 0))
goto ack;
if ((cap.issued & ~retain) == 0 && // and we don't have anything we wouldn't like
void Client::_async_invalidate(vinodeno_t ino, int64_t off, int64_t len)
{
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return;
+
ldout(cct, 10) << __func__ << " " << ino << " " << off << "~" << len << dendl;
ino_invalidate_cb(callback_handle, ino, off, len);
}
(cct->_conf.get_val<bool>("client_die_on_failed_remount") ||
cct->_conf.get_val<bool>("client_die_on_failed_dentry_invalidate")) &&
!(retry_on_error && (++retries_on_invalidate < max_retries));
- if (should_abort && !unmounting) {
+ if (should_abort && !is_unmounting()) {
lderr(cct) << "failed to remount for kernel dentry trimming; quitting!" << dendl;
ceph_abort();
}
void Client::_invalidate_kernel_dcache()
{
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return;
+
if (can_invalidate_dentries) {
if (dentry_invalidate_cb && root->dir) {
for (ceph::unordered_map<string, Dentry*>::iterator p = root->dir->dentries.begin();
void Client::_async_inode_release(vinodeno_t ino)
{
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return;
+
ldout(cct, 10) << __func__ << " " << ino << dendl;
ino_release_cb(callback_handle, ino);
}
void Client::_async_dentry_invalidate(vinodeno_t dirino, vinodeno_t ino, string& name)
{
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return;
+
ldout(cct, 10) << __func__ << " '" << name << "' ino " << ino
<< " in dir " << dirino << dendl;
dentry_invalidate_cb(callback_handle, dirino, ino, name.c_str(), name.length());
string *outs,
Context *onfinish)
{
- std::lock_guard lock(client_lock);
-
- if (!initialized)
+ RWRef_t iref_reader(initialize_state, CLIENT_INITIALIZED);
+ if (!iref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::scoped_lock lock(client_lock);
+
int r;
r = authenticate();
if (r < 0) {
int Client::mount(const std::string &mount_root, const UserPerm& perms,
bool require_mds, const std::string &fs_name)
{
- std::unique_lock lock(client_lock);
+ ceph_assert(is_initialized());
- if (mounted) {
- ldout(cct, 5) << "already mounted" << dendl;
+ /*
+ * To make sure that the _unmount() must wait until the mount()
+ * is done.
+ */
+ RWRef_t mref_writer(mount_state, CLIENT_MOUNTING, false);
+ if (!mref_writer.is_first_writer()) // already mounting or mounted
return 0;
- }
- unmounting = false;
+ std::unique_lock cl(client_lock);
int r = subscribe_mdsmap(fs_name);
if (r < 0) {
return r;
}
- lock.unlock();
+ cl.unlock();
tick(); // start tick
- lock.lock();
-
+ cl.lock();
+
if (require_mds) {
while (1) {
auto availability = mdsmap->is_cluster_available();
ceph_assert(root);
_ll_get(root);
- mounted = true;
-
// trace?
if (!cct->_conf->client_trace.empty()) {
traceout.open(cct->_conf->client_trace.c_str());
ldout(cct, 3) << "op: map<int, int> open_files;" << dendl;
ldout(cct, 3) << "op: int fd;" << dendl;
*/
+
+ mref_writer.update_state(CLIENT_MOUNTED);
return 0;
}
void Client::_unmount(bool abort)
{
- std::unique_lock lock{client_lock};
- if (unmounting)
+ /*
+ * We are unmounting the client.
+ *
+ * Just declare the state to STATE_UNMOUNTING to block and fail
+ * any new comming "reader" and then try to wait all the in-flight
+ * "readers" to finish.
+ */
+ RWRef_t mref_writer(mount_state, CLIENT_UNMOUNTING, false);
+ if (!mref_writer.is_first_writer())
return;
+ mref_writer.wait_readers_done();
+
+ std::unique_lock lock{client_lock};
if (abort || blacklisted) {
ldout(cct, 2) << "unmounting (" << (abort ? "abort)" : "blacklisted)") << dendl;
} else {
ldout(cct, 2) << "unmounting" << dendl;
}
- unmounting = true;
deleg_timeout = 0;
_close_sessions();
- mounted = false;
+ mref_writer.update_state(CLIENT_UNMOUNTED);
ldout(cct, 2) << "unmounted." << dendl;
}
utime_t now = ceph_clock_now();
- std::lock_guard lock(client_lock);
-
- if (!mounted && !mds_requests.empty()) {
+ std::scoped_lock cl(client_lock);
+ /*
+ * If the mount() is not finished
+ */
+ if (is_mounting() && !mds_requests.empty()) {
MetaRequest *req = mds_requests.begin()->second;
if (req->op_stamp + cct->_conf->client_mount_timeout < now) {
req->abort(-ETIMEDOUT);
if (req->caller_cond) {
- req->kick = true;
- req->caller_cond->notify_all();
+ req->kick = true;
+ req->caller_cond->notify_all();
}
signal_cond_list(waiting_for_mdsmap);
for (auto &p : mds_sessions) {
- signal_context_list(p.second.waiting_for_open);
+ signal_context_list(p.second.waiting_for_open);
}
}
}
trim_cache(true);
- if (blacklisted && mounted &&
+ if (blacklisted && (is_mounted() || is_unmounting()) &&
last_auto_reconnect + 30 * 60 < now &&
cct->_conf.get_val<bool>("client_reconnect_stale")) {
messenger->client_reset();
int Client::link(const char *relexisting, const char *relpath, const UserPerm& perm)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << "link" << std::endl;
tout(cct) << relexisting << std::endl;
tout(cct) << relpath << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
filepath existing(relexisting);
InodeRef in, dir;
+
+ std::scoped_lock lock(client_lock);
int r = path_walk(existing, &in, perm, true);
if (r < 0)
return r;
int Client::unlink(const char *relpath, const UserPerm& perm)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << relpath << std::endl;
- std::scoped_lock lock(client_lock);
-
- if (unmounting)
- return -ENOTCONN;
-
if (std::string(relpath) == "/")
return -EISDIR;
string name = path.last_dentry();
path.pop_dentry();
InodeRef dir;
+
+ std::scoped_lock lock(client_lock);
int r = path_walk(path, &dir, perm);
if (r < 0)
return r;
int Client::rename(const char *relfrom, const char *relto, const UserPerm& perm)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << relfrom << std::endl;
tout(cct) << relto << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
if (std::string(relfrom) == "/" || std::string(relto) == "/")
return -EBUSY;
to.pop_dentry();
InodeRef fromdir, todir;
+
+ std::scoped_lock lock(client_lock);
int r = path_walk(from, &fromdir, perm);
if (r < 0)
goto out;
int Client::mkdir(const char *relpath, mode_t mode, const UserPerm& perm)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << relpath << std::endl;
tout(cct) << mode << std::endl;
ldout(cct, 10) << __func__ << ": " << relpath << dendl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
if (std::string(relpath) == "/")
return -EEXIST;
string name = path.last_dentry();
path.pop_dentry();
InodeRef dir;
+
+ std::scoped_lock lock(client_lock);
int r = path_walk(path, &dir, perm);
if (r < 0)
return r;
int Client::mkdirs(const char *relpath, mode_t mode, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
ldout(cct, 10) << "Client::mkdirs " << relpath << dendl;
tout(cct) << __func__ << std::endl;
tout(cct) << relpath << std::endl;
tout(cct) << mode << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
//get through existing parts of path
filepath path(relpath);
unsigned int i;
int r = 0, caps = 0;
InodeRef cur, next;
+
+ std::scoped_lock lock(client_lock);
cur = cwd;
for (i=0; i<path.depth(); ++i) {
if (cct->_conf->client_permissions) {
int Client::rmdir(const char *relpath, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << relpath << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
if (std::string(relpath) == "/")
return -EBUSY;
string name = path.last_dentry();
path.pop_dentry();
InodeRef dir;
+
+ std::scoped_lock lock(client_lock);
int r = path_walk(path, &dir, perms);
if (r < 0)
return r;
int Client::mknod(const char *relpath, mode_t mode, const UserPerm& perms, dev_t rdev)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << relpath << std::endl;
tout(cct) << mode << std::endl;
tout(cct) << rdev << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
if (std::string(relpath) == "/")
return -EEXIST;
string name = path.last_dentry();
path.pop_dentry();
InodeRef dir;
+
+ std::scoped_lock lock(client_lock);
int r = path_walk(path, &dir, perms);
if (r < 0)
return r;
int Client::symlink(const char *target, const char *relpath, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << target << std::endl;
tout(cct) << relpath << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
if (std::string(relpath) == "/")
return -EEXIST;
string name = path.last_dentry();
path.pop_dentry();
InodeRef dir;
+
+ std::scoped_lock lock(client_lock);
int r = path_walk(path, &dir, perms);
if (r < 0)
return r;
int Client::readlink(const char *relpath, char *buf, loff_t size, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << relpath << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
filepath path(relpath);
InodeRef in;
+
+ std::scoped_lock lock(client_lock);
int r = path_walk(path, &in, perms, false);
if (r < 0)
return r;
int Client::setattr(const char *relpath, struct stat *attr, int mask,
const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << relpath << std::endl;
tout(cct) << mask << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
filepath path(relpath);
InodeRef in;
+
+ std::scoped_lock lock(client_lock);
int r = path_walk(path, &in, perms);
if (r < 0)
return r;
int Client::setattrx(const char *relpath, struct ceph_statx *stx, int mask,
const UserPerm& perms, int flags)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << relpath << std::endl;
tout(cct) << mask << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
filepath path(relpath);
InodeRef in;
+
+ std::scoped_lock lock(client_lock);
int r = path_walk(path, &in, perms, !(flags & AT_SYMLINK_NOFOLLOW));
if (r < 0)
return r;
int Client::fsetattr(int fd, struct stat *attr, int mask, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << fd << std::endl;
tout(cct) << mask << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
Fh *f = get_filehandle(fd);
if (!f)
return -EBADF;
int Client::fsetattrx(int fd, struct ceph_statx *stx, int mask, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << fd << std::endl;
tout(cct) << mask << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
Fh *f = get_filehandle(fd);
if (!f)
return -EBADF;
int Client::stat(const char *relpath, struct stat *stbuf, const UserPerm& perms,
frag_info_t *dirstat, int mask)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
ldout(cct, 3) << __func__ << " enter (relpath " << relpath << " mask " << mask << ")" << dendl;
tout(cct) << "stat" << std::endl;
tout(cct) << relpath << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
filepath path(relpath);
InodeRef in;
+
+ std::scoped_lock lock(client_lock);
int r = path_walk(path, &in, perms, true, mask);
if (r < 0)
return r;
const UserPerm& perms,
unsigned int want, unsigned int flags)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
ldout(cct, 3) << __func__ << " enter (relpath " << relpath << " want " << want << ")" << dendl;
tout(cct) << "statx" << std::endl;
tout(cct) << relpath << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
filepath path(relpath);
InodeRef in;
unsigned mask = statx_to_mask(flags, want);
+ std::scoped_lock lock(client_lock);
int r = path_walk(path, &in, perms, !(flags & AT_SYMLINK_NOFOLLOW), mask);
if (r < 0)
return r;
int Client::lstat(const char *relpath, struct stat *stbuf,
const UserPerm& perms, frag_info_t *dirstat, int mask)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
ldout(cct, 3) << __func__ << " enter (relpath " << relpath << " mask " << mask << ")" << dendl;
tout(cct) << __func__ << std::endl;
tout(cct) << relpath << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
filepath path(relpath);
InodeRef in;
+
+ std::scoped_lock lock(client_lock);
// don't follow symlinks
int r = path_walk(path, &in, perms, false, mask);
if (r < 0)
int Client::chmod(const char *relpath, mode_t mode, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << relpath << std::endl;
tout(cct) << mode << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
filepath path(relpath);
InodeRef in;
+
+ std::scoped_lock lock(client_lock);
int r = path_walk(path, &in, perms);
if (r < 0)
return r;
int Client::fchmod(int fd, mode_t mode, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << fd << std::endl;
tout(cct) << mode << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
Fh *f = get_filehandle(fd);
if (!f)
return -EBADF;
int Client::lchmod(const char *relpath, mode_t mode, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << relpath << std::endl;
tout(cct) << mode << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
filepath path(relpath);
InodeRef in;
+
+ std::scoped_lock lock(client_lock);
// don't follow symlinks
int r = path_walk(path, &in, perms, false);
if (r < 0)
int Client::chown(const char *relpath, uid_t new_uid, gid_t new_gid,
const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << relpath << std::endl;
tout(cct) << new_uid << std::endl;
tout(cct) << new_gid << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
filepath path(relpath);
InodeRef in;
+
+ std::scoped_lock lock(client_lock);
int r = path_walk(path, &in, perms);
if (r < 0)
return r;
int Client::fchown(int fd, uid_t new_uid, gid_t new_gid, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << fd << std::endl;
tout(cct) << new_uid << std::endl;
tout(cct) << new_gid << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
Fh *f = get_filehandle(fd);
if (!f)
return -EBADF;
int Client::lchown(const char *relpath, uid_t new_uid, gid_t new_gid,
const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << relpath << std::endl;
tout(cct) << new_uid << std::endl;
tout(cct) << new_gid << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
filepath path(relpath);
InodeRef in;
+
+ std::scoped_lock lock(client_lock);
// don't follow symlinks
int r = path_walk(path, &in, perms, false);
if (r < 0)
int Client::utimes(const char *relpath, struct timeval times[2],
const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << relpath << std::endl;
tout(cct) << "atime: " << times[0].tv_sec << "." << times[0].tv_usec
tout(cct) << "mtime: " << times[1].tv_sec << "." << times[1].tv_usec
<< std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
filepath path(relpath);
InodeRef in;
+
+ std::scoped_lock lock(client_lock);
int r = path_walk(path, &in, perms);
if (r < 0)
return r;
int Client::lutimes(const char *relpath, struct timeval times[2],
const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << relpath << std::endl;
tout(cct) << "atime: " << times[0].tv_sec << "." << times[0].tv_usec
tout(cct) << "mtime: " << times[1].tv_sec << "." << times[1].tv_usec
<< std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
filepath path(relpath);
InodeRef in;
+
+ std::scoped_lock lock(client_lock);
int r = path_walk(path, &in, perms, false);
if (r < 0)
return r;
int Client::futimens(int fd, struct timespec times[2], const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << fd << std::endl;
tout(cct) << "atime: " << times[0].tv_sec << "." << times[0].tv_nsec
<< std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
Fh *f = get_filehandle(fd);
if (!f)
return -EBADF;
int Client::flock(int fd, int operation, uint64_t owner)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << fd << std::endl;
tout(cct) << operation << std::endl;
tout(cct) << owner << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
Fh *f = get_filehandle(fd);
if (!f)
return -EBADF;
int Client::opendir(const char *relpath, dir_result_t **dirpp, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << relpath << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
filepath path(relpath);
InodeRef in;
+
+ std::scoped_lock lock(client_lock);
int r = path_walk(path, &in, perms, true);
if (r < 0)
return r;
void Client::rewinddir(dir_result_t *dirp)
{
- std::lock_guard lock(client_lock);
ldout(cct, 3) << __func__ << "(" << dirp << ")" << dendl;
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return;
+ std::lock_guard lock(client_lock);
dir_result_t *d = static_cast<dir_result_t*>(dirp);
_readdir_drop_dirp_buffer(d);
d->reset();
void Client::seekdir(dir_result_t *dirp, loff_t offset)
{
- std::lock_guard lock(client_lock);
-
ldout(cct, 3) << __func__ << "(" << dirp << ", " << offset << ")" << dendl;
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return;
+ std::lock_guard lock(client_lock);
+
if (offset == dirp->offset)
return;
{
int caps = statx_to_mask(flags, want);
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard lock(client_lock);
+
dir_result_t *dirp = static_cast<dir_result_t*>(d);
ldout(cct, 10) << __func__ << " " << *dirp->inode << " offset " << hex << dirp->offset
mode_t mode, int stripe_unit, int stripe_count,
int object_size, const char *data_pool)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
ldout(cct, 3) << "open enter(" << relpath << ", " << ceph_flags_sys2wire(flags) << "," << mode << ")" << dendl;
tout(cct) << "open" << std::endl;
tout(cct) << relpath << std::endl;
tout(cct) << ceph_flags_sys2wire(flags) << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
Fh *fh = NULL;
#if defined(__linux__) && defined(O_PATH)
bool created = false;
/* O_CREATE with O_EXCL enforces O_NOFOLLOW. */
bool followsym = !((flags & O_NOFOLLOW) || ((flags & O_CREAT) && (flags & O_EXCL)));
+
+ std::scoped_lock lock(client_lock);
int r = path_walk(path, &in, perms, followsym, ceph_caps_for_mode(mode));
if (r == 0 && (flags & O_CREAT) && (flags & O_EXCL))
int Client::lookup_hash(inodeno_t ino, inodeno_t dirino, const char *name,
const UserPerm& perms)
{
- std::lock_guard lock(client_lock);
ldout(cct, 3) << __func__ << " enter(" << ino << ", #" << dirino << "/" << name << ")" << dendl;
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard lock(client_lock);
MetaRequest *req = new MetaRequest(CEPH_MDS_OP_LOOKUPHASH);
filepath path(ino);
req->set_filepath(path);
{
ldout(cct, 8) << __func__ << " enter(" << ino << ")" << dendl;
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
MetaRequest *req = new MetaRequest(CEPH_MDS_OP_LOOKUPINO);
ceph_assert(parent->is_dir());
ldout(cct, 3) << __func__ << " enter(" << ino->ino << ")" << dendl;
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
MetaRequest *req = new MetaRequest(CEPH_MDS_OP_LOOKUPNAME);
int Client::close(int fd)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
ldout(cct, 3) << "close enter(" << fd << ")" << dendl;
tout(cct) << "close" << std::endl;
tout(cct) << fd << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
Fh *fh = get_filehandle(fd);
if (!fh)
return -EBADF;
loff_t Client::lseek(int fd, loff_t offset, int whence)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << "lseek" << std::endl;
tout(cct) << fd << std::endl;
tout(cct) << offset << std::endl;
tout(cct) << whence << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
Fh *f = get_filehandle(fd);
if (!f)
return -EBADF;
int Client::read(int fd, char *buf, loff_t size, loff_t offset)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << "read" << std::endl;
tout(cct) << fd << std::endl;
tout(cct) << size << std::endl;
tout(cct) << offset << std::endl;
std::unique_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
Fh *f = get_filehandle(fd);
if (!f)
return -EBADF;
put_cap_ref(in, CEPH_CAP_FILE_BUFFER);
ldout(cct, 15) << __func__ << " unsafe_sync_write = " << unsafe_sync_write << dendl;
- if (unsafe_sync_write == 0 && unmounting) {
+ if (unsafe_sync_write == 0 && is_unmounting()) {
ldout(cct, 10) << __func__ << " -- no more unsafe writes, unmount can proceed" << dendl;
mount_cond.notify_all();
}
int Client::write(int fd, const char *buf, loff_t size, loff_t offset)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << "write" << std::endl;
tout(cct) << fd << std::endl;
tout(cct) << size << std::endl;
tout(cct) << offset << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
Fh *fh = get_filehandle(fd);
if (!fh)
return -EBADF;
int Client::_preadv_pwritev(int fd, const struct iovec *iov, unsigned iovcnt, int64_t offset, bool write)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << fd << std::endl;
tout(cct) << offset << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
Fh *fh = get_filehandle(fd);
if (!fh)
return -EBADF;
int Client::ftruncate(int fd, loff_t length, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
tout(cct) << fd << std::endl;
tout(cct) << length << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
Fh *f = get_filehandle(fd);
if (!f)
return -EBADF;
int Client::fsync(int fd, bool syncdataonly)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << "fsync" << std::endl;
tout(cct) << fd << std::endl;
tout(cct) << syncdataonly << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
Fh *f = get_filehandle(fd);
if (!f)
return -EBADF;
int Client::fstat(int fd, struct stat *stbuf, const UserPerm& perms, int mask)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << "fstat mask " << hex << mask << dec << std::endl;
tout(cct) << fd << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
Fh *f = get_filehandle(fd);
if (!f)
return -EBADF;
int Client::fstatx(int fd, struct ceph_statx *stx, const UserPerm& perms,
unsigned int want, unsigned int flags)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << "fstatx flags " << hex << flags << " want " << want << dec << std::endl;
tout(cct) << fd << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
Fh *f = get_filehandle(fd);
if (!f)
return -EBADF;
int Client::chdir(const char *relpath, std::string &new_cwd,
const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << "chdir" << std::endl;
tout(cct) << relpath << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
filepath path(relpath);
InodeRef in;
+
+ std::scoped_lock lock(client_lock);
int r = path_walk(path, &in, perms);
if (r < 0)
return r;
void Client::getcwd(string& dir, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return;
+
std::lock_guard l(client_lock);
- if (!unmounting)
- _getcwd(dir, perms);
+
+ _getcwd(dir, perms);
}
int Client::statfs(const char *path, struct statvfs *stbuf,
const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << std::endl;
unsigned long int total_files_on_fs;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
ceph_statfs stats;
C_SaferCond cond;
+ std::scoped_lock lock(client_lock);
const vector<int64_t> &data_pools = mdsmap->get_data_pools();
if (data_pools.size() == 1) {
objecter->get_fs_stats(stats, data_pools[0], &cond);
{
int r = 0;
+ RWRef_t iref_reader(initialize_state, CLIENT_INITIALIZED);
+ if (!iref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
can_invalidate_dentries = can_invalidate;
if (can_invalidate_dentries) {
int Client::sync_fs()
{
- std::lock_guard l(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard l(client_lock);
+
return _sync_fs();
}
int Client::mksnap(const char *relpath, const char *name, const UserPerm& perm)
{
- std::lock_guard l(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard l(client_lock);
+
filepath path(relpath);
InodeRef in;
int r = path_walk(path, &in, perm);
int Client::rmsnap(const char *relpath, const char *name, const UserPerm& perms)
{
- std::lock_guard l(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard l(client_lock);
+
filepath path(relpath);
InodeRef in;
int r = path_walk(path, &in, perms);
// =============================
// expose caps
-int Client::get_caps_issued(int fd) {
+int Client::get_caps_issued(int fd)
+{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
std::lock_guard lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
Fh *f = get_filehandle(fd);
if (!f)
return -EBADF;
int Client::get_caps_issued(const char *path, const UserPerm& perms)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard lock(client_lock);
+
filepath p(path);
InodeRef in;
int r = path_walk(p, &in, perms, true);
int Client::ll_lookup(Inode *parent, const char *name, struct stat *attr,
Inode **out, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
vinodeno_t vparent = _get_vino(parent);
ldout(cct, 3) << __func__ << " " << vparent << " " << name << dendl;
tout(cct) << __func__ << std::endl;
tout(cct) << name << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
int r = 0;
if (!fuse_default_permissions) {
Inode **inode)
{
ceph_assert(inode != NULL);
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
std::lock_guard lock(client_lock);
ldout(cct, 3) << "ll_lookup_inode " << ino << dendl;
-
- if (unmounting)
- return -ENOTCONN;
// Num1: get inode and *inode
int r = _lookup_ino(ino, perms, inode);
struct ceph_statx *stx, unsigned want, unsigned flags,
const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
vinodeno_t vparent = _get_vino(parent);
ldout(cct, 3) << __func__ << " " << vparent << " " << name << dendl;
tout(cct) << "ll_lookupx" << std::endl;
tout(cct) << name << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
int r = 0;
if (!fuse_default_permissions) {
int Client::ll_walk(const char* name, Inode **out, struct ceph_statx *stx,
unsigned int want, unsigned int flags, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
filepath fp(name, 0);
InodeRef in;
int rc;
tout(cct) << name << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
rc = path_walk(fp, &in, perms, !(flags & AT_SYMLINK_NOFOLLOW), mask);
if (rc < 0) {
/* zero out mask, just in case... */
tout(cct) << count << std::endl;
// Ignore forget if we're no longer mounted
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return true;
if (ino == 1) return true; // ignore forget on root.
Inode *Client::ll_get_inode(ino_t ino)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return NULL;
+ std::lock_guard lock(client_lock);
+
vinodeno_t vino = _map_faked_ino(ino);
unordered_map<vinodeno_t,Inode*>::iterator p = inode_map.find(vino);
if (p == inode_map.end())
Inode *Client::ll_get_inode(vinodeno_t vino)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return NULL;
+ std::lock_guard lock(client_lock);
+
unordered_map<vinodeno_t,Inode*>::iterator p = inode_map.find(vino);
if (p == inode_map.end())
return NULL;
int Client::ll_getattr(Inode *in, struct stat *attr, const UserPerm& perms)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard lock(client_lock);
+
int res = _ll_getattr(in, CEPH_STAT_CAP_INODE_ALL, perms);
if (res == 0)
int Client::ll_getattrx(Inode *in, struct ceph_statx *stx, unsigned int want,
unsigned int flags, const UserPerm& perms)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard lock(client_lock);
+
int res = 0;
unsigned mask = statx_to_mask(flags, want);
int Client::ll_setattrx(Inode *in, struct ceph_statx *stx, int mask,
const UserPerm& perms)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard lock(client_lock);
+
InodeRef target(in);
int res = _ll_setattrx(in, stx, mask, perms, &target);
if (res == 0) {
struct ceph_statx stx;
stat_to_statx(attr, &stx);
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard lock(client_lock);
+
InodeRef target(in);
int res = _ll_setattrx(in, &stx, mask, perms, &target);
if (res == 0) {
int Client::getxattr(const char *path, const char *name, void *value, size_t size,
const UserPerm& perms)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard lock(client_lock);
+
InodeRef in;
int r = Client::path_walk(path, &in, perms, true, CEPH_STAT_CAP_XATTR);
if (r < 0)
int Client::lgetxattr(const char *path, const char *name, void *value, size_t size,
const UserPerm& perms)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard lock(client_lock);
+
InodeRef in;
int r = Client::path_walk(path, &in, perms, false, CEPH_STAT_CAP_XATTR);
if (r < 0)
int Client::fgetxattr(int fd, const char *name, void *value, size_t size,
const UserPerm& perms)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard lock(client_lock);
+
Fh *f = get_filehandle(fd);
if (!f)
return -EBADF;
int Client::listxattr(const char *path, char *list, size_t size,
const UserPerm& perms)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard lock(client_lock);
+
InodeRef in;
int r = Client::path_walk(path, &in, perms, true, CEPH_STAT_CAP_XATTR);
if (r < 0)
int Client::llistxattr(const char *path, char *list, size_t size,
const UserPerm& perms)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard lock(client_lock);
+
InodeRef in;
int r = Client::path_walk(path, &in, perms, false, CEPH_STAT_CAP_XATTR);
if (r < 0)
int Client::flistxattr(int fd, char *list, size_t size, const UserPerm& perms)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard lock(client_lock);
+
Fh *f = get_filehandle(fd);
if (!f)
return -EBADF;
int Client::removexattr(const char *path, const char *name,
const UserPerm& perms)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard lock(client_lock);
+
InodeRef in;
int r = Client::path_walk(path, &in, perms, true);
if (r < 0)
int Client::lremovexattr(const char *path, const char *name,
const UserPerm& perms)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard lock(client_lock);
+
InodeRef in;
int r = Client::path_walk(path, &in, perms, false);
if (r < 0)
int Client::fremovexattr(int fd, const char *name, const UserPerm& perms)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard lock(client_lock);
+
Fh *f = get_filehandle(fd);
if (!f)
return -EBADF;
{
_setxattr_maybe_wait_for_osdmap(name, value, size);
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard lock(client_lock);
+
InodeRef in;
int r = Client::path_walk(path, &in, perms, true);
if (r < 0)
{
_setxattr_maybe_wait_for_osdmap(name, value, size);
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard lock(client_lock);
+
InodeRef in;
int r = Client::path_walk(path, &in, perms, false);
if (r < 0)
{
_setxattr_maybe_wait_for_osdmap(name, value, size);
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard lock(client_lock);
+
Fh *f = get_filehandle(fd);
if (!f)
return -EBADF;
int Client::ll_getxattr(Inode *in, const char *name, void *value,
size_t size, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
vinodeno_t vino = _get_vino(in);
ldout(cct, 3) << __func__ << " " << vino << " " << name << " size " << size << dendl;
tout(cct) << name << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
if (!fuse_default_permissions) {
int r = xattr_permission(in, name, MAY_READ, perms);
if (r < 0)
int Client::ll_listxattr(Inode *in, char *names, size_t size,
const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
vinodeno_t vino = _get_vino(in);
ldout(cct, 3) << __func__ << " " << vino << " size " << size << dendl;
tout(cct) << size << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
return _listxattr(in, names, size, perms);
}
int Client::ll_setxattr(Inode *in, const char *name, const void *value,
size_t size, int flags, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
_setxattr_maybe_wait_for_osdmap(name, value, size);
vinodeno_t vino = _get_vino(in);
tout(cct) << name << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
if (!fuse_default_permissions) {
int r = xattr_permission(in, name, MAY_WRITE, perms);
if (r < 0)
int Client::ll_removexattr(Inode *in, const char *name, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
vinodeno_t vino = _get_vino(in);
ldout(cct, 3) << "ll_removexattr " << vino << " " << name << dendl;
tout(cct) << name << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
if (!fuse_default_permissions) {
int r = xattr_permission(in, name, MAY_WRITE, perms);
if (r < 0)
int Client::ll_readlink(Inode *in, char *buf, size_t buflen, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
vinodeno_t vino = _get_vino(in);
ldout(cct, 3) << "ll_readlink " << vino << dendl;
tout(cct) << vino.ino.val << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
for (auto dn : in->dentries) {
touch_dn(dn);
}
dev_t rdev, struct stat *attr, Inode **out,
const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
vinodeno_t vparent = _get_vino(parent);
ldout(cct, 3) << "ll_mknod " << vparent << " " << name << dendl;
tout(cct) << rdev << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
if (!fuse_default_permissions) {
int r = may_create(parent, perms);
if (r < 0)
struct ceph_statx *stx, unsigned want, unsigned flags,
const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
unsigned caps = statx_to_mask(flags, want);
+
vinodeno_t vparent = _get_vino(parent);
ldout(cct, 3) << "ll_mknodx " << vparent << " " << name << dendl;
tout(cct) << rdev << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
if (!fuse_default_permissions) {
int r = may_create(parent, perms);
int Client::ll_mkdir(Inode *parent, const char *name, mode_t mode,
struct stat *attr, Inode **out, const UserPerm& perm)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
vinodeno_t vparent = _get_vino(parent);
ldout(cct, 3) << "ll_mkdir " << vparent << " " << name << dendl;
tout(cct) << mode << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
if (!fuse_default_permissions) {
int r = may_create(parent, perm);
struct ceph_statx *stx, unsigned want, unsigned flags,
const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
vinodeno_t vparent = _get_vino(parent);
ldout(cct, 3) << "ll_mkdirx " << vparent << " " << name << dendl;
tout(cct) << mode << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
if (!fuse_default_permissions) {
int r = may_create(parent, perms);
int Client::ll_symlink(Inode *parent, const char *name, const char *value,
struct stat *attr, Inode **out, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
vinodeno_t vparent = _get_vino(parent);
ldout(cct, 3) << "ll_symlink " << vparent << " " << name << " -> " << value
tout(cct) << value << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
if (!fuse_default_permissions) {
int r = may_create(parent, perms);
Inode **out, struct ceph_statx *stx, unsigned want,
unsigned flags, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
vinodeno_t vparent = _get_vino(parent);
ldout(cct, 3) << "ll_symlinkx " << vparent << " " << name << " -> " << value
tout(cct) << value << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
if (!fuse_default_permissions) {
int r = may_create(parent, perms);
int Client::ll_unlink(Inode *in, const char *name, const UserPerm& perm)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
vinodeno_t vino = _get_vino(in);
ldout(cct, 3) << "ll_unlink " << vino << " " << name << dendl;
tout(cct) << name << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
if (!fuse_default_permissions) {
int r = may_delete(in, name, perm);
int Client::ll_rmdir(Inode *in, const char *name, const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
vinodeno_t vino = _get_vino(in);
ldout(cct, 3) << "ll_rmdir " << vino << " " << name << dendl;
tout(cct) << name << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
if (!fuse_default_permissions) {
int r = may_delete(in, name, perms);
int Client::ll_rename(Inode *parent, const char *name, Inode *newparent,
const char *newname, const UserPerm& perm)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
vinodeno_t vparent = _get_vino(parent);
vinodeno_t vnewparent = _get_vino(newparent);
tout(cct) << newname << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
if (!fuse_default_permissions) {
int r = may_delete(parent, name, perm);
int Client::ll_link(Inode *in, Inode *newparent, const char *newname,
const UserPerm& perm)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
vinodeno_t vino = _get_vino(in);
vinodeno_t vnewparent = _get_vino(newparent);
tout(cct) << vnewparent << std::endl;
tout(cct) << newname << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
InodeRef target;
+ std::scoped_lock lock(client_lock);
+
if (!fuse_default_permissions) {
if (S_ISDIR(in->mode))
return -EPERM;
int Client::ll_opendir(Inode *in, int flags, dir_result_t** dirpp,
const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
vinodeno_t vino = _get_vino(in);
ldout(cct, 3) << "ll_opendir " << vino << dendl;
tout(cct) << vino.ino.val << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
if (!fuse_default_permissions) {
int r = may_open(in, flags, perms);
int Client::ll_releasedir(dir_result_t *dirp)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
ldout(cct, 3) << "ll_releasedir " << dirp << dendl;
tout(cct) << "ll_releasedir" << std::endl;
tout(cct) << (unsigned long)dirp << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
_closedir(dirp);
return 0;
int Client::ll_fsyncdir(dir_result_t *dirp)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
ldout(cct, 3) << "ll_fsyncdir " << dirp << dendl;
tout(cct) << "ll_fsyncdir" << std::endl;
tout(cct) << (unsigned long)dirp << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
return _fsync(dirp->inode.get(), false);
}
{
ceph_assert(!(flags & O_CREAT));
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
vinodeno_t vino = _get_vino(in);
ldout(cct, 3) << "ll_open " << vino << " " << ceph_flags_sys2wire(flags) << dendl;
tout(cct) << ceph_flags_sys2wire(flags) << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
int r;
if (!fuse_default_permissions) {
int flags, struct stat *attr, Inode **outp, Fh **fhp,
const UserPerm& perms)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
std::lock_guard lock(client_lock);
InodeRef in;
- if (unmounting)
- return -ENOTCONN;
-
int r = _ll_create(parent, name, mode, flags, &in, CEPH_STAT_CAP_INODE_ALL,
fhp, perms);
if (r >= 0) {
const UserPerm& perms)
{
unsigned caps = statx_to_mask(lflags, want);
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
std::lock_guard lock(client_lock);
InodeRef in;
- if (unmounting)
- return -ENOTCONN;
-
int r = _ll_create(parent, name, mode, oflags, &in, caps, fhp, perms);
if (r >= 0) {
ceph_assert(in);
loff_t Client::ll_lseek(Fh *fh, loff_t offset, int whence)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << "ll_lseek" << std::endl;
tout(cct) << offset << std::endl;
tout(cct) << whence << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
return _lseek(fh, offset, whence);
}
int Client::ll_read(Fh *fh, loff_t off, loff_t len, bufferlist *bl)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
ldout(cct, 3) << "ll_read " << fh << " " << fh->inode->ino << " " << " " << off << "~" << len << dendl;
tout(cct) << "ll_read" << std::endl;
tout(cct) << (unsigned long)fh << std::endl;
tout(cct) << off << std::endl;
tout(cct) << len << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
/* We can't return bytes written larger than INT_MAX, clamp len to that */
len = std::min(len, (loff_t)INT_MAX);
+ std::scoped_lock lock(client_lock);
+
int r = _read(fh, off, len, bl);
ldout(cct, 3) << "ll_read " << fh << " " << off << "~" << len << " = " << r
<< dendl;
uint64_t length,
file_layout_t* layout)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
vinodeno_t vino = _get_vino(in);
C_SaferCond onfinish;
bufferlist bl;
+ std::scoped_lock lock(client_lock);
+
objecter->read(oid,
object_locator_t(layout->pool_id),
offset,
vinodeno_t vino = ll_get_vino(in);
int r = 0;
std::unique_ptr<C_SaferCond> onsafe = nullptr;
-
+
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
if (length == 0) {
return -EINVAL;
}
/* lock just in time */
client_lock.lock();
- if (unmounting) {
- client_lock.unlock();
- return -ENOTCONN;
- }
-
objecter->write(oid,
object_locator_t(layout->pool_id),
offset,
uint64_t offset,
uint64_t length)
{
- std::lock_guard lock(client_lock);
/*
BarrierContext *bctx;
vinodeno_t vino = _get_vino(in);
return -EINVAL;
}
+ std::scoped_lock lock(client_lock);
map<uint64_t, BarrierContext*>::iterator p = barriers.find(ino);
if (p != barriers.end()) {
barrier_interval civ(offset, offset + length);
tout(cct) << off << std::endl;
tout(cct) << len << std::endl;
- std::scoped_lock lock(client_lock);
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
/* We can't return bytes written larger than INT_MAX, clamp len to that */
len = std::min(len, (loff_t)INT_MAX);
+ std::scoped_lock lock(client_lock);
+
int r = _write(fh, off, len, data, NULL, 0);
ldout(cct, 3) << "ll_write " << fh << " " << off << "~" << len << " = " << r
<< dendl;
int64_t Client::ll_writev(struct Fh *fh, const struct iovec *iov, int iovcnt, int64_t off)
{
- std::lock_guard lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
+ std::scoped_lock lock(client_lock);
return _preadv_pwritev_locked(fh, iov, iovcnt, off, true, false);
}
int64_t Client::ll_readv(struct Fh *fh, const struct iovec *iov, int iovcnt, int64_t off)
{
- std::lock_guard lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
+ std::scoped_lock lock(client_lock);
return _preadv_pwritev_locked(fh, iov, iovcnt, off, false, false);
}
int Client::ll_flush(Fh *fh)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
ldout(cct, 3) << "ll_flush " << fh << " " << fh->inode->ino << " " << dendl;
tout(cct) << "ll_flush" << std::endl;
tout(cct) << (unsigned long)fh << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
return _flush(fh);
}
int Client::ll_fsync(Fh *fh, bool syncdataonly)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
ldout(cct, 3) << "ll_fsync " << fh << " " << fh->inode->ino << " " << dendl;
tout(cct) << "ll_fsync" << std::endl;
tout(cct) << (unsigned long)fh << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
int r = _fsync(fh, syncdataonly);
if (r) {
// If we're returning an error, clear it from the FH
int Client::ll_sync_inode(Inode *in, bool syncdataonly)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
ldout(cct, 3) << "ll_sync_inode " << *in << " " << dendl;
tout(cct) << "ll_sync_inode" << std::endl;
tout(cct) << (unsigned long)in << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
return _fsync(in, syncdataonly);
}
int Client::ll_fallocate(Fh *fh, int mode, int64_t offset, int64_t length)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
ldout(cct, 3) << __func__ << " " << fh << " " << fh->inode->ino << " " << dendl;
tout(cct) << __func__ << " " << mode << " " << offset << " " << length << std::endl;
tout(cct) << (unsigned long)fh << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
return _fallocate(fh, mode, offset, length);
}
int Client::fallocate(int fd, int mode, loff_t offset, loff_t length)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
tout(cct) << __func__ << " " << " " << fd << mode << " " << offset << " " << length << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
Fh *fh = get_filehandle(fd);
if (!fh)
return -EBADF;
int Client::ll_release(Fh *fh)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
ldout(cct, 3) << __func__ << " (fh)" << fh << " " << fh->inode->ino << " " <<
dendl;
tout(cct) << __func__ << " (fh)" << std::endl;
tout(cct) << (unsigned long)fh << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
if (ll_unclosed_fh_set.count(fh))
ll_unclosed_fh_set.erase(fh);
int Client::ll_getlk(Fh *fh, struct flock *fl, uint64_t owner)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
ldout(cct, 3) << "ll_getlk (fh)" << fh << " " << fh->inode->ino << dendl;
tout(cct) << "ll_getk (fh)" << (unsigned long)fh << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
return _getlk(fh, fl, owner);
}
int Client::ll_setlk(Fh *fh, struct flock *fl, uint64_t owner, int sleep)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
ldout(cct, 3) << __func__ << " (fh) " << fh << " " << fh->inode->ino << dendl;
tout(cct) << __func__ << " (fh)" << (unsigned long)fh << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
return _setlk(fh, fl, owner, sleep);
}
int Client::ll_flock(Fh *fh, int cmd, uint64_t owner)
{
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
+ return -ENOTCONN;
+
ldout(cct, 3) << __func__ << " (fh) " << fh << " " << fh->inode->ino << dendl;
tout(cct) << __func__ << " (fh)" << (unsigned long)fh << std::endl;
std::scoped_lock lock(client_lock);
- if (unmounting)
- return -ENOTCONN;
-
return _flock(fh, cmd, owner);
}
int Client::set_deleg_timeout(uint32_t timeout)
{
- std::lock_guard lock(client_lock);
+ std::scoped_lock lock(client_lock);
/*
* The whole point is to prevent blacklisting so we must time out the
{
int ret = -EINVAL;
- std::lock_guard lock(client_lock);
-
- if (!mounted)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::scoped_lock lock(client_lock);
+
Inode *inode = fh->inode.get();
switch(cmd) {
int Client::describe_layout(const char *relpath, file_layout_t *lp,
const UserPerm& perms)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::scoped_lock lock(client_lock);
+
filepath path(relpath);
InodeRef in;
int r = path_walk(path, &in, perms);
int Client::fdescribe_layout(int fd, file_layout_t *lp)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::scoped_lock lock(client_lock);
+
Fh *f = get_filehandle(fd);
if (!f)
return -EBADF;
int64_t Client::get_default_pool_id()
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::scoped_lock lock(client_lock);
+
/* first data pool is the default */
return mdsmap->get_first_data_pool();
}
int64_t Client::get_pool_id(const char *pool_name)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::lock_guard lock(client_lock);
+
return objecter->with_osdmap(std::mem_fn(&OSDMap::lookup_pg_pool_name),
pool_name);
}
string Client::get_pool_name(int64_t pool)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return string();
+ std::scoped_lock lock(client_lock);
+
return objecter->with_osdmap([pool](const OSDMap& o) {
return o.have_pg_pool(pool) ? o.get_pool_name(pool) : string();
});
int Client::get_pool_replication(int64_t pool)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::scoped_lock lock(client_lock);
+
return objecter->with_osdmap([pool](const OSDMap& o) {
return o.have_pg_pool(pool) ? o.get_pg_pool(pool)->get_size() : -ENOENT;
});
int Client::get_file_extent_osds(int fd, loff_t off, loff_t *len, vector<int>& osds)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::scoped_lock lock(client_lock);
+
Fh *f = get_filehandle(fd);
if (!f)
return -EBADF;
int Client::get_osd_crush_location(int id, vector<pair<string, string> >& path)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::scoped_lock lock(client_lock);
+
if (id < 0)
return -EINVAL;
return objecter->with_osdmap([&](const OSDMap& o) {
int Client::get_file_stripe_address(int fd, loff_t offset,
vector<entity_addr_t>& address)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::scoped_lock lock(client_lock);
+
Fh *f = get_filehandle(fd);
if (!f)
return -EBADF;
int Client::get_osd_addr(int osd, entity_addr_t& addr)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::scoped_lock lock(client_lock);
+
return objecter->with_osdmap([&](const OSDMap& o) {
if (!o.exists(osd))
return -ENOENT;
int Client::enumerate_layout(int fd, vector<ObjectExtent>& result,
loff_t length, loff_t offset)
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::scoped_lock lock(client_lock);
+
Fh *f = get_filehandle(fd);
if (!f)
return -EBADF;
/* find an osd with the same ip. -ENXIO if none. */
int Client::get_local_osd()
{
- std::lock_guard lock(client_lock);
-
- if (unmounting)
+ RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
+ if (!mref_reader.is_state_satisfied())
return -ENOTCONN;
+ std::scoped_lock lock(client_lock);
+
objecter->with_osdmap([this](const OSDMap& o) {
if (o.get_epoch() != local_osd_epoch) {
local_osd = o.find_osd_on_ip(messenger->get_myaddrs().front());
void Client::ms_handle_remote_reset(Connection *con)
{
+ std::scoped_lock lock(client_lock);
ldout(cct, 0) << __func__ << " on " << con->get_peer_addr() << dendl;
- std::lock_guard l(client_lock);
switch (con->get_peer_type()) {
case CEPH_ENTITY_TYPE_MDS:
{
// called before mount
void Client::set_uuid(const std::string& uuid)
{
+ RWRef_t iref_reader(initialize_state, CLIENT_INITIALIZED);
+ ceph_assert(iref_reader.is_state_satisfied());
+
std::lock_guard l(client_lock);
- assert(initialized);
assert(!uuid.empty());
metadata["uuid"] = uuid;
// called before mount. 0 means infinite
void Client::set_session_timeout(unsigned timeout)
{
+ RWRef_t iref_reader(initialize_state, CLIENT_INITIALIZED);
+ ceph_assert(iref_reader.is_state_satisfied());
+
std::lock_guard l(client_lock);
- assert(initialized);
metadata["timeout"] = stringify(timeout);
}
int Client::start_reclaim(const std::string& uuid, unsigned flags,
const std::string& fs_name)
{
- std::unique_lock l(client_lock);
- if (!initialized)
+ RWRef_t iref_reader(initialize_state, CLIENT_INITIALIZED);
+ if (!iref_reader.is_state_satisfied())
return -ENOTCONN;
if (uuid.empty())
return -EINVAL;
+ std::unique_lock l(client_lock);
{
auto it = metadata.find("uuid");
if (it != metadata.end() && it->second == uuid)
int StandaloneClient::init()
{
+ RWRef_t iref_writer(initialize_state, CLIENT_INITIALIZING, false);
+ ceph_assert(iref_writer.is_first_writer());
+
_pre_init();
objecter->init();
client_lock.lock();
- ceph_assert(!is_initialized());
messenger->add_dispatcher_tail(objecter);
messenger->add_dispatcher_tail(this);
client_lock.unlock();
_finish_init();
+ iref_writer.update_state(CLIENT_INITIALIZED);
return 0;
}
projects / ceph-ci.git / commitdiff