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; }