int
nfs3_fh_build_child_fh (struct nfs3_fh *parent, struct iatt *newstat,
struct nfs3_fh *newfh)
{
if ((!parent) || (!newstat) || (!newfh))
return -1;
nfs3_fh_init (newfh, newstat);
gf_uuid_copy (newfh->exportid, parent->exportid);
gf_uuid_copy (newfh->mountid, parent->mountid);
return 0;
}
struct nfs3_fh
nfs3_fh_build_uuid_root_fh (uuid_t volumeid, uuid_t mountid)
{
struct nfs3_fh fh = {{0}, };
struct iatt buf = {0, };
uuid_t root = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
gf_uuid_copy (buf.ia_gfid, root);
nfs3_fh_init (&fh, &buf);
gf_uuid_copy (fh.exportid, volumeid);
gf_uuid_copy (fh.mountid, mountid);
return fh;
}
int
nfs3_build_fh (inode_t *inode, uuid_t exportid, struct nfs3_fh *newfh)
{
if (!newfh || !inode)
return -1;
newfh->ident[0] = GF_NFSFH_IDENT0;
newfh->ident[1] = GF_NFSFH_IDENT1;
newfh->ident[2] = GF_NFSFH_IDENT2;
newfh->ident[3] = GF_NFSFH_IDENT3;
gf_uuid_copy (newfh->gfid, inode->gfid);
gf_uuid_copy (newfh->exportid, exportid);
/*gf_uuid_copy (newfh->mountid, mountid);*/
return 0;
}
static int
sdfs_build_parent_loc (loc_t *parent, loc_t *child)
{
int ret = -1;
char *path = NULL;
if (!child->parent) {
goto out;
}
parent->inode = inode_ref (child->parent);
path = gf_strdup (child->path);
if (!path) {
ret = -ENOMEM;
goto out;
}
parent->path = dirname(path);
if (!parent->path) {
goto out;
}
gf_uuid_copy (parent->gfid, child->pargfid);
return 0;
out:
GF_FREE (path);
return ret;
}
int
afr_build_parent_loc (loc_t *parent, loc_t *child, int32_t *op_errno)
{
int ret = -1;
char *child_path = NULL;
if (!child->parent) {
if (op_errno)
*op_errno = EINVAL;
goto out;
}
child_path = gf_strdup (child->path);
if (!child_path) {
if (op_errno)
*op_errno = ENOMEM;
goto out;
}
parent->path = gf_strdup (dirname (child_path));
if (!parent->path) {
if (op_errno)
*op_errno = ENOMEM;
goto out;
}
parent->inode = inode_ref (child->parent);
gf_uuid_copy (parent->gfid, child->pargfid);
ret = 0;
out:
GF_FREE (child_path);
return ret;
}
int
nfs3_fh_build_parent_fh (struct nfs3_fh *child, struct iatt *newstat,
struct nfs3_fh *newfh)
{
if ((!child) || (!newstat) || (!newfh))
return -1;
nfs3_fh_init (newfh, newstat);
gf_uuid_copy (newfh->exportid, child->exportid);
return 0;
}
void
nfs3_fh_init (struct nfs3_fh *fh, struct iatt *buf)
{
if ((!fh) || (!buf))
return;
fh->ident[0] = GF_NFSFH_IDENT0;
fh->ident[1] = GF_NFSFH_IDENT1;
fh->ident[2] = GF_NFSFH_IDENT2;
fh->ident[3] = GF_NFSFH_IDENT3;
gf_uuid_copy (fh->gfid, buf->ia_gfid);
}
int
nfs_gfid_loc_fill (inode_table_t *itable, uuid_t gfid, loc_t *loc, int how)
{
int ret = -EFAULT;
inode_t *inode = NULL;
if (!loc)
return ret;
inode = inode_find (itable, gfid);
if (!inode) {
gf_msg_trace (GF_NFS, 0, "Inode not found in itable, will "
"try to create one.");
if (how == NFS_RESOLVE_CREATE) {
gf_msg_trace (GF_NFS, 0, "Inode needs to be created.");
inode = inode_new (itable);
if (!inode) {
gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM,
NFS_MSG_NO_MEMORY, "Failed to "
"allocate memory");
ret = -ENOMEM;
goto err;
}
} else {
gf_msg (GF_NFS, GF_LOG_ERROR, ENOENT,
NFS_MSG_INODE_NOT_FOUND, "Inode not found in "
"itable and no creation was requested.");
ret = -ENOENT;
goto err;
}
} else {
gf_msg_trace (GF_NFS, 0, "Inode was found in the itable.");
}
gf_uuid_copy (loc->gfid, gfid);
ret = nfs_inode_loc_fill (inode, loc, how);
if (ret < 0) {
gf_msg (GF_NFS, GF_LOG_ERROR, -ret,
NFS_MSG_INODE_LOC_FILL_ERROR,
"Inode loc filling failed.: %s", strerror (-ret));
goto err;
}
err:
if (inode)
inode_unref (inode);
return ret;
}
struct nfs3_fh
nfs3_fh_build_indexed_root_fh (xlator_list_t *cl, xlator_t *xl)
{
struct nfs3_fh fh = {{0}, };
struct iatt buf = {0, };
uuid_t root = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
if ((!cl) || (!xl))
return fh;
gf_uuid_copy (buf.ia_gfid, root);
nfs3_fh_init (&fh, &buf);
fh.exportid [15] = nfs_xlator_to_xlid (cl, xl);
return fh;
}
int
nfs_loc_fill (loc_t *loc, inode_t *inode, inode_t *parent, char *path)
{
int ret = -EFAULT;
if (!loc)
return ret;
if (inode) {
loc->inode = inode_ref (inode);
if (!gf_uuid_is_null (inode->gfid))
gf_uuid_copy (loc->gfid, inode->gfid);
}
if (parent)
loc->parent = inode_ref (parent);
if (path) {
loc->path = gf_strdup (path);
if (!loc->path) {
gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM,
NFS_MSG_NO_MEMORY, "strdup failed");
goto loc_wipe;
}
loc->name = strrchr (loc->path, '/');
if (loc->name)
loc->name++;
}
ret = 0;
loc_wipe:
if (ret < 0)
nfs_loc_wipe (loc);
return ret;
}
static int
glusterd_handle_mgmt_v3_unlock_fn (rpcsvc_request_t *req)
{
gd1_mgmt_v3_unlock_req lock_req = {{0},};
int32_t ret = -1;
glusterd_op_lock_ctx_t *ctx = NULL;
xlator_t *this = NULL;
gf_boolean_t is_synctasked = _gf_false;
gf_boolean_t free_ctx = _gf_false;
this = THIS;
GF_ASSERT (this);
GF_ASSERT (req);
ret = xdr_to_generic (req->msg[0], &lock_req,
(xdrproc_t)xdr_gd1_mgmt_v3_unlock_req);
if (ret < 0) {
gf_log (this->name, GF_LOG_ERROR, "Failed to decode unlock "
"request received from peer");
req->rpc_err = GARBAGE_ARGS;
goto out;
}
gf_log (this->name, GF_LOG_DEBUG, "Received volume unlock req "
"from uuid: %s", uuid_utoa (lock_req.uuid));
if (glusterd_peerinfo_find_by_uuid (lock_req.uuid) == NULL) {
gf_log (this->name, GF_LOG_WARNING, "%s doesn't "
"belong to the cluster. Ignoring request.",
uuid_utoa (lock_req.uuid));
ret = -1;
goto out;
}
ctx = GF_CALLOC (1, sizeof (*ctx), gf_gld_mt_op_lock_ctx_t);
if (!ctx) {
ret = -1;
goto out;
}
gf_uuid_copy (ctx->uuid, lock_req.uuid);
ctx->req = req;
ctx->dict = dict_new ();
if (!ctx->dict) {
ret = -1;
goto out;
}
ret = dict_unserialize (lock_req.dict.dict_val,
lock_req.dict.dict_len, &ctx->dict);
if (ret) {
gf_log (this->name, GF_LOG_WARNING,
"failed to unserialize the dictionary");
goto out;
}
is_synctasked = dict_get_str_boolean (ctx->dict,
"is_synctasked", _gf_false);
if (is_synctasked) {
ret = glusterd_syctasked_mgmt_v3_unlock (req, &lock_req, ctx);
if (ret) {
gf_log (this->name, GF_LOG_ERROR,
"Failed to release mgmt_v3_locks");
/* Ignore the return code, as it shouldn't be propagated
* from the handler function so as to avoid double
* deletion of the req
*/
ret = 0;
}
/* The above function does not take ownership of ctx.
* Therefore we need to free the ctx explicitly. */
free_ctx = _gf_true;
}
else {
/* Shouldn't ignore the return code here, and it should
* be propagated from the handler function as in failure
* case it doesn't delete the req object
*/
ret = glusterd_op_state_machine_mgmt_v3_unlock (req, &lock_req,
ctx);
if (ret)
gf_log (this->name, GF_LOG_ERROR,
"Failed to release mgmt_v3_locks");
}
out:
if (ctx && (ret || free_ctx)) {
if (ctx->dict)
dict_unref (ctx->dict);
GF_FREE (ctx);
}
free (lock_req.dict.dict_val);
gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret);
return ret;
}
