diff options
Diffstat (limited to 'xlators/nfs/server')
| -rw-r--r-- | xlators/nfs/server/src/acl3.c | 1560 | ||||
| -rw-r--r-- | xlators/nfs/server/src/auth-cache.c | 543 | ||||
| -rw-r--r-- | xlators/nfs/server/src/exports.c | 1609 | ||||
| -rw-r--r-- | xlators/nfs/server/src/mount3-auth.c | 680 | ||||
| -rw-r--r-- | xlators/nfs/server/src/mount3.c | 6426 | ||||
| -rw-r--r-- | xlators/nfs/server/src/mount3udp_svc.c | 344 | ||||
| -rw-r--r-- | xlators/nfs/server/src/netgroups.c | 1018 | ||||
| -rw-r--r-- | xlators/nfs/server/src/nfs-common.c | 643 | ||||
| -rw-r--r-- | xlators/nfs/server/src/nfs-fops.c | 2349 | ||||
| -rw-r--r-- | xlators/nfs/server/src/nfs-generics.c | 333 | ||||
| -rw-r--r-- | xlators/nfs/server/src/nfs-inodes.c | 764 | ||||
| -rw-r--r-- | xlators/nfs/server/src/nfs.c | 3417 | ||||
| -rw-r--r-- | xlators/nfs/server/src/nfs3-fh.c | 206 | ||||
| -rw-r--r-- | xlators/nfs/server/src/nfs3-helpers.c | 5055 | ||||
| -rw-r--r-- | xlators/nfs/server/src/nfs3.c | 9208 | ||||
| -rw-r--r-- | xlators/nfs/server/src/nlm4.c | 4315 | ||||
| -rw-r--r-- | xlators/nfs/server/src/nlmcbk_svc.c | 157 |
17 files changed, 19018 insertions, 19609 deletions
diff --git a/xlators/nfs/server/src/acl3.c b/xlators/nfs/server/src/acl3.c index 7cd2988928..ff4bcfd8f4 100644 --- a/xlators/nfs/server/src/acl3.c +++ b/xlators/nfs/server/src/acl3.c @@ -27,233 +27,228 @@ #include "nfs-messages.h" static int -acl3_nfs_acl_to_xattr (aclentry *ace, void *xattrbuf, - int aclcount, int defacl); +acl3_nfs_acl_to_xattr(aclentry *ace, void *xattrbuf, int aclcount, int defacl); static int -acl3_nfs_acl_from_xattr (aclentry *ace, void *xattrbuf, - int bufsize, int defacl); +acl3_nfs_acl_from_xattr(aclentry *ace, void *xattrbuf, int bufsize, int defacl); -typedef ssize_t (*acl3_serializer) (struct iovec outmsg, void *args); +typedef ssize_t (*acl3_serializer)(struct iovec outmsg, void *args); -extern void nfs3_call_state_wipe (nfs3_call_state_t *cs); +extern void +nfs3_call_state_wipe(nfs3_call_state_t *cs); extern nfs3_call_state_t * -nfs3_call_state_init (struct nfs3_state *s, rpcsvc_request_t *req, xlator_t *v); +nfs3_call_state_init(struct nfs3_state *s, rpcsvc_request_t *req, xlator_t *v); extern int -nfs3_fh_validate (struct nfs3_fh *fh); +nfs3_fh_validate(struct nfs3_fh *fh); extern void -nfs3_stat_to_fattr3 (struct iatt *buf, fattr3 *fa); - -#define acl3_validate_nfs3_state(request, state, status, label, retval) \ - do { \ - state = rpcsvc_request_program_private (request); \ - if (!state) { \ - gf_msg (GF_ACL, GF_LOG_ERROR, errno, \ - NFS_MSG_STATE_MISSING, \ - "NFSv3 state " \ - "missing from RPC request"); \ - rpcsvc_request_seterr (req, SYSTEM_ERR); \ - status = NFS3ERR_SERVERFAULT; \ - goto label; \ - } \ - } while (0); \ - -#define acl3_validate_gluster_fh(handle, status, errlabel) \ - do { \ - if (!nfs3_fh_validate (handle)) { \ - gf_msg (GF_ACL, GF_LOG_ERROR, EINVAL, \ - NFS_MSG_BAD_HANDLE, \ - "Bad Handle"); \ - status = NFS3ERR_BADHANDLE; \ - goto errlabel; \ - } \ - } while (0) \ - +nfs3_stat_to_fattr3(struct iatt *buf, fattr3 *fa); + +#define acl3_validate_nfs3_state(request, state, status, label, retval) \ + do { \ + state = rpcsvc_request_program_private(request); \ + if (!state) { \ + gf_msg(GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_STATE_MISSING, \ + "NFSv3 state " \ + "missing from RPC request"); \ + rpcsvc_request_seterr(req, SYSTEM_ERR); \ + status = NFS3ERR_SERVERFAULT; \ + goto label; \ + } \ + } while (0); + +#define acl3_validate_gluster_fh(handle, status, errlabel) \ + do { \ + if (!nfs3_fh_validate(handle)) { \ + gf_msg(GF_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_BAD_HANDLE, \ + "Bad Handle"); \ + status = NFS3ERR_BADHANDLE; \ + goto errlabel; \ + } \ + } while (0) extern xlator_t * -nfs3_fh_to_xlator (struct nfs3_state *nfs3, struct nfs3_fh *fh); - -#define acl3_map_fh_to_volume(nfs3state, handle, req, volume, status, label) \ - do { \ - char exportid[256], gfid[256]; \ - rpc_transport_t *trans = NULL; \ - volume = nfs3_fh_to_xlator ((nfs3state), handle); \ - if (!volume) { \ - gf_uuid_unparse (handle->exportid, exportid); \ - gf_uuid_unparse (handle->gfid, gfid); \ - trans = rpcsvc_request_transport (req); \ - gf_msg (GF_ACL, GF_LOG_ERROR, 0, \ - NFS_MSG_FH_TO_VOL_FAIL, "Failed to map " \ - "FH to vol: client=%s, exportid=%s, gfid=%s",\ - trans->peerinfo.identifier, exportid, \ - gfid); \ - gf_msg (GF_ACL, GF_LOG_ERROR, ESTALE, \ - NFS_MSG_VOLUME_ERROR, \ - "Stale nfs client %s must be trying to "\ - "connect to a deleted volume, please " \ - "unmount it.", trans->peerinfo.identifier);\ - status = NFS3ERR_STALE; \ - goto label; \ - } else { \ - gf_msg_trace (GF_ACL, 0, "FH to Volume: %s", \ - volume->name); \ - rpcsvc_request_set_private (req, volume); \ - } \ - } while (0); \ - -#define acl3_volume_started_check(nfs3state, vlm, rtval, erlbl) \ - do { \ - if ((!nfs_subvolume_started (nfs_state (nfs3state->nfsx), vlm))){\ - gf_msg (GF_ACL, GF_LOG_ERROR, 0, NFS_MSG_VOL_DISABLE, \ - "Volume is disabled: %s", \ - vlm->name); \ - rtval = RPCSVC_ACTOR_IGNORE; \ - goto erlbl; \ - } \ - } while (0) \ - -#define acl3_check_fh_resolve_status(cst, nfstat, erlabl) \ - do { \ - xlator_t *xlatorp = NULL; \ - char buf[256], gfid[GF_UUID_BUF_SIZE]; \ - rpc_transport_t *trans = NULL; \ - if ((cst)->resolve_ret < 0) { \ - trans = rpcsvc_request_transport (cst->req); \ - xlatorp = nfs3_fh_to_xlator (cst->nfs3state, \ - &cst->resolvefh); \ - gf_uuid_unparse (cst->resolvefh.gfid, gfid); \ - snprintf (buf, sizeof (buf), "(%s) %s : %s", \ - trans->peerinfo.identifier, \ - xlatorp ? xlatorp->name : "ERR", \ - gfid); \ - gf_msg (GF_ACL, GF_LOG_ERROR, cst->resolve_errno, \ - NFS_MSG_RESOLVE_FH_FAIL, "Unable to resolve "\ - "FH: %s", buf); \ - nfstat = nfs3_errno_to_nfsstat3 (cst->resolve_errno);\ - goto erlabl; \ - } \ - } while (0) \ - -#define acl3_handle_call_state_init(nfs3state, calls, rq, v, opstat, errlabel)\ - do { \ - calls = nfs3_call_state_init ((nfs3state), (rq), v); \ - if (!calls) { \ - gf_msg (GF_ACL, GF_LOG_ERROR, 0, \ - NFS_MSG_INIT_CALL_STAT_FAIL, "Failed to " \ - "init call state"); \ - opstat = NFS3ERR_SERVERFAULT; \ - rpcsvc_request_seterr (req, SYSTEM_ERR); \ - goto errlabel; \ - } \ - } while (0) \ - +nfs3_fh_to_xlator(struct nfs3_state *nfs3, struct nfs3_fh *fh); + +#define acl3_map_fh_to_volume(nfs3state, handle, req, volume, status, label) \ + do { \ + char exportid[256], gfid[256]; \ + rpc_transport_t *trans = NULL; \ + volume = nfs3_fh_to_xlator((nfs3state), handle); \ + if (!volume) { \ + gf_uuid_unparse(handle->exportid, exportid); \ + gf_uuid_unparse(handle->gfid, gfid); \ + trans = rpcsvc_request_transport(req); \ + gf_msg(GF_ACL, GF_LOG_ERROR, 0, NFS_MSG_FH_TO_VOL_FAIL, \ + "Failed to map " \ + "FH to vol: client=%s, exportid=%s, gfid=%s", \ + trans->peerinfo.identifier, exportid, gfid); \ + gf_msg(GF_ACL, GF_LOG_ERROR, ESTALE, NFS_MSG_VOLUME_ERROR, \ + "Stale nfs client %s must be trying to " \ + "connect to a deleted volume, please " \ + "unmount it.", \ + trans->peerinfo.identifier); \ + status = NFS3ERR_STALE; \ + goto label; \ + } else { \ + gf_msg_trace(GF_ACL, 0, "FH to Volume: %s", volume->name); \ + rpcsvc_request_set_private(req, volume); \ + } \ + } while (0); + +#define acl3_volume_started_check(nfs3state, vlm, rtval, erlbl) \ + do { \ + if ((!nfs_subvolume_started(nfs_state(nfs3state->nfsx), vlm))) { \ + gf_msg(GF_ACL, GF_LOG_ERROR, 0, NFS_MSG_VOL_DISABLE, \ + "Volume is disabled: %s", vlm->name); \ + rtval = RPCSVC_ACTOR_IGNORE; \ + goto erlbl; \ + } \ + } while (0) + +#define acl3_check_fh_resolve_status(cst, nfstat, erlabl) \ + do { \ + xlator_t *xlatorp = NULL; \ + char buf[256], gfid[GF_UUID_BUF_SIZE]; \ + rpc_transport_t *trans = NULL; \ + if ((cst)->resolve_ret < 0) { \ + trans = rpcsvc_request_transport(cst->req); \ + xlatorp = nfs3_fh_to_xlator(cst->nfs3state, &cst->resolvefh); \ + gf_uuid_unparse(cst->resolvefh.gfid, gfid); \ + snprintf(buf, sizeof(buf), "(%s) %s : %s", \ + trans->peerinfo.identifier, \ + xlatorp ? xlatorp->name : "ERR", gfid); \ + gf_msg(GF_ACL, GF_LOG_ERROR, cst->resolve_errno, \ + NFS_MSG_RESOLVE_FH_FAIL, \ + "Unable to resolve " \ + "FH: %s", \ + buf); \ + nfstat = nfs3_errno_to_nfsstat3(cst->resolve_errno); \ + goto erlabl; \ + } \ + } while (0) + +#define acl3_handle_call_state_init(nfs3state, calls, rq, v, opstat, errlabel) \ + do { \ + calls = nfs3_call_state_init((nfs3state), (rq), v); \ + if (!calls) { \ + gf_msg(GF_ACL, GF_LOG_ERROR, 0, NFS_MSG_INIT_CALL_STAT_FAIL, \ + "Failed to " \ + "init call state"); \ + opstat = NFS3ERR_SERVERFAULT; \ + rpcsvc_request_seterr(req, SYSTEM_ERR); \ + goto errlabel; \ + } \ + } while (0) int -acl3svc_submit_reply (rpcsvc_request_t *req, void *arg, acl3_serializer sfunc) +acl3svc_submit_reply(rpcsvc_request_t *req, void *arg, acl3_serializer sfunc) { - struct iovec outmsg = {0, }; - struct iobuf *iob = NULL; - struct nfs3_state *nfs3 = NULL; - int ret = -1; - ssize_t msglen = 0; - struct iobref *iobref = NULL; - - if (!req) - return -1; - - nfs3 = (struct nfs3_state *)rpcsvc_request_program_private (req); - if (!nfs3) { - gf_msg (GF_ACL, GF_LOG_ERROR, EINVAL, - NFS_MSG_MNT_STATE_NOT_FOUND, "mount state not found"); - goto ret; - } - - /* First, get the io buffer into which the reply in arg will - * be serialized. - */ - iob = iobuf_get (nfs3->iobpool); - if (!iob) { - gf_msg (GF_ACL, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to get iobuf"); - goto ret; - } - - iobuf_to_iovec (iob, &outmsg); - /* Use the given serializer to translate the give C structure in arg - * to XDR format which will be written into the buffer in outmsg. - */ - msglen = sfunc (outmsg, arg); - if (msglen < 0) { - gf_msg (GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_ENCODE_MSG_FAIL, - "Failed to encode message"); - goto ret; - } - outmsg.iov_len = msglen; - - iobref = iobref_new (); - if (iobref == NULL) { - gf_msg (GF_ACL, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to get iobref"); - goto ret; - } - - ret = iobref_add (iobref, iob); - if (ret) { - gf_msg (GF_ACL, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to add iob to iobref"); - goto ret; - } - - /* Then, submit the message for transmission. */ - ret = rpcsvc_submit_message (req, &outmsg, 1, NULL, 0, iobref); - if (ret == -1) { - gf_msg (GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_REP_SUBMIT_FAIL, - "Reply submission failed"); - goto ret; - } - - ret = 0; + struct iovec outmsg = { + 0, + }; + struct iobuf *iob = NULL; + struct nfs3_state *nfs3 = NULL; + int ret = -1; + ssize_t msglen = 0; + struct iobref *iobref = NULL; + + if (!req) + return -1; + + nfs3 = (struct nfs3_state *)rpcsvc_request_program_private(req); + if (!nfs3) { + gf_msg(GF_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_MNT_STATE_NOT_FOUND, + "mount state not found"); + goto ret; + } + + /* First, get the io buffer into which the reply in arg will + * be serialized. + */ + iob = iobuf_get(nfs3->iobpool); + if (!iob) { + gf_msg(GF_ACL, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to get iobuf"); + goto ret; + } + + iobuf_to_iovec(iob, &outmsg); + /* Use the given serializer to translate the give C structure in arg + * to XDR format which will be written into the buffer in outmsg. + */ + msglen = sfunc(outmsg, arg); + if (msglen < 0) { + gf_msg(GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_ENCODE_MSG_FAIL, + "Failed to encode message"); + goto ret; + } + outmsg.iov_len = msglen; + + iobref = iobref_new(); + if (iobref == NULL) { + gf_msg(GF_ACL, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to get iobref"); + goto ret; + } + + ret = iobref_add(iobref, iob); + if (ret) { + gf_msg(GF_ACL, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to add iob to iobref"); + goto ret; + } + + /* Then, submit the message for transmission. */ + ret = rpcsvc_submit_message(req, &outmsg, 1, NULL, 0, iobref); + if (ret == -1) { + gf_msg(GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_REP_SUBMIT_FAIL, + "Reply submission failed"); + goto ret; + } + + ret = 0; ret: - if (iob) - iobuf_unref (iob); - if (iobref) - iobref_unref (iobref); + if (iob) + iobuf_unref(iob); + if (iobref) + iobref_unref(iobref); - return ret; + return ret; } - int -acl3svc_null (rpcsvc_request_t *req) +acl3svc_null(rpcsvc_request_t *req) { - struct iovec dummyvec = {0, }; + struct iovec dummyvec = { + 0, + }; - if (!req) { - gf_msg (GF_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Got NULL request!"); - return 0; - } - rpcsvc_submit_generic (req, &dummyvec, 1, NULL, 0, NULL); + if (!req) { + gf_msg(GF_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Got NULL request!"); return 0; + } + rpcsvc_submit_generic(req, &dummyvec, 1, NULL, 0, NULL); + return 0; } int -acl3_getacl_reply (rpcsvc_request_t *req, getaclreply *reply) +acl3_getacl_reply(rpcsvc_request_t *req, getaclreply *reply) { - acl3svc_submit_reply (req, (void *)reply, - (acl3_serializer)xdr_serialize_getaclreply); - return 0; + acl3svc_submit_reply(req, (void *)reply, + (acl3_serializer)xdr_serialize_getaclreply); + return 0; } int -acl3_setacl_reply (rpcsvc_request_t *req, setaclreply *reply) +acl3_setacl_reply(rpcsvc_request_t *req, setaclreply *reply) { - acl3svc_submit_reply (req, (void *)reply, - (acl3_serializer)xdr_serialize_setaclreply); - return 0; + acl3svc_submit_reply(req, (void *)reply, + (acl3_serializer)xdr_serialize_setaclreply); + return 0; } /* acl3_getacl_cbk: fetch and decode the ACL in the POSIX_ACL_ACCESS_XATTR @@ -261,63 +256,59 @@ acl3_setacl_reply (rpcsvc_request_t *req, setaclreply *reply) * The POSIX_ACL_ACCESS_XATTR can be set on files and directories. */ int -acl3_getacl_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict, - dict_t *xdata) +acl3_getacl_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - nfs3_call_state_t *cs = NULL; - data_t *data = NULL; - getaclreply *getaclreply = NULL; - int aclcount = 0; - int defacl = 1; /* DEFAULT ACL */ - - if (!frame->local) { - gf_msg (GF_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Invalid argument, frame->local NULL"); - return -EINVAL; - } - cs = frame->local; - getaclreply = &cs->args.getaclreply; - if ((op_ret < 0) && (op_errno != ENODATA && op_errno != ENOATTR)) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - goto err; - } else if (!dict) { - /* no ACL has been set */ - stat = NFS3_OK; - goto err; - } - - getaclreply->aclentry.aclentry_val = cs->aclentry; - - /* getfacl: NFS USER ACL */ - data = dict_get (dict, POSIX_ACL_ACCESS_XATTR); - if (data && data->data) { - aclcount = acl3_nfs_acl_from_xattr (cs->aclentry, - data->data, - data->len, - !defacl); - if (aclcount < 0) { - gf_msg (GF_ACL, GF_LOG_ERROR, aclcount, - NFS_MSG_GET_USER_ACL_FAIL, - "Failed to get USER ACL"); - stat = nfs3_errno_to_nfsstat3 (-aclcount); - goto err; - } - getaclreply->aclcount = aclcount; - getaclreply->aclentry.aclentry_len = aclcount; - } - - acl3_getacl_reply (cs->req, getaclreply); - nfs3_call_state_wipe (cs); - return 0; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + nfs3_call_state_t *cs = NULL; + data_t *data = NULL; + getaclreply *getaclreply = NULL; + int aclcount = 0; + int defacl = 1; /* DEFAULT ACL */ + + if (!frame->local) { + gf_msg(GF_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Invalid argument, frame->local NULL"); + return -EINVAL; + } + cs = frame->local; + getaclreply = &cs->args.getaclreply; + if ((op_ret < 0) && (op_errno != ENODATA && op_errno != ENOATTR)) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + goto err; + } else if (!dict) { + /* no ACL has been set */ + stat = NFS3_OK; + goto err; + } + + getaclreply->aclentry.aclentry_val = cs->aclentry; + + /* getfacl: NFS USER ACL */ + data = dict_get(dict, POSIX_ACL_ACCESS_XATTR); + if (data && data->data) { + aclcount = acl3_nfs_acl_from_xattr(cs->aclentry, data->data, data->len, + !defacl); + if (aclcount < 0) { + gf_msg(GF_ACL, GF_LOG_ERROR, aclcount, NFS_MSG_GET_USER_ACL_FAIL, + "Failed to get USER ACL"); + stat = nfs3_errno_to_nfsstat3(-aclcount); + goto err; + } + getaclreply->aclcount = aclcount; + getaclreply->aclentry.aclentry_len = aclcount; + } + + acl3_getacl_reply(cs->req, getaclreply); + nfs3_call_state_wipe(cs); + return 0; err: - if (getaclreply) - getaclreply->status = stat; - acl3_getacl_reply (cs->req, getaclreply); - nfs3_call_state_wipe (cs); - return 0; + if (getaclreply) + getaclreply->status = stat; + acl3_getacl_reply(cs->req, getaclreply); + nfs3_call_state_wipe(cs); + return 0; } /* acl3_default_getacl_cbk: fetch and decode the ACL set in the @@ -329,625 +320,604 @@ err: * ACL that can be set in POSIX_ACL_DEFAULT_XATTR. */ int -acl3_default_getacl_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict, - dict_t *xdata) +acl3_default_getacl_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *dict, + dict_t *xdata) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - nfs3_call_state_t *cs = NULL; - data_t *data = NULL; - getaclreply *getaclreply = NULL; - int aclcount = 0; - int defacl = 1; /* DEFAULT ACL */ - nfs_user_t nfu = {0, }; - int ret = -1; - - if (!frame->local) { - gf_msg (GF_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Invalid argument, frame->local NULL"); - return -EINVAL; - } - cs = frame->local; - getaclreply = &cs->args.getaclreply; - if ((op_ret < 0) && (op_errno != ENODATA && op_errno != ENOATTR)) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - goto err; - } else if (!dict) { - /* no ACL has been set */ - stat = NFS3_OK; - goto err; - } - - getaclreply->daclentry.daclentry_val = cs->daclentry; - - /* getfacl: NFS DEFAULT ACL */ - data = dict_get (dict, POSIX_ACL_DEFAULT_XATTR); - if (data && data->data) { - aclcount = acl3_nfs_acl_from_xattr (cs->daclentry, - data->data, - data->len, - defacl); - if (aclcount < 0) { - gf_msg (GF_ACL, GF_LOG_ERROR, aclcount, - NFS_MSG_GET_DEF_ACL_FAIL, - "Failed to get DEFAULT ACL"); - stat = nfs3_errno_to_nfsstat3 (-aclcount); - goto err; - } - - getaclreply->daclcount = aclcount; - getaclreply->daclentry.daclentry_len = aclcount; - } - - getaclreply->attr_follows = TRUE; - nfs_request_user_init (&nfu, cs->req); - ret = nfs_getxattr (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - POSIX_ACL_ACCESS_XATTR, NULL, acl3_getacl_cbk, cs); - if (ret < 0) { - stat = nfs3_errno_to_nfsstat3 (-ret); - goto err; - } - - return 0; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + nfs3_call_state_t *cs = NULL; + data_t *data = NULL; + getaclreply *getaclreply = NULL; + int aclcount = 0; + int defacl = 1; /* DEFAULT ACL */ + nfs_user_t nfu = { + 0, + }; + int ret = -1; + + if (!frame->local) { + gf_msg(GF_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Invalid argument, frame->local NULL"); + return -EINVAL; + } + cs = frame->local; + getaclreply = &cs->args.getaclreply; + if ((op_ret < 0) && (op_errno != ENODATA && op_errno != ENOATTR)) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + goto err; + } else if (!dict) { + /* no ACL has been set */ + stat = NFS3_OK; + goto err; + } + + getaclreply->daclentry.daclentry_val = cs->daclentry; + + /* getfacl: NFS DEFAULT ACL */ + data = dict_get(dict, POSIX_ACL_DEFAULT_XATTR); + if (data && data->data) { + aclcount = acl3_nfs_acl_from_xattr(cs->daclentry, data->data, data->len, + defacl); + if (aclcount < 0) { + gf_msg(GF_ACL, GF_LOG_ERROR, aclcount, NFS_MSG_GET_DEF_ACL_FAIL, + "Failed to get DEFAULT ACL"); + stat = nfs3_errno_to_nfsstat3(-aclcount); + goto err; + } + + getaclreply->daclcount = aclcount; + getaclreply->daclentry.daclentry_len = aclcount; + } + + getaclreply->attr_follows = TRUE; + nfs_request_user_init(&nfu, cs->req); + ret = nfs_getxattr(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + POSIX_ACL_ACCESS_XATTR, NULL, acl3_getacl_cbk, cs); + if (ret < 0) { + stat = nfs3_errno_to_nfsstat3(-ret); + goto err; + } + + return 0; err: - if (getaclreply) - getaclreply->status = stat; - acl3_getacl_reply (cs->req, getaclreply); - nfs3_call_state_wipe (cs); - return 0; + if (getaclreply) + getaclreply->status = stat; + acl3_getacl_reply(cs->req, getaclreply); + nfs3_call_state_wipe(cs); + return 0; } - int -acl3_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, - dict_t *xdata) +acl3_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, struct iatt *buf, dict_t *xdata) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - nfs3_call_state_t *cs = NULL; - getaclreply *getaclreply = NULL; - int ret = -1; - nfs_user_t nfu = {0, }; - uint64_t deviceid = 0; - - if (!frame->local) { - gf_msg (GF_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Invalid argument, frame->local NULL"); - return EINVAL; - } - - cs = frame->local; - getaclreply = &cs->args.getaclreply; - - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - goto err; - } - - /* Fill the attrs before xattrs */ - getaclreply->attr_follows = TRUE; - deviceid = nfs3_request_xlator_deviceid (cs->req); - nfs3_map_deviceid_to_statdev (buf, deviceid); - nfs3_stat_to_fattr3 (buf, &(getaclreply->attr)); - - nfs_request_user_init (&nfu, cs->req); - if (buf->ia_type == IA_IFDIR) { - ret = nfs_getxattr (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - POSIX_ACL_DEFAULT_XATTR, NULL, - acl3_default_getacl_cbk, cs); - } else { - ret = nfs_getxattr (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - POSIX_ACL_ACCESS_XATTR, NULL, - acl3_getacl_cbk, cs); - } - - if (ret < 0) { - stat = nfs3_errno_to_nfsstat3 (-ret); - goto err; - } - - return 0; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + nfs3_call_state_t *cs = NULL; + getaclreply *getaclreply = NULL; + int ret = -1; + nfs_user_t nfu = { + 0, + }; + uint64_t deviceid = 0; + + if (!frame->local) { + gf_msg(GF_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Invalid argument, frame->local NULL"); + return EINVAL; + } + + cs = frame->local; + getaclreply = &cs->args.getaclreply; + + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + goto err; + } + + /* Fill the attrs before xattrs */ + getaclreply->attr_follows = TRUE; + deviceid = nfs3_request_xlator_deviceid(cs->req); + nfs3_map_deviceid_to_statdev(buf, deviceid); + nfs3_stat_to_fattr3(buf, &(getaclreply->attr)); + + nfs_request_user_init(&nfu, cs->req); + if (buf->ia_type == IA_IFDIR) { + ret = nfs_getxattr(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + POSIX_ACL_DEFAULT_XATTR, NULL, + acl3_default_getacl_cbk, cs); + } else { + ret = nfs_getxattr(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + POSIX_ACL_ACCESS_XATTR, NULL, acl3_getacl_cbk, cs); + } + + if (ret < 0) { + stat = nfs3_errno_to_nfsstat3(-ret); + goto err; + } + + return 0; err: - getaclreply->status = stat; - acl3_getacl_reply (cs->req, getaclreply); - nfs3_call_state_wipe (cs); - return 0; + getaclreply->status = stat; + acl3_getacl_reply(cs->req, getaclreply); + nfs3_call_state_wipe(cs); + return 0; } - int -acl3_getacl_resume (void *carg) +acl3_getacl_resume(void *carg) { - int ret = -1; - nfs3_call_state_t *cs = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - nfs_user_t nfu = {0, }; - - if (!carg) - return ret; + int ret = -1; + nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + nfs_user_t nfu = { + 0, + }; + + if (!carg) + return ret; - cs = (nfs3_call_state_t *)carg; - acl3_check_fh_resolve_status (cs, stat, acl3err); - nfs_request_user_init (&nfu, cs->req); + cs = (nfs3_call_state_t *)carg; + acl3_check_fh_resolve_status(cs, stat, acl3err); + nfs_request_user_init(&nfu, cs->req); - ret = nfs_stat (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - acl3_stat_cbk, cs); - stat = -ret; + ret = nfs_stat(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, acl3_stat_cbk, + cs); + stat = -ret; acl3err: - if (ret < 0) { - gf_msg (GF_ACL, GF_LOG_ERROR, stat, NFS_MSG_OPEN_FAIL, - "unable to open_and_resume"); - cs->args.getaclreply.status = nfs3_errno_to_nfsstat3 (stat); - acl3_getacl_reply (cs->req, &cs->args.getaclreply); - nfs3_call_state_wipe (cs); - } - - return ret; + if (ret < 0) { + gf_msg(GF_ACL, GF_LOG_ERROR, stat, NFS_MSG_OPEN_FAIL, + "unable to open_and_resume"); + cs->args.getaclreply.status = nfs3_errno_to_nfsstat3(stat); + acl3_getacl_reply(cs->req, &cs->args.getaclreply); + nfs3_call_state_wipe(cs); + } + + return ret; } - int -acl3svc_getacl (rpcsvc_request_t *req) +acl3svc_getacl(rpcsvc_request_t *req) { - xlator_t *vol = NULL; - struct nfs_state *nfs = NULL; - nfs3_state_t *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - int ret = RPCSVC_ACTOR_ERROR; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - struct nfs3_fh fh, *fhp = NULL; - getaclargs getaclargs; - getaclreply getaclreply; - - if (!req) - return ret; - - acl3_validate_nfs3_state (req, nfs3, stat, rpcerr, ret); - nfs = nfs_state (nfs3->nfsx); - memset (&getaclargs, 0, sizeof (getaclargs)); - memset (&getaclreply, 0, sizeof (getaclreply)); - getaclargs.fh.n_bytes = (char *)&fh; - if (xdr_to_getaclargs(req->msg[0], &getaclargs) <= 0) { - gf_msg (GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } - - /* Validate ACL mask */ - if (getaclargs.mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT)) { - stat = NFS3ERR_INVAL; - goto acl3err; - } - - fhp = &fh; - acl3_validate_gluster_fh (&fh, stat, acl3err); - acl3_map_fh_to_volume (nfs->nfs3state, fhp, req, vol, stat, acl3err); - acl3_volume_started_check (nfs3, vol, ret, rpcerr); - acl3_handle_call_state_init (nfs->nfs3state, cs, req, - vol, stat, acl3err); - - cs->vol = vol; - cs->args.getaclreply.mask = getaclargs.mask; + xlator_t *vol = NULL; + struct nfs_state *nfs = NULL; + nfs3_state_t *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + int ret = RPCSVC_ACTOR_ERROR; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + struct nfs3_fh fh, *fhp = NULL; + getaclargs getaclargs; + getaclreply getaclreply; + + if (!req) + return ret; - ret = nfs3_fh_resolve_and_resume (cs, fhp, NULL, acl3_getacl_resume); - stat = nfs3_errno_to_nfsstat3 (-ret); + acl3_validate_nfs3_state(req, nfs3, stat, rpcerr, ret); + nfs = nfs_state(nfs3->nfsx); + memset(&getaclargs, 0, sizeof(getaclargs)); + memset(&getaclreply, 0, sizeof(getaclreply)); + getaclargs.fh.n_bytes = (char *)&fh; + if (xdr_to_getaclargs(req->msg[0], &getaclargs) <= 0) { + gf_msg(GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + /* Validate ACL mask */ + if (getaclargs.mask & ~(NFS_ACL | NFS_ACLCNT | NFS_DFACL | NFS_DFACLCNT)) { + stat = NFS3ERR_INVAL; + goto acl3err; + } + + fhp = &fh; + acl3_validate_gluster_fh(&fh, stat, acl3err); + acl3_map_fh_to_volume(nfs->nfs3state, fhp, req, vol, stat, acl3err); + acl3_volume_started_check(nfs3, vol, ret, rpcerr); + acl3_handle_call_state_init(nfs->nfs3state, cs, req, vol, stat, acl3err); + + cs->vol = vol; + cs->args.getaclreply.mask = getaclargs.mask; + + ret = nfs3_fh_resolve_and_resume(cs, fhp, NULL, acl3_getacl_resume); + stat = nfs3_errno_to_nfsstat3(-ret); acl3err: - if (ret < 0) { - gf_msg (GF_ACL, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR, - "unable to resolve and resume"); - getaclreply.status = stat; - acl3_getacl_reply (req, &getaclreply); - nfs3_call_state_wipe (cs); - return 0; - } + if (ret < 0) { + gf_msg(GF_ACL, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR, + "unable to resolve and resume"); + getaclreply.status = stat; + acl3_getacl_reply(req, &getaclreply); + nfs3_call_state_wipe(cs); + return 0; + } rpcerr: - return ret; + return ret; } int -acl3_setacl_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, int32_t op_errno, - dict_t *xdata) +acl3_setacl_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - nfs3_call_state_t *cs = NULL; - cs = frame->local; - if (op_ret < 0) { - nfsstat3 status = nfs3_cbk_errno_status (op_ret, op_errno); - cs->args.setaclreply.status = status; - } + nfs3_call_state_t *cs = NULL; + cs = frame->local; + if (op_ret < 0) { + nfsstat3 status = nfs3_cbk_errno_status(op_ret, op_errno); + cs->args.setaclreply.status = status; + } - acl3_setacl_reply (cs->req, &cs->args.setaclreply); + acl3_setacl_reply(cs->req, &cs->args.setaclreply); - nfs3_call_state_wipe (cs); + nfs3_call_state_wipe(cs); - return 0; + return 0; } int -acl3_setacl_resume (void *carg) +acl3_setacl_resume(void *carg) { - int ret = -1; - nfs3_call_state_t *cs = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - nfs_user_t nfu = {0, }; - dict_t *xattr = NULL; - - if (!carg) - return ret; - cs = (nfs3_call_state_t *)carg; - acl3_check_fh_resolve_status (cs, stat, acl3err); - nfs_request_user_init (&nfu, cs->req); - xattr = dict_new(); - if (cs->aclcount) - ret = dict_set_static_bin (xattr, POSIX_ACL_ACCESS_XATTR, - cs->aclxattr, - posix_acl_xattr_size (cs->aclcount)); - if (cs->daclcount) - ret = dict_set_static_bin (xattr, POSIX_ACL_DEFAULT_XATTR, - cs->daclxattr, - posix_acl_xattr_size (cs->daclcount)); - - ret = nfs_setxattr (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, xattr, - 0, NULL, acl3_setacl_cbk, cs); - dict_unref (xattr); + int ret = -1; + nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + nfs_user_t nfu = { + 0, + }; + dict_t *xattr = NULL; + + if (!carg) + return ret; + cs = (nfs3_call_state_t *)carg; + acl3_check_fh_resolve_status(cs, stat, acl3err); + nfs_request_user_init(&nfu, cs->req); + xattr = dict_new(); + if (cs->aclcount) + ret = dict_set_static_bin(xattr, POSIX_ACL_ACCESS_XATTR, cs->aclxattr, + posix_acl_xattr_size(cs->aclcount)); + if (cs->daclcount) + ret = dict_set_static_bin(xattr, POSIX_ACL_DEFAULT_XATTR, cs->daclxattr, + posix_acl_xattr_size(cs->daclcount)); + + ret = nfs_setxattr(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, xattr, 0, + NULL, acl3_setacl_cbk, cs); + dict_unref(xattr); acl3err: - if (ret < 0) { - stat = -ret; - gf_msg (GF_ACL, GF_LOG_ERROR, stat, NFS_MSG_OPEN_FAIL, - "unable to open_and_resume"); - cs->args.setaclreply.status = nfs3_errno_to_nfsstat3 (stat); - acl3_setacl_reply (cs->req, &cs->args.setaclreply); - nfs3_call_state_wipe (cs); - } - - return ret; + if (ret < 0) { + stat = -ret; + gf_msg(GF_ACL, GF_LOG_ERROR, stat, NFS_MSG_OPEN_FAIL, + "unable to open_and_resume"); + cs->args.setaclreply.status = nfs3_errno_to_nfsstat3(stat); + acl3_setacl_reply(cs->req, &cs->args.setaclreply); + nfs3_call_state_wipe(cs); + } + + return ret; } - int -acl3svc_setacl (rpcsvc_request_t *req) +acl3svc_setacl(rpcsvc_request_t *req) { - xlator_t *vol = NULL; - struct nfs_state *nfs = NULL; - nfs3_state_t *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - int ret = RPCSVC_ACTOR_ERROR; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - struct nfs3_fh fh; - struct nfs3_fh *fhp = NULL; - setaclargs setaclargs; - setaclreply setaclreply; - aclentry *daclentry = NULL; - aclentry *aclentry = NULL; - int aclerrno = 0; - int defacl = 1; - - if (!req) - return ret; - aclentry = GF_CALLOC (NFS_ACL_MAX_ENTRIES, sizeof(*aclentry), - gf_nfs_mt_arr); - if (!aclentry) { - goto rpcerr; - } - daclentry = GF_CALLOC (NFS_ACL_MAX_ENTRIES, sizeof(*daclentry), - gf_nfs_mt_arr); - if (!daclentry) { - goto rpcerr; - } - - acl3_validate_nfs3_state (req, nfs3, stat, rpcerr, ret); - nfs = nfs_state (nfs3->nfsx); - memset (&setaclargs, 0, sizeof (setaclargs)); - memset (&setaclreply, 0, sizeof (setaclreply)); - memset (&fh, 0, sizeof (fh)); - setaclargs.fh.n_bytes = (char *)&fh; - setaclargs.aclentry.aclentry_val = aclentry; - setaclargs.daclentry.daclentry_val = daclentry; - if (xdr_to_setaclargs(req->msg[0], &setaclargs) <= 0) { - gf_msg (GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } - - /* Validate ACL mask */ - if (setaclargs.mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT)) { - stat = NFS3ERR_INVAL; - goto acl3err; - } - - fhp = &fh; - acl3_validate_gluster_fh (fhp, stat, acl3err); - acl3_map_fh_to_volume (nfs->nfs3state, fhp, req, vol, stat, acl3err); - acl3_volume_started_check (nfs3, vol, ret, rpcerr); - acl3_handle_call_state_init (nfs->nfs3state, cs, req, - vol, stat, acl3err); - - cs->vol = vol; - cs->aclcount = setaclargs.aclcount; - cs->daclcount = setaclargs.daclcount; - - /* setfacl: NFS USER ACL */ - aclerrno = acl3_nfs_acl_to_xattr (aclentry, - cs->aclxattr, - cs->aclcount, - !defacl); - if (aclerrno < 0) { - gf_msg (GF_ACL, GF_LOG_ERROR, -aclerrno, - NFS_MSG_SET_USER_ACL_FAIL, - "Failed to set USER ACL"); - stat = nfs3_errno_to_nfsstat3 (-aclerrno); - goto acl3err; - } - - /* setfacl: NFS DEFAULT ACL */ - aclerrno = acl3_nfs_acl_to_xattr (daclentry, - cs->daclxattr, - cs->daclcount, - defacl); - if (aclerrno < 0) { - gf_msg (GF_ACL, GF_LOG_ERROR, -aclerrno, - NFS_MSG_SET_DEF_ACL_FAIL, - "Failed to set DEFAULT ACL"); - stat = nfs3_errno_to_nfsstat3 (-aclerrno); - goto acl3err; - } - - ret = nfs3_fh_resolve_and_resume (cs, fhp, NULL, acl3_setacl_resume); - stat = nfs3_errno_to_nfsstat3 (-ret); + xlator_t *vol = NULL; + struct nfs_state *nfs = NULL; + nfs3_state_t *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + int ret = RPCSVC_ACTOR_ERROR; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + struct nfs3_fh fh; + struct nfs3_fh *fhp = NULL; + setaclargs setaclargs; + setaclreply setaclreply; + aclentry *daclentry = NULL; + aclentry *aclentry = NULL; + int aclerrno = 0; + int defacl = 1; + + if (!req) + return ret; + aclentry = GF_CALLOC(NFS_ACL_MAX_ENTRIES, sizeof(*aclentry), gf_nfs_mt_arr); + if (!aclentry) { + goto rpcerr; + } + daclentry = GF_CALLOC(NFS_ACL_MAX_ENTRIES, sizeof(*daclentry), + gf_nfs_mt_arr); + if (!daclentry) { + goto rpcerr; + } + + acl3_validate_nfs3_state(req, nfs3, stat, rpcerr, ret); + nfs = nfs_state(nfs3->nfsx); + memset(&setaclargs, 0, sizeof(setaclargs)); + memset(&setaclreply, 0, sizeof(setaclreply)); + memset(&fh, 0, sizeof(fh)); + setaclargs.fh.n_bytes = (char *)&fh; + setaclargs.aclentry.aclentry_val = aclentry; + setaclargs.daclentry.daclentry_val = daclentry; + if (xdr_to_setaclargs(req->msg[0], &setaclargs) <= 0) { + gf_msg(GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + /* Validate ACL mask */ + if (setaclargs.mask & ~(NFS_ACL | NFS_ACLCNT | NFS_DFACL | NFS_DFACLCNT)) { + stat = NFS3ERR_INVAL; + goto acl3err; + } + + fhp = &fh; + acl3_validate_gluster_fh(fhp, stat, acl3err); + acl3_map_fh_to_volume(nfs->nfs3state, fhp, req, vol, stat, acl3err); + acl3_volume_started_check(nfs3, vol, ret, rpcerr); + acl3_handle_call_state_init(nfs->nfs3state, cs, req, vol, stat, acl3err); + + cs->vol = vol; + cs->aclcount = setaclargs.aclcount; + cs->daclcount = setaclargs.daclcount; + + /* setfacl: NFS USER ACL */ + aclerrno = acl3_nfs_acl_to_xattr(aclentry, cs->aclxattr, cs->aclcount, + !defacl); + if (aclerrno < 0) { + gf_msg(GF_ACL, GF_LOG_ERROR, -aclerrno, NFS_MSG_SET_USER_ACL_FAIL, + "Failed to set USER ACL"); + stat = nfs3_errno_to_nfsstat3(-aclerrno); + goto acl3err; + } + + /* setfacl: NFS DEFAULT ACL */ + aclerrno = acl3_nfs_acl_to_xattr(daclentry, cs->daclxattr, cs->daclcount, + defacl); + if (aclerrno < 0) { + gf_msg(GF_ACL, GF_LOG_ERROR, -aclerrno, NFS_MSG_SET_DEF_ACL_FAIL, + "Failed to set DEFAULT ACL"); + stat = nfs3_errno_to_nfsstat3(-aclerrno); + goto acl3err; + } + + ret = nfs3_fh_resolve_and_resume(cs, fhp, NULL, acl3_setacl_resume); + stat = nfs3_errno_to_nfsstat3(-ret); acl3err: - if (ret < 0) { - gf_msg (GF_ACL, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR, - "unable to resolve and resume"); - setaclreply.status = stat; - acl3_setacl_reply (req, &setaclreply); - nfs3_call_state_wipe (cs); - GF_FREE(aclentry); - GF_FREE(daclentry); - return 0; - } + if (ret < 0) { + gf_msg(GF_ACL, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR, + "unable to resolve and resume"); + setaclreply.status = stat; + acl3_setacl_reply(req, &setaclreply); + nfs3_call_state_wipe(cs); + GF_FREE(aclentry); + GF_FREE(daclentry); + return 0; + } rpcerr: - if (ret < 0) - nfs3_call_state_wipe (cs); - if (aclentry) - GF_FREE (aclentry); - if (daclentry) - GF_FREE (daclentry); - return ret; + if (ret < 0) + nfs3_call_state_wipe(cs); + if (aclentry) + GF_FREE(aclentry); + if (daclentry) + GF_FREE(daclentry); + return ret; } - - -rpcsvc_actor_t acl3svc_actors[ACL3_PROC_COUNT] = { - {"NULL", ACL3_NULL, acl3svc_null, NULL, 0, DRC_NA}, - {"GETACL", ACL3_GETACL, acl3svc_getacl, NULL, 0, DRC_NA}, - {"SETACL", ACL3_SETACL, acl3svc_setacl, NULL, 0, DRC_NA}, +rpcsvc_actor_t acl3svc_actors[ACL3_PROC_COUNT] = { + {"NULL", ACL3_NULL, acl3svc_null, NULL, 0, DRC_NA}, + {"GETACL", ACL3_GETACL, acl3svc_getacl, NULL, 0, DRC_NA}, + {"SETACL", ACL3_SETACL, acl3svc_setacl, NULL, 0, DRC_NA}, }; -rpcsvc_program_t acl3prog = { - .progname = "ACL3", - .prognum = ACL_PROGRAM, - .progver = ACLV3_VERSION, - .progport = GF_NFS3_PORT, - .actors = acl3svc_actors, - .numactors = ACL3_PROC_COUNT, - .min_auth = AUTH_NULL, +rpcsvc_program_t acl3prog = { + .progname = "ACL3", + .prognum = ACL_PROGRAM, + .progver = ACLV3_VERSION, + .progport = GF_NFS3_PORT, + .actors = acl3svc_actors, + .numactors = ACL3_PROC_COUNT, + .min_auth = AUTH_NULL, }; rpcsvc_program_t * acl3svc_init(xlator_t *nfsx) { - struct nfs3_state *ns = NULL; - struct nfs_state *nfs = NULL; - dict_t *options = NULL; - int ret = -1; - char *portstr = NULL; - static gf_boolean_t acl3_inited = _gf_false; - - /* Already inited */ - if (acl3_inited) - return &acl3prog; - - nfs = (struct nfs_state*)nfsx->private; - - ns = nfs->nfs3state; - if (!ns) { - gf_msg (GF_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_ACL_INIT_FAIL, - "ACL3 init failed"); - goto err; - } - acl3prog.private = ns; - - options = dict_new (); - - ret = gf_asprintf (&portstr, "%d", GF_ACL3_PORT); - if (ret == -1) - goto err; + struct nfs3_state *ns = NULL; + struct nfs_state *nfs = NULL; + dict_t *options = NULL; + int ret = -1; + char *portstr = NULL; + static gf_boolean_t acl3_inited = _gf_false; + + /* Already inited */ + if (acl3_inited) + return &acl3prog; - ret = dict_set_dynstr (options, "transport.socket.listen-port", - portstr); - if (ret == -1) - goto err; - ret = dict_set_str (options, "transport-type", "socket"); + nfs = (struct nfs_state *)nfsx->private; + + ns = nfs->nfs3state; + if (!ns) { + gf_msg(GF_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_ACL_INIT_FAIL, + "ACL3 init failed"); + goto err; + } + acl3prog.private = ns; + + options = dict_new(); + + ret = gf_asprintf(&portstr, "%d", GF_ACL3_PORT); + if (ret == -1) + goto err; + + ret = dict_set_dynstr(options, "transport.socket.listen-port", portstr); + if (ret == -1) + goto err; + ret = dict_set_str(options, "transport-type", "socket"); + if (ret == -1) { + gf_msg(GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); + goto err; + } + + if (nfs->allow_insecure) { + ret = dict_set_str(options, "rpc-auth-allow-insecure", "on"); if (ret == -1) { - gf_msg (GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, - "dict_set_str error"); - goto err; - } - - if (nfs->allow_insecure) { - ret = dict_set_str (options, "rpc-auth-allow-insecure", "on"); - if (ret == -1) { - gf_msg (GF_ACL, GF_LOG_ERROR, errno, - NFS_MSG_DICT_SET_FAILED, - "dict_set_str error"); - goto err; - } - ret = dict_set_str (options, "rpc-auth.ports.insecure", "on"); - if (ret == -1) { - gf_msg (GF_ACL, GF_LOG_ERROR, errno, - NFS_MSG_DICT_SET_FAILED, - "dict_set_str error"); - goto err; - } + gf_msg(GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); + goto err; } - - ret = dict_set_str (options, "transport.address-family", "inet"); + ret = dict_set_str(options, "rpc-auth.ports.insecure", "on"); if (ret == -1) { - gf_msg (GF_ACL, GF_LOG_ERROR, errno, - NFS_MSG_DICT_SET_FAILED, - "dict_set_str error"); - goto err; - } - - ret = rpcsvc_create_listeners (nfs->rpcsvc, options, "ACL"); - if (ret == -1) { - gf_msg (GF_ACL, GF_LOG_ERROR, errno, - NFS_MSG_LISTENERS_CREATE_FAIL, - "Unable to create listeners"); - dict_unref (options); - goto err; - } - - acl3_inited = _gf_true; - return &acl3prog; + gf_msg(GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); + goto err; + } + } + + ret = dict_set_str(options, "transport.address-family", "inet"); + if (ret == -1) { + gf_msg(GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); + goto err; + } + + ret = rpcsvc_create_listeners(nfs->rpcsvc, options, "ACL"); + if (ret == -1) { + gf_msg(GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_LISTENERS_CREATE_FAIL, + "Unable to create listeners"); + dict_unref(options); + goto err; + } + + acl3_inited = _gf_true; + return &acl3prog; err: - return NULL; + return NULL; } static int -acl3_nfs_acl_to_xattr (aclentry *ace, /* ACL entries to be read */ - void *xattrbuf, /* XATTR buf to be populated */ - int aclcount, /* No of ACLs to be read */ - int defacl) /* 1 if DEFAULT ACL */ +acl3_nfs_acl_to_xattr(aclentry *ace, /* ACL entries to be read */ + void *xattrbuf, /* XATTR buf to be populated */ + int aclcount, /* No of ACLs to be read */ + int defacl) /* 1 if DEFAULT ACL */ { - int idx = 0; - posix_acl_xattr_header *xheader = NULL; - posix_acl_xattr_entry *xentry = NULL; + int idx = 0; + posix_acl_xattr_header *xheader = NULL; + posix_acl_xattr_entry *xentry = NULL; - if ((!ace) || (!xattrbuf)) - return (-EINVAL); + if ((!ace) || (!xattrbuf)) + return (-EINVAL); - /* ACL count is ZERO, nothing to do */ - if (!aclcount) - return (0); + /* ACL count is ZERO, nothing to do */ + if (!aclcount) + return (0); - if ((aclcount < 0) || (aclcount > NFS_ACL_MAX_ENTRIES)) + if ((aclcount < 0) || (aclcount > NFS_ACL_MAX_ENTRIES)) + return (-EINVAL); + + xheader = (posix_acl_xattr_header *)(xattrbuf); + xentry = (posix_acl_xattr_entry *)(xheader + 1); + + /* + * For "default ACL", NFSv3 handles the 'type' differently + * i.e. by logical OR'ing 'type' with NFS_ACL_DEFAULT. + * Which the backend File system does not understand and + * that needs to be masked OFF. + */ + xheader->version = POSIX_ACL_XATTR_VERSION; + + for (idx = 0; idx < aclcount; idx++) { + xentry->tag = ace->type; + if (defacl) + xentry->tag &= ~NFS_ACL_DEFAULT; + xentry->perm = ace->perm; + + switch (xentry->tag) { + case POSIX_ACL_USER: + case POSIX_ACL_GROUP: + if (xentry->perm & ~S_IRWXO) + return (-EINVAL); + xentry->id = ace->uid; + break; + case POSIX_ACL_USER_OBJ: + case POSIX_ACL_GROUP_OBJ: + case POSIX_ACL_OTHER: + if (xentry->perm & ~S_IRWXO) + return (-EINVAL); + xentry->id = POSIX_ACL_UNDEFINED_ID; + break; + case POSIX_ACL_MASK: + /* Solaris sometimes sets additional bits in + * the mask. + */ + xentry->perm &= S_IRWXO; + xentry->id = POSIX_ACL_UNDEFINED_ID; + break; + default: return (-EINVAL); - - xheader = (posix_acl_xattr_header *) (xattrbuf); - xentry = (posix_acl_xattr_entry *) (xheader + 1); - - /* - * For "default ACL", NFSv3 handles the 'type' differently - * i.e. by logical OR'ing 'type' with NFS_ACL_DEFAULT. - * Which the backend File system does not understand and - * that needs to be masked OFF. - */ - xheader->version = POSIX_ACL_XATTR_VERSION; - - for (idx = 0; idx < aclcount; idx++) { - xentry->tag = ace->type; - if (defacl) - xentry->tag &= ~NFS_ACL_DEFAULT; - xentry->perm = ace->perm; - - switch (xentry->tag) { - case POSIX_ACL_USER: - case POSIX_ACL_GROUP: - if (xentry->perm & ~S_IRWXO) - return (-EINVAL); - xentry->id = ace->uid; - break; - case POSIX_ACL_USER_OBJ: - case POSIX_ACL_GROUP_OBJ: - case POSIX_ACL_OTHER: - if (xentry->perm & ~S_IRWXO) - return (-EINVAL); - xentry->id = POSIX_ACL_UNDEFINED_ID; - break; - case POSIX_ACL_MASK: - /* Solaris sometimes sets additional bits in - * the mask. - */ - xentry->perm &= S_IRWXO; - xentry->id = POSIX_ACL_UNDEFINED_ID; - break; - default: - return (-EINVAL); - } - - xentry++; - ace++; } - /* SUCCESS */ - return (0); + xentry++; + ace++; + } + + /* SUCCESS */ + return (0); } static int -acl3_nfs_acl_from_xattr (aclentry *ace, /* ACL entries to be filled */ - void *xattrbuf, /* XATTR buf to be read */ - int bufsize, /* Size of XATTR buffer */ - int defacl) /* 1 if DEFAULT ACL */ +acl3_nfs_acl_from_xattr(aclentry *ace, /* ACL entries to be filled */ + void *xattrbuf, /* XATTR buf to be read */ + int bufsize, /* Size of XATTR buffer */ + int defacl) /* 1 if DEFAULT ACL */ { - int idx = 0; - ssize_t aclcount = 0; - posix_acl_xattr_header *xheader = NULL; - posix_acl_xattr_entry *xentry = NULL; - - if ((!xattrbuf) || (!ace)) + int idx = 0; + ssize_t aclcount = 0; + posix_acl_xattr_header *xheader = NULL; + posix_acl_xattr_entry *xentry = NULL; + + if ((!xattrbuf) || (!ace)) + return (-EINVAL); + + aclcount = posix_acl_xattr_count(bufsize); + if ((aclcount < 0) || (aclcount > NFS_ACL_MAX_ENTRIES)) + return (-EINVAL); + + xheader = (posix_acl_xattr_header *)(xattrbuf); + xentry = (posix_acl_xattr_entry *)(xheader + 1); + + /* Check for supported POSIX ACL xattr version */ + if (xheader->version != POSIX_ACL_XATTR_VERSION) + return (-ENOSYS); + + for (idx = 0; idx < (int)aclcount; idx++) { + ace->type = xentry->tag; + if (defacl) { + /* + * SET the NFS_ACL_DEFAULT flag for default + * ACL which was masked OFF during setfacl(). + */ + ace->type |= NFS_ACL_DEFAULT; + } + ace->perm = (xentry->perm & S_IRWXO); + + switch (xentry->tag) { + case POSIX_ACL_USER: + case POSIX_ACL_GROUP: + ace->uid = xentry->id; + break; + case POSIX_ACL_USER_OBJ: + case POSIX_ACL_GROUP_OBJ: + case POSIX_ACL_MASK: + case POSIX_ACL_OTHER: + ace->uid = POSIX_ACL_UNDEFINED_ID; + break; + default: return (-EINVAL); - - aclcount = posix_acl_xattr_count (bufsize); - if ((aclcount < 0) || (aclcount > NFS_ACL_MAX_ENTRIES)) - return (-EINVAL); - - xheader = (posix_acl_xattr_header *) (xattrbuf); - xentry = (posix_acl_xattr_entry *) (xheader + 1); - - /* Check for supported POSIX ACL xattr version */ - if (xheader->version != POSIX_ACL_XATTR_VERSION) - return (-ENOSYS); - - for (idx = 0; idx < (int)aclcount; idx++) { - ace->type = xentry->tag; - if (defacl) { - /* - * SET the NFS_ACL_DEFAULT flag for default - * ACL which was masked OFF during setfacl(). - */ - ace->type |= NFS_ACL_DEFAULT; - } - ace->perm = (xentry->perm & S_IRWXO); - - switch (xentry->tag) { - case POSIX_ACL_USER: - case POSIX_ACL_GROUP: - ace->uid = xentry->id; - break; - case POSIX_ACL_USER_OBJ: - case POSIX_ACL_GROUP_OBJ: - case POSIX_ACL_MASK: - case POSIX_ACL_OTHER: - ace->uid = POSIX_ACL_UNDEFINED_ID; - break; - default: - return (-EINVAL); - } - - - xentry++; - ace++; } - /* SUCCESS: ACL count */ - return aclcount; + xentry++; + ace++; + } + + /* SUCCESS: ACL count */ + return aclcount; } diff --git a/xlators/nfs/server/src/auth-cache.c b/xlators/nfs/server/src/auth-cache.c index a1aacaba61..248a90b058 100644 --- a/xlators/nfs/server/src/auth-cache.c +++ b/xlators/nfs/server/src/auth-cache.c @@ -18,44 +18,48 @@ #include "nfs-messages.h" enum auth_cache_lookup_results { - ENTRY_FOUND = 0, - ENTRY_NOT_FOUND = -1, - ENTRY_EXPIRED = -2, + ENTRY_FOUND = 0, + ENTRY_NOT_FOUND = -1, + ENTRY_EXPIRED = -2, }; struct auth_cache_entry { - GF_REF_DECL; /* refcounting */ - data_t *data; /* data_unref() on refcount == 0 */ + GF_REF_DECL; /* refcounting */ + data_t *data; /* data_unref() on refcount == 0 */ - time_t timestamp; - struct export_item *item; + time_t timestamp; + struct export_item *item; }; /* Given a filehandle and an ip, creates a colon delimited hashkey. */ -static char* +static char * make_hashkey(struct nfs3_fh *fh, const char *host) { - char *hashkey = NULL; - char exportid[256] = {0, }; - char gfid[256] = {0, }; - char mountid[256] = {0, }; - size_t nbytes = 0; - - gf_uuid_unparse (fh->exportid, exportid); - gf_uuid_unparse (fh->gfid, gfid); - gf_uuid_unparse (fh->mountid, mountid); - - nbytes = strlen (exportid) + strlen (host) - + strlen (mountid) + 3; - hashkey = GF_MALLOC (nbytes, gf_common_mt_char); - if (!hashkey) - return NULL; - - snprintf (hashkey, nbytes, "%s:%s:%s", exportid, - mountid, host); - - return hashkey; + char *hashkey = NULL; + char exportid[256] = { + 0, + }; + char gfid[256] = { + 0, + }; + char mountid[256] = { + 0, + }; + size_t nbytes = 0; + + gf_uuid_unparse(fh->exportid, exportid); + gf_uuid_unparse(fh->gfid, gfid); + gf_uuid_unparse(fh->mountid, mountid); + + nbytes = strlen(exportid) + strlen(host) + strlen(mountid) + 3; + hashkey = GF_MALLOC(nbytes, gf_common_mt_char); + if (!hashkey) + return NULL; + + snprintf(hashkey, nbytes, "%s:%s:%s", exportid, mountid, host); + + return hashkey; } /** @@ -66,24 +70,24 @@ make_hashkey(struct nfs3_fh *fh, const char *host) * @return : allocated auth cache struct, NULL if allocation failed. */ struct auth_cache * -auth_cache_init (time_t ttl_sec) +auth_cache_init(time_t ttl_sec) { - struct auth_cache *cache = GF_CALLOC (1, sizeof (*cache), - gf_nfs_mt_auth_cache); + struct auth_cache *cache = GF_CALLOC(1, sizeof(*cache), + gf_nfs_mt_auth_cache); - GF_VALIDATE_OR_GOTO ("auth-cache", cache, out); + GF_VALIDATE_OR_GOTO("auth-cache", cache, out); - cache->cache_dict = dict_new (); - if (!cache->cache_dict) { - GF_FREE (cache); - cache = NULL; - goto out; - } + cache->cache_dict = dict_new(); + if (!cache->cache_dict) { + GF_FREE(cache); + cache = NULL; + goto out; + } - LOCK_INIT (&cache->lock); - cache->ttl_sec = ttl_sec; + LOCK_INIT(&cache->lock); + cache->ttl_sec = ttl_sec; out: - return cache; + return cache; } /* auth_cache_entry_free -- called by refcounting subsystem on refcount == 0 @@ -91,22 +95,22 @@ out: * @to_free: auth_cache_entry that has refcount == 0 and needs to get free'd */ void -auth_cache_entry_free (void *to_free) +auth_cache_entry_free(void *to_free) { - struct auth_cache_entry *entry = to_free; - data_t *entry_data = NULL; + struct auth_cache_entry *entry = to_free; + data_t *entry_data = NULL; - GF_VALIDATE_OR_GOTO (GF_NFS, entry, out); - GF_VALIDATE_OR_GOTO (GF_NFS, entry->data, out); + GF_VALIDATE_OR_GOTO(GF_NFS, entry, out); + GF_VALIDATE_OR_GOTO(GF_NFS, entry->data, out); - entry_data = entry->data; - /* set data_t->data to NULL, otherwise data_unref() tries to free it */ - entry_data->data = NULL; - data_unref (entry_data); + entry_data = entry->data; + /* set data_t->data to NULL, otherwise data_unref() tries to free it */ + entry_data->data = NULL; + data_unref(entry_data); - GF_FREE (entry); + GF_FREE(entry); out: - return; + return; } /** @@ -116,18 +120,18 @@ out: * failed. */ static struct auth_cache_entry * -auth_cache_entry_init () +auth_cache_entry_init() { - struct auth_cache_entry *entry = NULL; + struct auth_cache_entry *entry = NULL; - entry = GF_CALLOC (1, sizeof (*entry), gf_nfs_mt_auth_cache_entry); - if (!entry) - gf_msg (GF_NFS, GF_LOG_WARNING, ENOMEM, NFS_MSG_NO_MEMORY, - "failed to allocate entry"); - else - GF_REF_INIT (entry, auth_cache_entry_free); + entry = GF_CALLOC(1, sizeof(*entry), gf_nfs_mt_auth_cache_entry); + if (!entry) + gf_msg(GF_NFS, GF_LOG_WARNING, ENOMEM, NFS_MSG_NO_MEMORY, + "failed to allocate entry"); + else + GF_REF_INIT(entry, auth_cache_entry_free); - return entry; + return entry; } /** @@ -136,46 +140,46 @@ auth_cache_entry_init () * @return: 0 on success, non-zero otherwise. */ static int -auth_cache_add (struct auth_cache *cache, char *hashkey, - struct auth_cache_entry *entry) +auth_cache_add(struct auth_cache *cache, char *hashkey, + struct auth_cache_entry *entry) { - int ret = -1; - data_t *entry_data = NULL; - - GF_VALIDATE_OR_GOTO (GF_NFS, cache, out); - GF_VALIDATE_OR_GOTO (GF_NFS, cache->cache_dict, out); - - /* FIXME: entry is passed as parameter, this can never fail? */ - entry = GF_REF_GET (entry); - if (!entry) { - /* entry does not have any references */ - ret = -1; - goto out; - } - - entry_data = bin_to_data (entry, sizeof (*entry)); - if (!entry_data) { - ret = -1; - GF_REF_PUT (entry); - goto out; - } - - /* we'll take an extra ref on the data_t, it gets unref'd when the - * auth_cache_entry is released */ - entry->data = data_ref (entry_data); - - LOCK (&cache->lock); - { - ret = dict_set (cache->cache_dict, hashkey, entry_data); - } - UNLOCK (&cache->lock); - - if (ret) { - /* adding to dict failed */ - GF_REF_PUT (entry); - } + int ret = -1; + data_t *entry_data = NULL; + + GF_VALIDATE_OR_GOTO(GF_NFS, cache, out); + GF_VALIDATE_OR_GOTO(GF_NFS, cache->cache_dict, out); + + /* FIXME: entry is passed as parameter, this can never fail? */ + entry = GF_REF_GET(entry); + if (!entry) { + /* entry does not have any references */ + ret = -1; + goto out; + } + + entry_data = bin_to_data(entry, sizeof(*entry)); + if (!entry_data) { + ret = -1; + GF_REF_PUT(entry); + goto out; + } + + /* we'll take an extra ref on the data_t, it gets unref'd when the + * auth_cache_entry is released */ + entry->data = data_ref(entry_data); + + LOCK(&cache->lock); + { + ret = dict_set(cache->cache_dict, hashkey, entry_data); + } + UNLOCK(&cache->lock); + + if (ret) { + /* adding to dict failed */ + GF_REF_PUT(entry); + } out: - return ret; + return ret; } /** @@ -186,9 +190,9 @@ out: * @return: true when the auth_cache_entry is expired, false otherwise. */ static int -_auth_cache_expired (struct auth_cache *cache, struct auth_cache_entry *entry) +_auth_cache_expired(struct auth_cache *cache, struct auth_cache_entry *entry) { - return ((time (NULL) - entry->timestamp) > cache->ttl_sec); + return ((time(NULL) - entry->timestamp) > cache->ttl_sec); } /** @@ -205,52 +209,52 @@ _auth_cache_expired (struct auth_cache *cache, struct auth_cache_entry *entry) * @return: 0 when found, ENTRY_NOT_FOUND or ENTRY_EXPIRED otherwise. */ static enum auth_cache_lookup_results -auth_cache_get (struct auth_cache *cache, char *hashkey, - struct auth_cache_entry **entry) +auth_cache_get(struct auth_cache *cache, char *hashkey, + struct auth_cache_entry **entry) { - enum auth_cache_lookup_results ret = ENTRY_NOT_FOUND; - data_t *entry_data = NULL; - struct auth_cache_entry *lookup_res = NULL; - - GF_VALIDATE_OR_GOTO (GF_NFS, cache, out); - GF_VALIDATE_OR_GOTO (GF_NFS, cache->cache_dict, out); - GF_VALIDATE_OR_GOTO (GF_NFS, hashkey, out); - - LOCK (&cache->lock); - { - entry_data = dict_get (cache->cache_dict, hashkey); - if (!entry_data) - goto unlock; - - /* FIXME: this is dangerous use of entry_data */ - lookup_res = GF_REF_GET ((struct auth_cache_entry *) entry_data->data); - if (lookup_res == NULL) { - /* entry has been free'd */ - ret = ENTRY_EXPIRED; - goto unlock; - } - - if (_auth_cache_expired (cache, lookup_res)) { - ret = ENTRY_EXPIRED; - GF_REF_PUT (lookup_res->item); - lookup_res->item = NULL; - - /* free entry and remove from the cache */ - GF_FREE (lookup_res); - entry_data->data = NULL; - dict_del (cache->cache_dict, hashkey); - - goto unlock; - } - - *entry = lookup_res; - ret = ENTRY_FOUND; + enum auth_cache_lookup_results ret = ENTRY_NOT_FOUND; + data_t *entry_data = NULL; + struct auth_cache_entry *lookup_res = NULL; + + GF_VALIDATE_OR_GOTO(GF_NFS, cache, out); + GF_VALIDATE_OR_GOTO(GF_NFS, cache->cache_dict, out); + GF_VALIDATE_OR_GOTO(GF_NFS, hashkey, out); + + LOCK(&cache->lock); + { + entry_data = dict_get(cache->cache_dict, hashkey); + if (!entry_data) + goto unlock; + + /* FIXME: this is dangerous use of entry_data */ + lookup_res = GF_REF_GET((struct auth_cache_entry *)entry_data->data); + if (lookup_res == NULL) { + /* entry has been free'd */ + ret = ENTRY_EXPIRED; + goto unlock; + } + + if (_auth_cache_expired(cache, lookup_res)) { + ret = ENTRY_EXPIRED; + GF_REF_PUT(lookup_res->item); + lookup_res->item = NULL; + + /* free entry and remove from the cache */ + GF_FREE(lookup_res); + entry_data->data = NULL; + dict_del(cache->cache_dict, hashkey); + + goto unlock; } + + *entry = lookup_res; + ret = ENTRY_FOUND; + } unlock: - UNLOCK (&cache->lock); + UNLOCK(&cache->lock); out: - return ret; + return ret; } /** @@ -270,49 +274,47 @@ out: * 0 if found */ enum auth_cache_lookup_results -auth_cache_lookup (struct auth_cache *cache, struct nfs3_fh *fh, - const char *host_addr, time_t *timestamp, - gf_boolean_t *can_write) +auth_cache_lookup(struct auth_cache *cache, struct nfs3_fh *fh, + const char *host_addr, time_t *timestamp, + gf_boolean_t *can_write) { - char *hashkey = NULL; - struct auth_cache_entry *lookup_res = NULL; - enum auth_cache_lookup_results ret = ENTRY_NOT_FOUND; - - GF_VALIDATE_OR_GOTO (GF_NFS, cache, out); - GF_VALIDATE_OR_GOTO (GF_NFS, fh, out); - GF_VALIDATE_OR_GOTO (GF_NFS, host_addr, out); - GF_VALIDATE_OR_GOTO (GF_NFS, timestamp, out); - GF_VALIDATE_OR_GOTO (GF_NFS, can_write, out); - - hashkey = make_hashkey (fh, host_addr); - if (!hashkey) { - ret = -ENOMEM; - goto out; - } - - ret = auth_cache_get (cache, hashkey, &lookup_res); - switch (ret) { + char *hashkey = NULL; + struct auth_cache_entry *lookup_res = NULL; + enum auth_cache_lookup_results ret = ENTRY_NOT_FOUND; + + GF_VALIDATE_OR_GOTO(GF_NFS, cache, out); + GF_VALIDATE_OR_GOTO(GF_NFS, fh, out); + GF_VALIDATE_OR_GOTO(GF_NFS, host_addr, out); + GF_VALIDATE_OR_GOTO(GF_NFS, timestamp, out); + GF_VALIDATE_OR_GOTO(GF_NFS, can_write, out); + + hashkey = make_hashkey(fh, host_addr); + if (!hashkey) { + ret = -ENOMEM; + goto out; + } + + ret = auth_cache_get(cache, hashkey, &lookup_res); + switch (ret) { case ENTRY_FOUND: - *timestamp = lookup_res->timestamp; - *can_write = lookup_res->item->opts->rw; - GF_REF_PUT (lookup_res); - break; + *timestamp = lookup_res->timestamp; + *can_write = lookup_res->item->opts->rw; + GF_REF_PUT(lookup_res); + break; case ENTRY_NOT_FOUND: - gf_msg_debug (GF_NFS, 0, "could not find entry for %s", - host_addr); - break; + gf_msg_debug(GF_NFS, 0, "could not find entry for %s", host_addr); + break; case ENTRY_EXPIRED: - gf_msg_debug (GF_NFS, 0, "entry for host %s has expired", - host_addr); - break; - } + gf_msg_debug(GF_NFS, 0, "entry for host %s has expired", host_addr); + break; + } out: - GF_FREE (hashkey); + GF_FREE(hashkey); - return ret; + return ret; } /* auth_cache_entry_purge -- free up the auth_cache_entry @@ -327,14 +329,14 @@ out: * @v: data_t of the current entry */ int -auth_cache_entry_purge (dict_t *d, char *k, data_t *v, void *_unused) +auth_cache_entry_purge(dict_t *d, char *k, data_t *v, void *_unused) { - struct auth_cache_entry *entry = (struct auth_cache_entry *) v->data; + struct auth_cache_entry *entry = (struct auth_cache_entry *)v->data; - if (entry) - GF_REF_PUT (entry); + if (entry) + GF_REF_PUT(entry); - return 0; + return 0; } /** @@ -344,26 +346,26 @@ auth_cache_entry_purge (dict_t *d, char *k, data_t *v, void *_unused) * */ void -auth_cache_purge (struct auth_cache *cache) +auth_cache_purge(struct auth_cache *cache) { - dict_t *new_cache_dict = dict_new (); - dict_t *old_cache_dict = NULL; - - if (!cache || !new_cache_dict) - goto out; - - LOCK (&cache->lock); - { - old_cache_dict = cache->cache_dict; - cache->cache_dict = new_cache_dict; - } - UNLOCK (&cache->lock); - - /* walk all entries and refcount-- with GF_REF_PUT() */ - dict_foreach (old_cache_dict, auth_cache_entry_purge, NULL); - dict_unref (old_cache_dict); + dict_t *new_cache_dict = dict_new(); + dict_t *old_cache_dict = NULL; + + if (!cache || !new_cache_dict) + goto out; + + LOCK(&cache->lock); + { + old_cache_dict = cache->cache_dict; + cache->cache_dict = new_cache_dict; + } + UNLOCK(&cache->lock); + + /* walk all entries and refcount-- with GF_REF_PUT() */ + dict_foreach(old_cache_dict, auth_cache_entry_purge, NULL); + dict_unref(old_cache_dict); out: - return; + return; } /** @@ -378,25 +380,24 @@ out: * */ gf_boolean_t -is_nfs_fh_cached (struct auth_cache *cache, struct nfs3_fh *fh, - const char *host_addr) +is_nfs_fh_cached(struct auth_cache *cache, struct nfs3_fh *fh, + const char *host_addr) { - int ret = 0; - time_t timestamp = 0; - gf_boolean_t cached = _gf_false; - gf_boolean_t can_write = _gf_false; + int ret = 0; + time_t timestamp = 0; + gf_boolean_t cached = _gf_false; + gf_boolean_t can_write = _gf_false; - if (!fh) - goto out; + if (!fh) + goto out; - ret = auth_cache_lookup (cache, fh, host_addr, ×tamp, &can_write); - cached = (ret == ENTRY_FOUND); + ret = auth_cache_lookup(cache, fh, host_addr, ×tamp, &can_write); + cached = (ret == ENTRY_FOUND); out: - return cached; + return cached; } - /** * is_nfs_fh_cached_and_writeable -- Checks if an NFS FH is cached for the given * host and writable @@ -409,22 +410,22 @@ out: * */ gf_boolean_t -is_nfs_fh_cached_and_writeable (struct auth_cache *cache, struct nfs3_fh *fh, - const char *host_addr) +is_nfs_fh_cached_and_writeable(struct auth_cache *cache, struct nfs3_fh *fh, + const char *host_addr) { - int ret = 0; - time_t timestamp = 0; - gf_boolean_t cached = _gf_false; - gf_boolean_t writable = _gf_false; + int ret = 0; + time_t timestamp = 0; + gf_boolean_t cached = _gf_false; + gf_boolean_t writable = _gf_false; - if (!fh) - goto out; + if (!fh) + goto out; - ret = auth_cache_lookup (cache, fh, host_addr, ×tamp, &writable); - cached = ((ret == ENTRY_FOUND) && writable); + ret = auth_cache_lookup(cache, fh, host_addr, ×tamp, &writable); + cached = ((ret == ENTRY_FOUND) && writable); out: - return cached; + return cached; } /** @@ -441,56 +442,58 @@ out: * */ int -cache_nfs_fh (struct auth_cache *cache, struct nfs3_fh *fh, - const char *host_addr, struct export_item *export_item) +cache_nfs_fh(struct auth_cache *cache, struct nfs3_fh *fh, + const char *host_addr, struct export_item *export_item) { - int ret = -EINVAL; - char *hashkey = NULL; - time_t timestamp = 0; - gf_boolean_t can_write = _gf_false; - struct auth_cache_entry *entry = NULL; - - GF_VALIDATE_OR_GOTO (GF_NFS, host_addr, out); - GF_VALIDATE_OR_GOTO (GF_NFS, cache, out); - GF_VALIDATE_OR_GOTO (GF_NFS, fh, out); - - /* If we could already find it in the cache, just return */ - ret = auth_cache_lookup (cache, fh, host_addr, ×tamp, &can_write); - if (ret == 0) { - gf_msg_trace (GF_NFS, 0, "found cached auth/fh for host " - "%s", host_addr); - goto out; - } - - hashkey = make_hashkey (fh, host_addr); - if (!hashkey) { - ret = -ENOMEM; - goto out; - } - - entry = auth_cache_entry_init (); - if (!entry) { - ret = -ENOMEM; - goto out; - } - - entry->timestamp = time (NULL); - /* Update entry->item if it is pointing to a different export_item */ - if (entry->item && entry->item != export_item) { - GF_REF_PUT (entry->item); - } - entry->item = GF_REF_GET (export_item); - - ret = auth_cache_add (cache, hashkey, entry); - GF_REF_PUT (entry); - if (ret) - goto out; - - gf_msg_trace (GF_NFS, 0, "Caching file-handle (%s)", host_addr); - ret = 0; + int ret = -EINVAL; + char *hashkey = NULL; + time_t timestamp = 0; + gf_boolean_t can_write = _gf_false; + struct auth_cache_entry *entry = NULL; + + GF_VALIDATE_OR_GOTO(GF_NFS, host_addr, out); + GF_VALIDATE_OR_GOTO(GF_NFS, cache, out); + GF_VALIDATE_OR_GOTO(GF_NFS, fh, out); + + /* If we could already find it in the cache, just return */ + ret = auth_cache_lookup(cache, fh, host_addr, ×tamp, &can_write); + if (ret == 0) { + gf_msg_trace(GF_NFS, 0, + "found cached auth/fh for host " + "%s", + host_addr); + goto out; + } + + hashkey = make_hashkey(fh, host_addr); + if (!hashkey) { + ret = -ENOMEM; + goto out; + } + + entry = auth_cache_entry_init(); + if (!entry) { + ret = -ENOMEM; + goto out; + } + + entry->timestamp = time(NULL); + /* Update entry->item if it is pointing to a different export_item */ + if (entry->item && entry->item != export_item) { + GF_REF_PUT(entry->item); + } + entry->item = GF_REF_GET(export_item); + + ret = auth_cache_add(cache, hashkey, entry); + GF_REF_PUT(entry); + if (ret) + goto out; + + gf_msg_trace(GF_NFS, 0, "Caching file-handle (%s)", host_addr); + ret = 0; out: - GF_FREE (hashkey); + GF_FREE(hashkey); - return ret; + return ret; } diff --git a/xlators/nfs/server/src/exports.c b/xlators/nfs/server/src/exports.c index 671aa04ffc..342ad503a6 100644 --- a/xlators/nfs/server/src/exports.c +++ b/xlators/nfs/server/src/exports.c @@ -17,10 +17,14 @@ #include "parse-utils.h" #include "nfs-messages.h" -static void _exp_dict_destroy (dict_t *ng_dict); -static void _export_options_print (const struct export_options *opts); -static void _export_options_deinit (struct export_options *opts); -static void _export_dir_deinit (struct export_dir *dir); +static void +_exp_dict_destroy(dict_t *ng_dict); +static void +_export_options_print(const struct export_options *opts); +static void +_export_options_deinit(struct export_options *opts); +static void +_export_dir_deinit(struct export_dir *dir); static struct parser *netgroup_parser; static struct parser *hostname_parser; @@ -33,36 +37,36 @@ static struct parser *options_parser; * failure: -1 */ static int -_exp_init_parsers () +_exp_init_parsers() { - int ret = -1; + int ret = -1; - netgroup_parser = parser_init (NETGROUP_REGEX_PATTERN); - if (!netgroup_parser) - goto out; + netgroup_parser = parser_init(NETGROUP_REGEX_PATTERN); + if (!netgroup_parser) + goto out; - hostname_parser = parser_init (HOSTNAME_REGEX_PATTERN); - if (!hostname_parser) - goto out; + hostname_parser = parser_init(HOSTNAME_REGEX_PATTERN); + if (!hostname_parser) + goto out; - options_parser = parser_init (OPTIONS_REGEX_PATTERN); - if (!options_parser) - goto out; + options_parser = parser_init(OPTIONS_REGEX_PATTERN); + if (!options_parser) + goto out; - ret = 0; + ret = 0; out: - return ret; + return ret; } /** * _exp_deinit_parsers -- Free parsers used in this file */ static void -_exp_deinit_parsers () +_exp_deinit_parsers() { - parser_deinit (netgroup_parser); - parser_deinit (hostname_parser); - parser_deinit (options_parser); + parser_deinit(netgroup_parser); + parser_deinit(hostname_parser); + parser_deinit(options_parser); } /** @@ -74,35 +78,35 @@ _exp_deinit_parsers () * Not for external use. */ struct exports_file * -_exports_file_init () +_exports_file_init() { - struct exports_file *file = NULL; + struct exports_file *file = NULL; - file = GF_CALLOC (1, sizeof (*file), gf_common_mt_nfs_exports); - if (!file) { - gf_msg (GF_EXP, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to allocate file struct!"); - goto out; - } + file = GF_CALLOC(1, sizeof(*file), gf_common_mt_nfs_exports); + if (!file) { + gf_msg(GF_EXP, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to allocate file struct!"); + goto out; + } - file->exports_dict = dict_new (); - file->exports_map = dict_new (); - if (!file->exports_dict || !file->exports_map) { - gf_msg (GF_EXP, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to allocate dict!"); - goto free_and_out; - } + file->exports_dict = dict_new(); + file->exports_map = dict_new(); + if (!file->exports_dict || !file->exports_map) { + gf_msg(GF_EXP, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to allocate dict!"); + goto free_and_out; + } - goto out; + goto out; free_and_out: - if (file->exports_dict) - dict_unref (file->exports_dict); + if (file->exports_dict) + dict_unref(file->exports_dict); - GF_FREE (file); - file = NULL; + GF_FREE(file); + file = NULL; out: - return file; + return file; } /** @@ -116,24 +120,24 @@ out: * Not for external use. */ static int -_exp_file_dict_destroy (dict_t *dict, char *key, data_t *val, void *tmp) +_exp_file_dict_destroy(dict_t *dict, char *key, data_t *val, void *tmp) { - struct export_dir *dir = NULL; + struct export_dir *dir = NULL; - GF_VALIDATE_OR_GOTO (GF_EXP, dict, out); + GF_VALIDATE_OR_GOTO(GF_EXP, dict, out); - if (val) { - dir = (struct export_dir *)val->data; + if (val) { + dir = (struct export_dir *)val->data; - if (dir) { - _export_dir_deinit (dir); - val->data = NULL; - } - dict_del (dict, key); + if (dir) { + _export_dir_deinit(dir); + val->data = NULL; } + dict_del(dict, key); + } out: - return 0; + return 0; } /** @@ -144,27 +148,25 @@ out: * Externally usable. */ void -exp_file_deinit (struct exports_file *expfile) +exp_file_deinit(struct exports_file *expfile) { - if (!expfile) - goto out; + if (!expfile) + goto out; - if (expfile->exports_dict) { - dict_foreach (expfile->exports_dict, _exp_file_dict_destroy, - NULL); - dict_unref (expfile->exports_dict); - } + if (expfile->exports_dict) { + dict_foreach(expfile->exports_dict, _exp_file_dict_destroy, NULL); + dict_unref(expfile->exports_dict); + } - if (expfile->exports_map) { - dict_foreach (expfile->exports_map, _exp_file_dict_destroy, - NULL); - dict_unref (expfile->exports_map); - } + if (expfile->exports_map) { + dict_foreach(expfile->exports_map, _exp_file_dict_destroy, NULL); + dict_unref(expfile->exports_map); + } - GF_FREE (expfile->filename); - GF_FREE (expfile); + GF_FREE(expfile->filename); + GF_FREE(expfile); out: - return; + return; } /** @@ -176,16 +178,16 @@ out: * Not for external use. */ static struct export_dir * -_export_dir_init () +_export_dir_init() { - struct export_dir *expdir = GF_CALLOC (1, sizeof (*expdir), - gf_common_mt_nfs_exports); + struct export_dir *expdir = GF_CALLOC(1, sizeof(*expdir), + gf_common_mt_nfs_exports); - if (!expdir) - gf_msg (GF_EXP, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to allocate export dir structure!"); + if (!expdir) + gf_msg(GF_EXP, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to allocate export dir structure!"); - return expdir; + return expdir; } /** @@ -196,19 +198,18 @@ _export_dir_init () * Not for external use. */ static void -_export_dir_deinit (struct export_dir *dir) +_export_dir_deinit(struct export_dir *dir) { - GF_VALIDATE_OR_GOTO (GF_EXP, dir, out); - GF_FREE (dir->dir_name); - _exp_dict_destroy (dir->netgroups); - _exp_dict_destroy (dir->hosts); - GF_FREE (dir); + GF_VALIDATE_OR_GOTO(GF_EXP, dir, out); + GF_FREE(dir->dir_name); + _exp_dict_destroy(dir->netgroups); + _exp_dict_destroy(dir->hosts); + GF_FREE(dir); out: - return; + return; } - /** * _export_item_print -- Print the elements in the export item. * @@ -217,13 +218,13 @@ out: * Not for external use. */ static void -_export_item_print (const struct export_item *item) +_export_item_print(const struct export_item *item) { - GF_VALIDATE_OR_GOTO (GF_EXP, item, out); - printf ("%s", item->name); - _export_options_print (item->opts); + GF_VALIDATE_OR_GOTO(GF_EXP, item, out); + printf("%s", item->name); + _export_options_print(item->opts); out: - return; + return; } /** @@ -234,14 +235,14 @@ out: * Not for external use. */ static void -_export_item_deinit (struct export_item *item) +_export_item_deinit(struct export_item *item) { - if (!item) - return; + if (!item) + return; - _export_options_deinit (item->opts); - GF_FREE (item->name); - GF_FREE (item); + _export_options_deinit(item->opts); + GF_FREE(item->name); + GF_FREE(item); } /** @@ -253,19 +254,19 @@ _export_item_deinit (struct export_item *item) * Not for external use. */ static struct export_item * -_export_item_init () +_export_item_init() { - struct export_item *item = GF_CALLOC (1, sizeof (*item), - gf_common_mt_nfs_exports); - - if (item) { - GF_REF_INIT(item, _export_item_deinit); - } else { - gf_msg (GF_EXP, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to allocate export item!"); - } + struct export_item *item = GF_CALLOC(1, sizeof(*item), + gf_common_mt_nfs_exports); - return item; + if (item) { + GF_REF_INIT(item, _export_item_deinit); + } else { + gf_msg(GF_EXP, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to allocate export item!"); + } + + return item; } /** @@ -277,16 +278,16 @@ _export_item_init () * Not for external use. */ static struct export_options * -_export_options_init () +_export_options_init() { - struct export_options *opts = GF_CALLOC (1, sizeof (*opts), - gf_common_mt_nfs_exports); + struct export_options *opts = GF_CALLOC(1, sizeof(*opts), + gf_common_mt_nfs_exports); - if (!opts) - gf_msg (GF_EXP, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to allocate options structure!"); + if (!opts) + gf_msg(GF_EXP, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to allocate options structure!"); - return opts; + return opts; } /** @@ -297,14 +298,14 @@ _export_options_init () * Not for external use. */ static void -_export_options_deinit (struct export_options *opts) +_export_options_deinit(struct export_options *opts) { - if (!opts) - return; + if (!opts) + return; - GF_FREE (opts->anon_uid); - GF_FREE (opts->sec_type); - GF_FREE (opts); + GF_FREE(opts->anon_uid); + GF_FREE(opts->sec_type); + GF_FREE(opts); } /** @@ -315,31 +316,31 @@ _export_options_deinit (struct export_options *opts) * Not for external use. */ static void -_export_options_print (const struct export_options *opts) +_export_options_print(const struct export_options *opts) { - GF_VALIDATE_OR_GOTO (GF_EXP, opts, out); + GF_VALIDATE_OR_GOTO(GF_EXP, opts, out); - printf ("("); - if (opts->rw) - printf ("rw,"); - else - printf ("ro,"); + printf("("); + if (opts->rw) + printf("rw,"); + else + printf("ro,"); - if (opts->nosuid) - printf ("nosuid,"); + if (opts->nosuid) + printf("nosuid,"); - if (opts->root) - printf ("root,"); + if (opts->root) + printf("root,"); - if (opts->anon_uid) - printf ("anonuid=%s,", opts->anon_uid); + if (opts->anon_uid) + printf("anonuid=%s,", opts->anon_uid); - if (opts->sec_type) - printf ("sec=%s,", opts->sec_type); + if (opts->sec_type) + printf("sec=%s,", opts->sec_type); - printf (") "); + printf(") "); out: - return; + return; } /** @@ -355,14 +356,14 @@ out: * Not for external use. */ static int -__exp_dict_free_walk (dict_t *dict, char *key, data_t *val, void *tmp) +__exp_dict_free_walk(dict_t *dict, char *key, data_t *val, void *tmp) { - if (val) { - GF_REF_PUT ((struct export_item *)val->data); - val->data = NULL; - dict_del (dict, key); - } - return 0; + if (val) { + GF_REF_PUT((struct export_item *)val->data); + val->data = NULL; + dict_del(dict, key); + } + return 0; } /** @@ -374,14 +375,14 @@ __exp_dict_free_walk (dict_t *dict, char *key, data_t *val, void *tmp) * Not for external use. */ static void -_exp_dict_destroy (dict_t *ng_dict) +_exp_dict_destroy(dict_t *ng_dict) { - if (!ng_dict) - goto out; + if (!ng_dict) + goto out; - dict_foreach (ng_dict, __exp_dict_free_walk, NULL); + dict_foreach(ng_dict, __exp_dict_free_walk, NULL); out: - return; + return; } /** @@ -395,20 +396,22 @@ out: * failure: NULL */ struct export_dir * -exp_file_dir_from_uuid (const struct exports_file *file, - const uuid_t export_uuid) +exp_file_dir_from_uuid(const struct exports_file *file, + const uuid_t export_uuid) { - char export_uuid_str[512] = {0, }; - data_t *dirdata = NULL; - struct export_dir *dir = NULL; + char export_uuid_str[512] = { + 0, + }; + data_t *dirdata = NULL; + struct export_dir *dir = NULL; - gf_uuid_unparse (export_uuid, export_uuid_str); + gf_uuid_unparse(export_uuid, export_uuid_str); - dirdata = dict_get (file->exports_map, export_uuid_str); - if (dirdata) - dir = (struct export_dir *)dirdata->data; + dirdata = dict_get(file->exports_map, export_uuid_str); + if (dirdata) + dir = (struct export_dir *)dirdata->data; - return dir; + return dir; } /** @@ -425,32 +428,36 @@ exp_file_dir_from_uuid (const struct exports_file *file, * Not for external use. */ static void -_exp_file_insert (struct exports_file *file, struct export_dir *dir) +_exp_file_insert(struct exports_file *file, struct export_dir *dir) { - data_t *dirdata = NULL; - uint32_t hashedval = 0; - uuid_t export_uuid = {0, }; - char export_uuid_str[512] = {0, }; - char *dirdup = NULL; - - GF_VALIDATE_OR_GOTO (GF_EXP, file, out); - GF_VALIDATE_OR_GOTO (GF_EXP, dir, out); - - dirdata = bin_to_data (dir, sizeof (*dir)); - dict_set (file->exports_dict, dir->dir_name, dirdata); - - dirdup = strdupa (dir->dir_name); - while (strlen (dirdup) > 0 && dirdup[0] == '/') - dirdup++; - - hashedval = SuperFastHash (dirdup, strlen (dirdup)); - memset (export_uuid, 0, sizeof (export_uuid)); - memcpy (export_uuid, &hashedval, sizeof (hashedval)); - gf_uuid_unparse (export_uuid, export_uuid_str); - - dict_set (file->exports_map, export_uuid_str, dirdata); + data_t *dirdata = NULL; + uint32_t hashedval = 0; + uuid_t export_uuid = { + 0, + }; + char export_uuid_str[512] = { + 0, + }; + char *dirdup = NULL; + + GF_VALIDATE_OR_GOTO(GF_EXP, file, out); + GF_VALIDATE_OR_GOTO(GF_EXP, dir, out); + + dirdata = bin_to_data(dir, sizeof(*dir)); + dict_set(file->exports_dict, dir->dir_name, dirdata); + + dirdup = strdupa(dir->dir_name); + while (strlen(dirdup) > 0 && dirdup[0] == '/') + dirdup++; + + hashedval = SuperFastHash(dirdup, strlen(dirdup)); + memset(export_uuid, 0, sizeof(export_uuid)); + memcpy(export_uuid, &hashedval, sizeof(hashedval)); + gf_uuid_unparse(export_uuid, export_uuid_str); + + dict_set(file->exports_map, export_uuid_str, dirdata); out: - return; + return; } /** @@ -466,12 +473,12 @@ out: * Not for external use. */ static int -__exp_item_print_walk (dict_t *dict, char *key, data_t *val, void *tmp) +__exp_item_print_walk(dict_t *dict, char *key, data_t *val, void *tmp) { - if (val) - _export_item_print ((struct export_item *)val->data); + if (val) + _export_item_print((struct export_item *)val->data); - return 0; + return 0; } /** @@ -487,23 +494,22 @@ __exp_item_print_walk (dict_t *dict, char *key, data_t *val, void *tmp) * Not for external use. */ static int -__exp_file_print_walk (dict_t *dict, char *key, data_t *val, void *tmp) +__exp_file_print_walk(dict_t *dict, char *key, data_t *val, void *tmp) { - if (val) { - struct export_dir *dir = (struct export_dir *)val->data; + if (val) { + struct export_dir *dir = (struct export_dir *)val->data; - printf ("%s ", key); + printf("%s ", key); - if (dir->netgroups) - dict_foreach (dir->netgroups, __exp_item_print_walk, - NULL); + if (dir->netgroups) + dict_foreach(dir->netgroups, __exp_item_print_walk, NULL); - if (dir->hosts) - dict_foreach (dir->hosts, __exp_item_print_walk, NULL); + if (dir->hosts) + dict_foreach(dir->hosts, __exp_item_print_walk, NULL); - printf ("\n"); - } - return 0; + printf("\n"); + } + return 0; } /** @@ -514,29 +520,29 @@ __exp_file_print_walk (dict_t *dict, char *key, data_t *val, void *tmp) * Not for external use. */ void -exp_file_print (const struct exports_file *file) +exp_file_print(const struct exports_file *file) { - GF_VALIDATE_OR_GOTO (GF_EXP, file, out); - dict_foreach (file->exports_dict, __exp_file_print_walk, NULL); + GF_VALIDATE_OR_GOTO(GF_EXP, file, out); + dict_foreach(file->exports_dict, __exp_file_print_walk, NULL); out: - return; + return; } -#define __exp_line_get_opt_val(val, equals, ret, errlabel) \ - do { \ - (val) = (equals) + 1; \ - if (!(*(val))) { \ - (ret) = 1; \ - goto errlabel; \ - } \ - } while (0) \ +#define __exp_line_get_opt_val(val, equals, ret, errlabel) \ + do { \ + (val) = (equals) + 1; \ + if (!(*(val))) { \ + (ret) = 1; \ + goto errlabel; \ + } \ + } while (0) enum gf_exp_parse_status { - GF_EXP_PARSE_SUCCESS = 0, - GF_EXP_PARSE_ITEM_NOT_FOUND = 1, - GF_EXP_PARSE_ITEM_FAILURE = 2, - GF_EXP_PARSE_ITEM_NOT_IN_MOUNT_STATE = 3, - GF_EXP_PARSE_LINE_IGNORING = 4, + GF_EXP_PARSE_SUCCESS = 0, + GF_EXP_PARSE_ITEM_NOT_FOUND = 1, + GF_EXP_PARSE_ITEM_FAILURE = 2, + GF_EXP_PARSE_ITEM_NOT_IN_MOUNT_STATE = 3, + GF_EXP_PARSE_LINE_IGNORING = 4, }; /** @@ -559,48 +565,48 @@ enum gf_exp_parse_status { * Not for external use. */ static int -__exp_line_opt_key_value_parse (char *option, struct export_options *opts) +__exp_line_opt_key_value_parse(char *option, struct export_options *opts) { - char *equals = NULL; - char *right = NULL; - char *strmatch = option; - int ret = -EINVAL; + char *equals = NULL; + char *right = NULL; + char *strmatch = option; + int ret = -EINVAL; - GF_VALIDATE_OR_GOTO (GF_EXP, option, out); - GF_VALIDATE_OR_GOTO (GF_EXP, opts, out); + GF_VALIDATE_OR_GOTO(GF_EXP, option, out); + GF_VALIDATE_OR_GOTO(GF_EXP, opts, out); - equals = strchr (option, '='); - if (!equals) { - ret = GF_EXP_PARSE_ITEM_FAILURE; - goto out; - } - - *equals = 0; - /* Now that an '=' has been found the left side is the option and - * the right side is the value. We simply have to compare those and - * extract it. - */ - if (strcmp (strmatch, "anonuid") == 0) { - *equals = '='; - /* Get the value for this option */ - __exp_line_get_opt_val (right, equals, ret, out); - opts->anon_uid = gf_strdup (right); - GF_CHECK_ALLOC (opts->anon_uid, ret, out); - } else if (strcmp (strmatch, "sec") == 0) { - *equals = '='; - /* Get the value for this option */ - __exp_line_get_opt_val (right, equals, ret, out); - opts->sec_type = gf_strdup (right); - GF_CHECK_ALLOC (opts->sec_type, ret, out); - } else { - *equals = '='; - ret = GF_EXP_PARSE_ITEM_FAILURE; - goto out; - } + equals = strchr(option, '='); + if (!equals) { + ret = GF_EXP_PARSE_ITEM_FAILURE; + goto out; + } + + *equals = 0; + /* Now that an '=' has been found the left side is the option and + * the right side is the value. We simply have to compare those and + * extract it. + */ + if (strcmp(strmatch, "anonuid") == 0) { + *equals = '='; + /* Get the value for this option */ + __exp_line_get_opt_val(right, equals, ret, out); + opts->anon_uid = gf_strdup(right); + GF_CHECK_ALLOC(opts->anon_uid, ret, out); + } else if (strcmp(strmatch, "sec") == 0) { + *equals = '='; + /* Get the value for this option */ + __exp_line_get_opt_val(right, equals, ret, out); + opts->sec_type = gf_strdup(right); + GF_CHECK_ALLOC(opts->sec_type, ret, out); + } else { + *equals = '='; + ret = GF_EXP_PARSE_ITEM_FAILURE; + goto out; + } - ret = GF_EXP_PARSE_SUCCESS; + ret = GF_EXP_PARSE_SUCCESS; out: - return ret; + return ret; } /** @@ -619,87 +625,87 @@ out: * Not for external use. */ static int -__exp_line_opt_parse (const char *opt_str, struct export_options **exp_opts) +__exp_line_opt_parse(const char *opt_str, struct export_options **exp_opts) { - struct export_options *opts = NULL; - char *strmatch = NULL; - int ret = -EINVAL; - char *equals = NULL; + struct export_options *opts = NULL; + char *strmatch = NULL; + int ret = -EINVAL; + char *equals = NULL; - ret = parser_set_string (options_parser, opt_str); - if (ret < 0) - goto out; + ret = parser_set_string(options_parser, opt_str); + if (ret < 0) + goto out; - while ((strmatch = parser_get_next_match (options_parser))) { - if (!opts) { - /* If the options have not been allocated, - * allocate it. - */ - opts = _export_options_init (); - if (!opts) { - ret = -ENOMEM; - parser_unset_string (options_parser); - goto out; - } - } - - /* First, check for all the boolean options Second, check for - * an '=', and check the available options there. The string - * parsing here gets slightly messy, but the concept itself - * is pretty simple. - */ - equals = strchr (strmatch, '='); - if (strcmp (strmatch, "root") == 0) - opts->root = _gf_true; - else if (strcmp (strmatch, "ro") == 0) - opts->rw = _gf_false; - else if (strcmp (strmatch, "rw") == 0) - opts->rw = _gf_true; - else if (strcmp (strmatch, "nosuid") == 0) - opts->nosuid = _gf_true; - else if (equals) { - ret = __exp_line_opt_key_value_parse (strmatch, opts); - if (ret < 0) { - /* This means invalid key value options were - * specified, or memory allocation failed. - * The ret value gets bubbled up to the caller. - */ - GF_FREE (strmatch); - parser_unset_string (options_parser); - _export_options_deinit (opts); - goto out; - } - } else - /* Cannot change to gf_msg. - * gf_msg not giving output to STDOUT - * Bug id : BZ1215017 - */ - gf_log (GF_EXP, GF_LOG_WARNING, - "Could not find any valid options for " - "string: %s", strmatch); - GF_FREE (strmatch); + while ((strmatch = parser_get_next_match(options_parser))) { + if (!opts) { + /* If the options have not been allocated, + * allocate it. + */ + opts = _export_options_init(); + if (!opts) { + ret = -ENOMEM; + parser_unset_string(options_parser); + goto out; + } } - if (!opts) { - /* If opts is not allocated - * that means no matches were found - * which is a parse error. Not marking - * it as "not found" because it is a parse - * error to not have options. + /* First, check for all the boolean options Second, check for + * an '=', and check the available options there. The string + * parsing here gets slightly messy, but the concept itself + * is pretty simple. + */ + equals = strchr(strmatch, '='); + if (strcmp(strmatch, "root") == 0) + opts->root = _gf_true; + else if (strcmp(strmatch, "ro") == 0) + opts->rw = _gf_false; + else if (strcmp(strmatch, "rw") == 0) + opts->rw = _gf_true; + else if (strcmp(strmatch, "nosuid") == 0) + opts->nosuid = _gf_true; + else if (equals) { + ret = __exp_line_opt_key_value_parse(strmatch, opts); + if (ret < 0) { + /* This means invalid key value options were + * specified, or memory allocation failed. + * The ret value gets bubbled up to the caller. */ - ret = GF_EXP_PARSE_ITEM_FAILURE; - parser_unset_string (options_parser); + GF_FREE(strmatch); + parser_unset_string(options_parser); + _export_options_deinit(opts); goto out; - } + } + } else + /* Cannot change to gf_msg. + * gf_msg not giving output to STDOUT + * Bug id : BZ1215017 + */ + gf_log(GF_EXP, GF_LOG_WARNING, + "Could not find any valid options for " + "string: %s", + strmatch); + GF_FREE(strmatch); + } + + if (!opts) { + /* If opts is not allocated + * that means no matches were found + * which is a parse error. Not marking + * it as "not found" because it is a parse + * error to not have options. + */ + ret = GF_EXP_PARSE_ITEM_FAILURE; + parser_unset_string(options_parser); + goto out; + } - *exp_opts = opts; - parser_unset_string (options_parser); - ret = GF_EXP_PARSE_SUCCESS; + *exp_opts = opts; + parser_unset_string(options_parser); + ret = GF_EXP_PARSE_SUCCESS; out: - return ret; + return ret; } - /** * __exp_line_ng_host_str_parse -- Parse the netgroup or host string * @@ -716,76 +722,76 @@ out: * Not for external use. */ static int -__exp_line_ng_host_str_parse (char *str, struct export_item **exp_item) +__exp_line_ng_host_str_parse(char *str, struct export_item **exp_item) { - struct export_item *item = NULL; - int ret = -EINVAL; - char *parens = NULL; - char *optstr = NULL; - struct export_options *exp_opts = NULL; - char *item_name = NULL; - - GF_VALIDATE_OR_GOTO (GF_EXP, str, out); - GF_VALIDATE_OR_GOTO (GF_EXP, exp_item, out); - - /* A netgroup/host string looks like this: - * @test(sec=sys,rw,anonuid=0) or host(sec=sys,rw,anonuid=0) - * We want to extract the name, 'test' or 'host' - * Again, we could setup a regex and use it here, - * but its simpler to find the '(' and copy until - * there. - */ - parens = strchr (str, '('); - if (!parens) { - /* Parse error if there are no parens. */ - ret = GF_EXP_PARSE_ITEM_FAILURE; - goto out; - } + struct export_item *item = NULL; + int ret = -EINVAL; + char *parens = NULL; + char *optstr = NULL; + struct export_options *exp_opts = NULL; + char *item_name = NULL; + + GF_VALIDATE_OR_GOTO(GF_EXP, str, out); + GF_VALIDATE_OR_GOTO(GF_EXP, exp_item, out); + + /* A netgroup/host string looks like this: + * @test(sec=sys,rw,anonuid=0) or host(sec=sys,rw,anonuid=0) + * We want to extract the name, 'test' or 'host' + * Again, we could setup a regex and use it here, + * but its simpler to find the '(' and copy until + * there. + */ + parens = strchr(str, '('); + if (!parens) { + /* Parse error if there are no parens. */ + ret = GF_EXP_PARSE_ITEM_FAILURE; + goto out; + } - *parens = '\0'; /* Temporarily terminate it so we can do a copy */ + *parens = '\0'; /* Temporarily terminate it so we can do a copy */ - if (strlen (str) > FQDN_MAX_LEN) { - ret = GF_EXP_PARSE_ITEM_FAILURE; - goto out; - } + if (strlen(str) > FQDN_MAX_LEN) { + ret = GF_EXP_PARSE_ITEM_FAILURE; + goto out; + } - /* Strip leading whitespaces */ - while (*str == ' ' || *str == '\t') - str++; + /* Strip leading whitespaces */ + while (*str == ' ' || *str == '\t') + str++; - item_name = gf_strdup (str); - GF_CHECK_ALLOC (item_name, ret, out); + item_name = gf_strdup(str); + GF_CHECK_ALLOC(item_name, ret, out); - gf_msg_trace (GF_EXP, 0, "found hostname/netgroup: %s", item_name); + gf_msg_trace(GF_EXP, 0, "found hostname/netgroup: %s", item_name); - /* Initialize an export item for this */ - item = _export_item_init (); - GF_CHECK_ALLOC (item, ret, free_and_out); - item->name = item_name; + /* Initialize an export item for this */ + item = _export_item_init(); + GF_CHECK_ALLOC(item, ret, free_and_out); + item->name = item_name; - *parens = '('; /* Restore the string */ + *parens = '('; /* Restore the string */ - /* Options start at the parentheses */ - optstr = parens; + /* Options start at the parentheses */ + optstr = parens; - ret = __exp_line_opt_parse (optstr, &exp_opts); - if (ret != 0) { - /* Bubble up the error to the caller */ - GF_REF_PUT (item); - goto out; - } + ret = __exp_line_opt_parse(optstr, &exp_opts); + if (ret != 0) { + /* Bubble up the error to the caller */ + GF_REF_PUT(item); + goto out; + } - item->opts = exp_opts; + item->opts = exp_opts; - *exp_item = item; + *exp_item = item; - ret = GF_EXP_PARSE_SUCCESS; - goto out; + ret = GF_EXP_PARSE_SUCCESS; + goto out; free_and_out: - GF_FREE (item_name); + GF_FREE(item_name); out: - return ret; + return ret; } /** @@ -816,75 +822,75 @@ out: * Not for external use. */ static int -__exp_line_ng_parse (const char *line, dict_t **ng_dict) +__exp_line_ng_parse(const char *line, dict_t **ng_dict) { - dict_t *netgroups = NULL; - char *strmatch = NULL; - int ret = -EINVAL; - struct export_item *exp_ng = NULL; - data_t *ngdata = NULL; - - GF_VALIDATE_OR_GOTO (GF_EXP, line, out); - GF_VALIDATE_OR_GOTO (GF_EXP, ng_dict, out); + dict_t *netgroups = NULL; + char *strmatch = NULL; + int ret = -EINVAL; + struct export_item *exp_ng = NULL; + data_t *ngdata = NULL; + + GF_VALIDATE_OR_GOTO(GF_EXP, line, out); + GF_VALIDATE_OR_GOTO(GF_EXP, ng_dict, out); + + *ng_dict = NULL; /* Will be set if parse is successful */ + + /* Initialize a parser with the line to parse + * and the regex used to parse it. + */ + ret = parser_set_string(netgroup_parser, line); + if (ret < 0) { + goto out; + } - *ng_dict = NULL; /* Will be set if parse is successful */ + gf_msg_trace(GF_EXP, 0, "parsing line: %s", line); - /* Initialize a parser with the line to parse - * and the regex used to parse it. - */ - ret = parser_set_string (netgroup_parser, line); - if (ret < 0) { - goto out; + while ((strmatch = parser_get_next_match(netgroup_parser))) { + if (!netgroups) { + /* Allocate a new dict to store the netgroups. */ + netgroups = dict_new(); + if (!netgroups) { + ret = -ENOMEM; + goto free_and_out; + } } - gf_msg_trace (GF_EXP, 0, "parsing line: %s", line); + gf_msg_trace(GF_EXP, 0, "parsing netgroup: %s", strmatch); - while ((strmatch = parser_get_next_match (netgroup_parser))) { - if (!netgroups) { - /* Allocate a new dict to store the netgroups. */ - netgroups = dict_new (); - if (!netgroups) { - ret = -ENOMEM; - goto free_and_out; - } - } + ret = __exp_line_ng_host_str_parse(strmatch, &exp_ng); - gf_msg_trace (GF_EXP, 0, "parsing netgroup: %s", strmatch); - - ret = __exp_line_ng_host_str_parse (strmatch, &exp_ng); - - if (ret != 0) { - /* Parsing or other critical errors. - * caller will handle return value. - */ - _exp_dict_destroy (netgroups); - goto free_and_out; - } + if (ret != 0) { + /* Parsing or other critical errors. + * caller will handle return value. + */ + _exp_dict_destroy(netgroups); + goto free_and_out; + } - ngdata = bin_to_data (exp_ng, sizeof (*exp_ng)); - dict_set (netgroups, exp_ng->name, ngdata); + ngdata = bin_to_data(exp_ng, sizeof(*exp_ng)); + dict_set(netgroups, exp_ng->name, ngdata); - /* Free this matched string and continue parsing. */ - GF_FREE (strmatch); - } + /* Free this matched string and continue parsing. */ + GF_FREE(strmatch); + } - /* If the netgroups dict was not allocated, then we know that - * no matches were found. - */ - if (!netgroups) { - ret = GF_EXP_PARSE_ITEM_NOT_FOUND; - parser_unset_string (netgroup_parser); - goto out; - } + /* If the netgroups dict was not allocated, then we know that + * no matches were found. + */ + if (!netgroups) { + ret = GF_EXP_PARSE_ITEM_NOT_FOUND; + parser_unset_string(netgroup_parser); + goto out; + } - ret = GF_EXP_PARSE_SUCCESS; - *ng_dict = netgroups; + ret = GF_EXP_PARSE_SUCCESS; + *ng_dict = netgroups; free_and_out: - parser_unset_string (netgroup_parser); - GF_FREE (strmatch); + parser_unset_string(netgroup_parser); + GF_FREE(strmatch); out: - return ret; + return ret; } /** @@ -915,77 +921,75 @@ out: * Not for external use. */ static int -__exp_line_host_parse (const char *line, dict_t **host_dict) +__exp_line_host_parse(const char *line, dict_t **host_dict) { - dict_t *hosts = NULL; - char *strmatch = NULL; - int ret = -EINVAL; - struct export_item *exp_host = NULL; - data_t *hostdata = NULL; - - GF_VALIDATE_OR_GOTO (GF_EXP, line, out); - GF_VALIDATE_OR_GOTO (GF_EXP, host_dict, out); + dict_t *hosts = NULL; + char *strmatch = NULL; + int ret = -EINVAL; + struct export_item *exp_host = NULL; + data_t *hostdata = NULL; + + GF_VALIDATE_OR_GOTO(GF_EXP, line, out); + GF_VALIDATE_OR_GOTO(GF_EXP, host_dict, out); + + *host_dict = NULL; + + /* Initialize a parser with the line to parse and the regex used to + * parse it. + */ + ret = parser_set_string(hostname_parser, line); + if (ret < 0) { + goto out; + } - *host_dict = NULL; + gf_msg_trace(GF_EXP, 0, "parsing line: %s", line); - /* Initialize a parser with the line to parse and the regex used to - * parse it. - */ - ret = parser_set_string (hostname_parser, line); - if (ret < 0) { - goto out; + while ((strmatch = parser_get_next_match(hostname_parser))) { + if (!hosts) { + /* Allocate a new dictto store the netgroups. */ + hosts = dict_new(); + GF_CHECK_ALLOC(hosts, ret, free_and_out); } - gf_msg_trace (GF_EXP, 0, "parsing line: %s", line); - - while ((strmatch = parser_get_next_match (hostname_parser))) { - if (!hosts) { - /* Allocate a new dictto store the netgroups. */ - hosts = dict_new (); - GF_CHECK_ALLOC (hosts, ret, free_and_out); - } - - gf_msg_trace (GF_EXP, 0, "parsing hostname: %s", strmatch); + gf_msg_trace(GF_EXP, 0, "parsing hostname: %s", strmatch); - ret = __exp_line_ng_host_str_parse (strmatch, &exp_host); + ret = __exp_line_ng_host_str_parse(strmatch, &exp_host); - if (ret != 0) { - /* Parsing or other critical error, free allocated - * memory and exit. The caller will handle the errors. - */ - _exp_dict_destroy (hosts); - goto free_and_out; - } - - /* Insert export item structure into the hosts dict. */ - hostdata = bin_to_data (exp_host, sizeof (*exp_host)); - dict_set (hosts, exp_host->name, hostdata); + if (ret != 0) { + /* Parsing or other critical error, free allocated + * memory and exit. The caller will handle the errors. + */ + _exp_dict_destroy(hosts); + goto free_and_out; + } + /* Insert export item structure into the hosts dict. */ + hostdata = bin_to_data(exp_host, sizeof(*exp_host)); + dict_set(hosts, exp_host->name, hostdata); - /* Free this matched string and continue parsing.*/ - GF_FREE (strmatch); - } + /* Free this matched string and continue parsing.*/ + GF_FREE(strmatch); + } - /* If the hosts dict was not allocated, then we know that - * no matches were found. - */ - if (!exp_host) { - ret = GF_EXP_PARSE_ITEM_NOT_FOUND; - parser_unset_string (hostname_parser); - goto out; - } + /* If the hosts dict was not allocated, then we know that + * no matches were found. + */ + if (!exp_host) { + ret = GF_EXP_PARSE_ITEM_NOT_FOUND; + parser_unset_string(hostname_parser); + goto out; + } - ret = GF_EXP_PARSE_SUCCESS; - *host_dict = hosts; + ret = GF_EXP_PARSE_SUCCESS; + *host_dict = hosts; free_and_out: - parser_unset_string (hostname_parser); - GF_FREE (strmatch); + parser_unset_string(hostname_parser); + GF_FREE(strmatch); out: - return ret; + return ret; } - /** * __exp_line_dir_parse -- Extract directory name from a line in the exports * file. @@ -1010,70 +1014,71 @@ out: * Not for external use. */ static int -__exp_line_dir_parse (const char *line, char **dirname, struct mount3_state *ms) +__exp_line_dir_parse(const char *line, char **dirname, struct mount3_state *ms) { - char *dir = NULL; - char *delim = NULL; - int ret = -EINVAL; - char *linedup = NULL; - struct mnt3_export *mnt3export = NULL; - size_t dirlen = 0; - - GF_VALIDATE_OR_GOTO (GF_EXP, line, out); - GF_VALIDATE_OR_GOTO (GF_EXP, dirname, out); - - /* Duplicate the line because we don't - * want to modify the original string. + char *dir = NULL; + char *delim = NULL; + int ret = -EINVAL; + char *linedup = NULL; + struct mnt3_export *mnt3export = NULL; + size_t dirlen = 0; + + GF_VALIDATE_OR_GOTO(GF_EXP, line, out); + GF_VALIDATE_OR_GOTO(GF_EXP, dirname, out); + + /* Duplicate the line because we don't + * want to modify the original string. + */ + linedup = strdupa(line); + + /* We use strtok_r () here to split the string by space/tab and get the + * the result. We only need the first result of the split. + * a simple task. It is worth noting that dirnames always have to be + * validated against gluster's vol files so if they don't + * match it will be rejected. + */ + dir = linedup; + delim = linedup + strcspn(linedup, " \t"); + *delim = 0; + + if (ms) { + /* Match the directory name with an existing + * export in the mount state. */ - linedup = strdupa (line); - - /* We use strtok_r () here to split the string by space/tab and get the - * the result. We only need the first result of the split. - * a simple task. It is worth noting that dirnames always have to be - * validated against gluster's vol files so if they don't - * match it will be rejected. - */ - dir = linedup; - delim = linedup + strcspn (linedup, " \t"); - *delim = 0; - - if (ms) { - /* Match the directory name with an existing - * export in the mount state. - */ - mnt3export = mnt3_mntpath_to_export (ms, dir, _gf_true); - if (!mnt3export) { - gf_msg_debug (GF_EXP, 0, "%s not in mount state, " - "ignoring!", dir); - ret = GF_EXP_PARSE_ITEM_NOT_IN_MOUNT_STATE; - goto out; - } - } - - /* Directories can be 1024 bytes in length, check - * that the argument provided adheres to - * that restriction. - */ - if (strlen (dir) > DIR_MAX_LEN) { - ret = -EINVAL; - goto out; + mnt3export = mnt3_mntpath_to_export(ms, dir, _gf_true); + if (!mnt3export) { + gf_msg_debug(GF_EXP, 0, + "%s not in mount state, " + "ignoring!", + dir); + ret = GF_EXP_PARSE_ITEM_NOT_IN_MOUNT_STATE; + goto out; } + } + + /* Directories can be 1024 bytes in length, check + * that the argument provided adheres to + * that restriction. + */ + if (strlen(dir) > DIR_MAX_LEN) { + ret = -EINVAL; + goto out; + } - /* Copy the result of the split */ - dir = gf_strdup (dir); - GF_CHECK_ALLOC (dir, ret, out); - - /* Ensure that trailing slashes are stripped before storing the name */ - dirlen = strlen (dir); - if (dirlen > 0 && dir[dirlen - 1] == '/') - dir[dirlen - 1] = '\0'; + /* Copy the result of the split */ + dir = gf_strdup(dir); + GF_CHECK_ALLOC(dir, ret, out); + /* Ensure that trailing slashes are stripped before storing the name */ + dirlen = strlen(dir); + if (dirlen > 0 && dir[dirlen - 1] == '/') + dir[dirlen - 1] = '\0'; - /* Set the argument to point to the allocated string */ - *dirname = dir; - ret = GF_EXP_PARSE_SUCCESS; + /* Set the argument to point to the allocated string */ + *dirname = dir; + ret = GF_EXP_PARSE_SUCCESS; out: - return ret; + return ret; } /** @@ -1121,126 +1126,126 @@ out: * Not for external use. */ static int -_exp_line_parse (const char *line, struct export_dir **dir, - gf_boolean_t parse_full, struct mount3_state *ms) +_exp_line_parse(const char *line, struct export_dir **dir, + gf_boolean_t parse_full, struct mount3_state *ms) { - struct export_dir *expdir = NULL; - char *dirstr = NULL; - dict_t *netgroups = NULL; - dict_t *hosts = NULL; - int ret = -EINVAL; - gf_boolean_t netgroups_failed = _gf_false; - - GF_VALIDATE_OR_GOTO (GF_EXP, line, out); - GF_VALIDATE_OR_GOTO (GF_EXP, dir, out); - - if (*line == '#' || *line == ' ' || *line == '\t' - || *line == '\0' || *line == '\n') { - ret = GF_EXP_PARSE_LINE_IGNORING; - goto out; - } - - expdir = _export_dir_init (); - if (!expdir) { - *dir = NULL; - ret = -ENOMEM; - goto out; - } - - /* Get the directory string from the line */ - ret = __exp_line_dir_parse (line, &dirstr, ms); - if (ret < 0) { - gf_msg (GF_EXP, GF_LOG_ERROR, 0, NFS_MSG_PARSE_DIR_FAIL, - "Parsing directory failed: %s", strerror (-ret)); - /* If parsing the directory failed, - * we should simply fail because there's - * nothing else we can extract from the string to make - * the data valuable. - */ - goto free_and_out; - } - - /* Set the dir str */ - expdir->dir_name = dirstr; - - /* Parse the netgroup part of the string */ - ret = __exp_line_ng_parse (line, &netgroups); - if (ret < 0) { - gf_msg (GF_EXP, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, - "Critical error: %s", strerror (-ret)); - /* Return values less than 0 - * indicate critical failures (null parameters, - * failure to allocate memory, etc). - */ - goto free_and_out; - } - if (ret != 0) { - if (ret == GF_EXP_PARSE_ITEM_FAILURE) - /* Cannot change to gf_msg. - * gf_msg not giving output to STDOUT - * Bug id : BZ1215017 - */ - gf_log (GF_EXP, GF_LOG_WARNING, - "Error parsing netgroups for: %s", line); - /* Even though parsing failed for the netgroups we should let - * host parsing proceed. - */ - netgroups_failed = _gf_true; - } - - /* Parse the host part of the string */ - ret = __exp_line_host_parse (line, &hosts); - if (ret < 0) { - gf_msg (GF_EXP, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, - "Critical error: %s", strerror (-ret)); - goto free_and_out; - } - if (ret != 0) { - if (ret == GF_EXP_PARSE_ITEM_FAILURE) - gf_msg (GF_EXP, GF_LOG_WARNING, 0, NFS_MSG_PARSE_FAIL, - "Error parsing hosts for: %s", line); - /* If netgroups parsing failed, AND - * host parsing failed, then there's something really - * wrong with this line, so we're just going to - * log it and fail out. - */ - if (netgroups_failed) - goto free_and_out; - } + struct export_dir *expdir = NULL; + char *dirstr = NULL; + dict_t *netgroups = NULL; + dict_t *hosts = NULL; + int ret = -EINVAL; + gf_boolean_t netgroups_failed = _gf_false; + + GF_VALIDATE_OR_GOTO(GF_EXP, line, out); + GF_VALIDATE_OR_GOTO(GF_EXP, dir, out); + + if (*line == '#' || *line == ' ' || *line == '\t' || *line == '\0' || + *line == '\n') { + ret = GF_EXP_PARSE_LINE_IGNORING; + goto out; + } - expdir->hosts = hosts; - expdir->netgroups = netgroups; - *dir = expdir; + expdir = _export_dir_init(); + if (!expdir) { + *dir = NULL; + ret = -ENOMEM; goto out; + } + + /* Get the directory string from the line */ + ret = __exp_line_dir_parse(line, &dirstr, ms); + if (ret < 0) { + gf_msg(GF_EXP, GF_LOG_ERROR, 0, NFS_MSG_PARSE_DIR_FAIL, + "Parsing directory failed: %s", strerror(-ret)); + /* If parsing the directory failed, + * we should simply fail because there's + * nothing else we can extract from the string to make + * the data valuable. + */ + goto free_and_out; + } + + /* Set the dir str */ + expdir->dir_name = dirstr; + + /* Parse the netgroup part of the string */ + ret = __exp_line_ng_parse(line, &netgroups); + if (ret < 0) { + gf_msg(GF_EXP, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, + "Critical error: %s", strerror(-ret)); + /* Return values less than 0 + * indicate critical failures (null parameters, + * failure to allocate memory, etc). + */ + goto free_and_out; + } + if (ret != 0) { + if (ret == GF_EXP_PARSE_ITEM_FAILURE) + /* Cannot change to gf_msg. + * gf_msg not giving output to STDOUT + * Bug id : BZ1215017 + */ + gf_log(GF_EXP, GF_LOG_WARNING, "Error parsing netgroups for: %s", + line); + /* Even though parsing failed for the netgroups we should let + * host parsing proceed. + */ + netgroups_failed = _gf_true; + } + + /* Parse the host part of the string */ + ret = __exp_line_host_parse(line, &hosts); + if (ret < 0) { + gf_msg(GF_EXP, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, + "Critical error: %s", strerror(-ret)); + goto free_and_out; + } + if (ret != 0) { + if (ret == GF_EXP_PARSE_ITEM_FAILURE) + gf_msg(GF_EXP, GF_LOG_WARNING, 0, NFS_MSG_PARSE_FAIL, + "Error parsing hosts for: %s", line); + /* If netgroups parsing failed, AND + * host parsing failed, then there's something really + * wrong with this line, so we're just going to + * log it and fail out. + */ + if (netgroups_failed) + goto free_and_out; + } + + expdir->hosts = hosts; + expdir->netgroups = netgroups; + *dir = expdir; + goto out; free_and_out: - _export_dir_deinit (expdir); + _export_dir_deinit(expdir); out: - return ret; + return ret; } struct export_item * -exp_dir_get_netgroup (const struct export_dir *expdir, const char *netgroup) +exp_dir_get_netgroup(const struct export_dir *expdir, const char *netgroup) { - struct export_item *lookup_res = NULL; - data_t *dict_res = NULL; + struct export_item *lookup_res = NULL; + data_t *dict_res = NULL; - GF_VALIDATE_OR_GOTO (GF_EXP, expdir, out); - GF_VALIDATE_OR_GOTO (GF_EXP, netgroup, out); + GF_VALIDATE_OR_GOTO(GF_EXP, expdir, out); + GF_VALIDATE_OR_GOTO(GF_EXP, netgroup, out); - if (!expdir->netgroups) - goto out; + if (!expdir->netgroups) + goto out; - dict_res = dict_get (expdir->netgroups, (char *)netgroup); - if (!dict_res) { - gf_msg_debug (GF_EXP, 0, "%s not found for %s", - netgroup, expdir->dir_name); - goto out; - } + dict_res = dict_get(expdir->netgroups, (char *)netgroup); + if (!dict_res) { + gf_msg_debug(GF_EXP, 0, "%s not found for %s", netgroup, + expdir->dir_name); + goto out; + } - lookup_res = (struct export_item *)dict_res->data; + lookup_res = (struct export_item *)dict_res->data; out: - return lookup_res; + return lookup_res; } /** * exp_dir_get_host -- Given a host string and an exports directory structure, @@ -1254,35 +1259,33 @@ out: * failure: NULL */ struct export_item * -exp_dir_get_host (const struct export_dir *expdir, const char *host) +exp_dir_get_host(const struct export_dir *expdir, const char *host) { - struct export_item *lookup_res = NULL; - data_t *dict_res = NULL; + struct export_item *lookup_res = NULL; + data_t *dict_res = NULL; - GF_VALIDATE_OR_GOTO (GF_EXP, expdir, out); - GF_VALIDATE_OR_GOTO (GF_EXP, host, out); + GF_VALIDATE_OR_GOTO(GF_EXP, expdir, out); + GF_VALIDATE_OR_GOTO(GF_EXP, host, out); - if (!expdir->hosts) - goto out; + if (!expdir->hosts) + goto out; + + dict_res = dict_get(expdir->hosts, (char *)host); + if (!dict_res) { + gf_msg_debug(GF_EXP, 0, "%s not found for %s", host, expdir->dir_name); - dict_res = dict_get (expdir->hosts, (char *)host); + /* Check if wildcards are allowed for the host */ + dict_res = dict_get(expdir->hosts, "*"); if (!dict_res) { - gf_msg_debug (GF_EXP, 0, "%s not found for %s", - host, expdir->dir_name); - - /* Check if wildcards are allowed for the host */ - dict_res = dict_get (expdir->hosts, "*"); - if (!dict_res) { - goto out; - } + goto out; } + } - lookup_res = (struct export_item *)dict_res->data; + lookup_res = (struct export_item *)dict_res->data; out: - return lookup_res; + return lookup_res; } - /** * exp_file_get_dir -- Return an export dir given a directory name * Does a lookup from the dict in the file structure. @@ -1294,38 +1297,37 @@ out: * failure: NULL */ struct export_dir * -exp_file_get_dir (const struct exports_file *file, const char *dir) +exp_file_get_dir(const struct exports_file *file, const char *dir) { - struct export_dir *lookup_res = NULL; - data_t *dict_res = NULL; - char *dirdup = NULL; - size_t dirlen = 0; + struct export_dir *lookup_res = NULL; + data_t *dict_res = NULL; + char *dirdup = NULL; + size_t dirlen = 0; - GF_VALIDATE_OR_GOTO (GF_EXP, file, out); - GF_VALIDATE_OR_GOTO (GF_EXP, dir, out); + GF_VALIDATE_OR_GOTO(GF_EXP, file, out); + GF_VALIDATE_OR_GOTO(GF_EXP, dir, out); - dirlen = strlen (dir); - if (dirlen <= 0) - goto out; + dirlen = strlen(dir); + if (dirlen <= 0) + goto out; - dirdup = (char *)dir; /* Point at the directory */ + dirdup = (char *)dir; /* Point at the directory */ - /* If directories don't contain a leading slash */ - if (*dir != '/') { - dirdup = alloca (dirlen + 2); /* Leading slash & null byte */ - snprintf (dirdup, dirlen + 2, "/%s", dir); - } + /* If directories don't contain a leading slash */ + if (*dir != '/') { + dirdup = alloca(dirlen + 2); /* Leading slash & null byte */ + snprintf(dirdup, dirlen + 2, "/%s", dir); + } - dict_res = dict_get (file->exports_dict, dirdup); - if (!dict_res) { - gf_msg_debug (GF_EXP, 0, "%s not found in %s", dirdup, - file->filename); - goto out; - } + dict_res = dict_get(file->exports_dict, dirdup); + if (!dict_res) { + gf_msg_debug(GF_EXP, 0, "%s not found in %s", dirdup, file->filename); + goto out; + } - lookup_res = (struct export_dir *)dict_res->data; + lookup_res = (struct export_dir *)dict_res->data; out: - return lookup_res; + return lookup_res; } /** @@ -1347,129 +1349,130 @@ out: * Externally usable. */ int -exp_file_parse (const char *filepath, struct exports_file **expfile, - struct mount3_state *ms) +exp_file_parse(const char *filepath, struct exports_file **expfile, + struct mount3_state *ms) { - FILE *fp = NULL; - struct exports_file *file = NULL; - size_t len = 0; - int ret = -EINVAL; - unsigned long line_number = 0; - char *line = NULL; - struct export_dir *expdir = NULL; - - /* Sets whether we we should parse the entire file or just that which - * is present in the mount state */ - gf_boolean_t parse_complete_file = _gf_false; - - GF_VALIDATE_OR_GOTO (GF_EXP, expfile, parse_done); - - if (!ms) { - /* If mount state is null that means that we - * should go through and parse the whole file - * since we don't have anything to compare against. - */ - parse_complete_file = _gf_true; + FILE *fp = NULL; + struct exports_file *file = NULL; + size_t len = 0; + int ret = -EINVAL; + unsigned long line_number = 0; + char *line = NULL; + struct export_dir *expdir = NULL; + + /* Sets whether we we should parse the entire file or just that which + * is present in the mount state */ + gf_boolean_t parse_complete_file = _gf_false; + + GF_VALIDATE_OR_GOTO(GF_EXP, expfile, parse_done); + + if (!ms) { + /* If mount state is null that means that we + * should go through and parse the whole file + * since we don't have anything to compare against. + */ + parse_complete_file = _gf_true; + } + + fp = fopen(filepath, "r"); + if (!fp) { + ret = -errno; + goto parse_done; + } + + ret = _exp_init_parsers(); + if (ret < 0) + goto parse_done; + + /* Process the file line by line, with each line being parsed into + * an struct export_dir struct. If 'parse_complete_file' is set to TRUE + * then + */ + while (getline(&line, &len, fp) != -1) { + line_number++; /* Keeping track of line number allows us to + * to log which line numbers were wrong + */ + strtok(line, "\n"); /* removes the newline character from + * the line + */ + + /* Parse the line from the file into an struct export_dir + * structure. The process is as follows: + * Given a line like : + * "/vol @test(sec=sys,rw,anonuid=0) 10.35.11.31(sec=sys,rw)" + * + * This function will allocate an export dir and set its name + * to '/vol', using the function _exp_line_dir_parse (). + * + * Then it will extract the netgroups from the line, in this + * case it would be '@test(sec=sys,rw,anonuid=0)', and set the + * item structure's name to '@test'. + * It will also extract the options from that string and parse + * them into an struct export_options which will be pointed + * to by the item structure. This will be put into a dict + * which will be pointed to by the export directory structure. + * + * The same process happens above for the host string + * '10.35.11.32(sec=sys,rw)' + */ + ret = _exp_line_parse(line, &expdir, parse_complete_file, ms); + if (ret == -ENOMEM) { + /* If we get memory allocation errors, we really should + * not continue parsing, so just free the allocated + * memory and exit. + */ + goto free_and_done; } - fp = fopen (filepath, "r"); - if (!fp) { - ret = -errno; - goto parse_done; + if (ret < 0) { + gf_msg(GF_EXP, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, + "Failed to parse line #%lu", line_number); + continue; /* Skip entering this line and continue */ } - ret = _exp_init_parsers (); - if (ret < 0) - goto parse_done; + if (ret == GF_EXP_PARSE_LINE_IGNORING) { + /* This just means the line was empty or started with a + * '#' or a ' ' and we are ignoring it. + */ + gf_msg_debug(GF_EXP, 0, + "Ignoring line #%lu because it started " + "with a %c", + line_number, *line); + continue; + } - /* Process the file line by line, with each line being parsed into - * an struct export_dir struct. If 'parse_complete_file' is set to TRUE - * then - */ - while (getline (&line, &len, fp) != -1) { - line_number++; /* Keeping track of line number allows us to - * to log which line numbers were wrong - */ - strtok (line, "\n"); /* removes the newline character from - * the line - */ - - /* Parse the line from the file into an struct export_dir - * structure. The process is as follows: - * Given a line like : - * "/vol @test(sec=sys,rw,anonuid=0) 10.35.11.31(sec=sys,rw)" - * - * This function will allocate an export dir and set its name - * to '/vol', using the function _exp_line_dir_parse (). - * - * Then it will extract the netgroups from the line, in this - * case it would be '@test(sec=sys,rw,anonuid=0)', and set the - * item structure's name to '@test'. - * It will also extract the options from that string and parse - * them into an struct export_options which will be pointed - * to by the item structure. This will be put into a dict - * which will be pointed to by the export directory structure. - * - * The same process happens above for the host string - * '10.35.11.32(sec=sys,rw)' - */ - ret = _exp_line_parse (line, &expdir, parse_complete_file, ms); - if (ret == -ENOMEM) { - /* If we get memory allocation errors, we really should - * not continue parsing, so just free the allocated - * memory and exit. - */ - goto free_and_done; - } - - if (ret < 0) { - gf_msg (GF_EXP, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, - "Failed to parse line #%lu", line_number); - continue; /* Skip entering this line and continue */ - } - - if (ret == GF_EXP_PARSE_LINE_IGNORING) { - /* This just means the line was empty or started with a - * '#' or a ' ' and we are ignoring it. - */ - gf_msg_debug (GF_EXP, 0, - "Ignoring line #%lu because it started " - "with a %c", line_number, *line); - continue; - } - - if (!file) { - file = _exports_file_init (); - GF_CHECK_ALLOC_AND_LOG (GF_EXP, file, ret, - "Allocation error while " - "allocating file struct", - parse_done); - - file->filename = gf_strdup (filepath); - GF_CHECK_ALLOC_AND_LOG (GF_EXP, file, ret, - "Allocation error while " - "duping filepath", - free_and_done); - } - - /* If the parsing is successful store the export directory - * in the file structure. - */ - _exp_file_insert (file, expdir); + if (!file) { + file = _exports_file_init(); + GF_CHECK_ALLOC_AND_LOG(GF_EXP, file, ret, + "Allocation error while " + "allocating file struct", + parse_done); + + file->filename = gf_strdup(filepath); + GF_CHECK_ALLOC_AND_LOG(GF_EXP, file, ret, + "Allocation error while " + "duping filepath", + free_and_done); } - /* line got allocated through getline(), don't use GF_FREE() for it */ - free (line); + /* If the parsing is successful store the export directory + * in the file structure. + */ + _exp_file_insert(file, expdir); + } - *expfile = file; - goto parse_done; + /* line got allocated through getline(), don't use GF_FREE() for it */ + free(line); + + *expfile = file; + goto parse_done; free_and_done: - exp_file_deinit (file); + exp_file_deinit(file); parse_done: - if (fp) - fclose (fp); - _exp_deinit_parsers (); - return ret; + if (fp) + fclose(fp); + _exp_deinit_parsers(); + return ret; } diff --git a/xlators/nfs/server/src/mount3-auth.c b/xlators/nfs/server/src/mount3-auth.c index 97c95cbfd2..37839c230e 100644 --- a/xlators/nfs/server/src/mount3-auth.c +++ b/xlators/nfs/server/src/mount3-auth.c @@ -54,19 +54,18 @@ * For external use. */ struct mnt3_auth_params * -mnt3_auth_params_init (struct mount3_state *ms) +mnt3_auth_params_init(struct mount3_state *ms) { - struct mnt3_auth_params *auth_params = NULL; + struct mnt3_auth_params *auth_params = NULL; - auth_params = GF_MALLOC (sizeof (*auth_params), - gf_nfs_mt_mnt3_auth_params); - GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, auth_params, out); + auth_params = GF_MALLOC(sizeof(*auth_params), gf_nfs_mt_mnt3_auth_params); + GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, auth_params, out); - auth_params->ngfile = NULL; - auth_params->expfile = NULL; - auth_params->ms = ms; + auth_params->ngfile = NULL; + auth_params->expfile = NULL; + auth_params->ms = ms; out: - return auth_params; + return auth_params; } /** @@ -77,23 +76,23 @@ out: * For external use. */ void -mnt3_auth_params_deinit (struct mnt3_auth_params *auth_params) +mnt3_auth_params_deinit(struct mnt3_auth_params *auth_params) { - if (!auth_params) - goto out; - - /* Atomically set the auth params in the mount state to NULL - * so subsequent fops will be denied while the auth params - * are being cleaned up. - */ - (void)__sync_lock_test_and_set (&auth_params->ms->auth_params, NULL); - - ng_file_deinit (auth_params->ngfile); - exp_file_deinit (auth_params->expfile); - auth_params->ms = NULL; - GF_FREE (auth_params); + if (!auth_params) + goto out; + + /* Atomically set the auth params in the mount state to NULL + * so subsequent fops will be denied while the auth params + * are being cleaned up. + */ + (void)__sync_lock_test_and_set(&auth_params->ms->auth_params, NULL); + + ng_file_deinit(auth_params->ngfile); + exp_file_deinit(auth_params->expfile); + auth_params->ms = NULL; + GF_FREE(auth_params); out: - return; + return; } /** @@ -108,32 +107,33 @@ out: * For external use. */ int -mnt3_auth_set_exports_auth (struct mnt3_auth_params *auth_params, - const char *filename) +mnt3_auth_set_exports_auth(struct mnt3_auth_params *auth_params, + const char *filename) { - struct exports_file *expfile = NULL; - struct exports_file *oldfile = NULL; - int ret = -EINVAL; - - /* Validate args */ - GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, auth_params, out); - GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, filename, out); - - /* Parse the exports file and set the auth parameter */ - ret = exp_file_parse (filename, &expfile, auth_params->ms); - if (ret < 0) { - gf_msg (GF_MNT_AUTH, GF_LOG_ERROR, 0, NFS_MSG_LOAD_PARSE_ERROR, - "Failed to load & parse file" - " %s, see logs for more information", filename); - goto out; - } - - /* Atomically set the file pointer */ - oldfile = __sync_lock_test_and_set (&auth_params->expfile, expfile); - exp_file_deinit (oldfile); - ret = 0; + struct exports_file *expfile = NULL; + struct exports_file *oldfile = NULL; + int ret = -EINVAL; + + /* Validate args */ + GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, auth_params, out); + GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, filename, out); + + /* Parse the exports file and set the auth parameter */ + ret = exp_file_parse(filename, &expfile, auth_params->ms); + if (ret < 0) { + gf_msg(GF_MNT_AUTH, GF_LOG_ERROR, 0, NFS_MSG_LOAD_PARSE_ERROR, + "Failed to load & parse file" + " %s, see logs for more information", + filename); + goto out; + } + + /* Atomically set the file pointer */ + oldfile = __sync_lock_test_and_set(&auth_params->expfile, expfile); + exp_file_deinit(oldfile); + ret = 0; out: - return ret; + return ret; } /** @@ -148,32 +148,33 @@ out: * For external use. */ int -mnt3_auth_set_netgroups_auth (struct mnt3_auth_params *auth_params, - const char *filename) +mnt3_auth_set_netgroups_auth(struct mnt3_auth_params *auth_params, + const char *filename) { - struct netgroups_file *ngfile = NULL; - struct netgroups_file *oldfile = NULL; - int ret = -EINVAL; - - /* Validate args */ - GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, auth_params, out); - GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, filename, out); - - ngfile = ng_file_parse (filename); - if (!ngfile) { - gf_msg (GF_MNT_AUTH, GF_LOG_ERROR, 0, NFS_MSG_LOAD_PARSE_ERROR, - "Failed to load file %s, see logs for more " - "information", filename); - ret = -1; - goto out; - } - - /* Atomically set the file pointer */ - oldfile = __sync_lock_test_and_set (&auth_params->ngfile, ngfile); - ng_file_deinit (oldfile); - ret = 0; + struct netgroups_file *ngfile = NULL; + struct netgroups_file *oldfile = NULL; + int ret = -EINVAL; + + /* Validate args */ + GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, auth_params, out); + GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, filename, out); + + ngfile = ng_file_parse(filename); + if (!ngfile) { + gf_msg(GF_MNT_AUTH, GF_LOG_ERROR, 0, NFS_MSG_LOAD_PARSE_ERROR, + "Failed to load file %s, see logs for more " + "information", + filename); + ret = -1; + goto out; + } + + /* Atomically set the file pointer */ + oldfile = __sync_lock_test_and_set(&auth_params->ngfile, ngfile); + ng_file_deinit(oldfile); + ret = 0; out: - return ret; + return ret; } /* Struct used to pass parameters to @@ -181,8 +182,8 @@ out: * checks if an IP matches a subnet */ struct _mnt3_subnet_match_s { - char *ip; /* IP address to match */ - struct export_item **host; /* Host structure to set */ + char *ip; /* IP address to match */ + struct export_item **host; /* Host structure to set */ }; /** @@ -196,40 +197,40 @@ struct _mnt3_subnet_match_s { * */ static int -_mnt3_auth_subnet_match (dict_t *dict, char *key, data_t *val, void *tmp) +_mnt3_auth_subnet_match(dict_t *dict, char *key, data_t *val, void *tmp) { - struct _mnt3_subnet_match_s *match = NULL; - - match = (struct _mnt3_subnet_match_s *)tmp; + struct _mnt3_subnet_match_s *match = NULL; - if (!match) - return 0; + match = (struct _mnt3_subnet_match_s *)tmp; - if (!match->host) - return 0; - - if (!match->ip) - return 0; + if (!match) + return 0; - /* Already found the host */ - if (*(match->host)) - return 0; + if (!match->host) + return 0; - /* Don't process anything that's not in CIDR */ - if (!strchr (key, '/')) - return 0; + if (!match->ip) + return 0; - /* Strip out leading whitespaces */ - while (*key == ' ') - key++; + /* Already found the host */ + if (*(match->host)) + return 0; - /* If we found that the IP was in the network, set the host - * to point to the value in the dict. - */ - if (gf_is_ip_in_net (key, match->ip)) { - *(match->host) = (struct export_item *)val->data; - } + /* Don't process anything that's not in CIDR */ + if (!strchr(key, '/')) return 0; + + /* Strip out leading whitespaces */ + while (*key == ' ') + key++; + + /* If we found that the IP was in the network, set the host + * to point to the value in the dict. + */ + if (gf_is_ip_in_net(key, match->ip)) { + *(match->host) = (struct export_item *)val->data; + } + return 0; } /** @@ -256,67 +257,69 @@ _mnt3_auth_subnet_match (dict_t *dict, char *key, data_t *val, void *tmp) * Not for external use. */ static struct export_item * -_mnt3_auth_check_host_in_export (const struct exports_file *file, - const char *dir, const char *host, - struct nfs3_fh *fh) +_mnt3_auth_check_host_in_export(const struct exports_file *file, + const char *dir, const char *host, + struct nfs3_fh *fh) { - struct export_dir *expdir = NULL; - struct export_item *host_s = NULL; - struct _mnt3_subnet_match_s snet_match_s = {0, }; - - /* Validate args */ - GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, file, out); - GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, host, out); - - /* If the filehandle is defined, use that to perform authentication. - * All file operations that need authentication must follow this - * code path. - */ - if (fh) { - expdir = exp_file_dir_from_uuid (file, fh->mountid); - if (!expdir) - goto out; - } else { - /* Get the exports directory from the exports file */ - expdir = exp_file_get_dir (file, dir); - if (!expdir) - goto out; - } - - /* Extract the host from the export directory */ - host_s = exp_dir_get_host (expdir, host); - if (!host_s) - goto subnet_match; - else - goto out; - - /* If the host is not found, we need to walk through the hosts - * in the exports directory and see if any of the "hosts" are actually - * networks (e.g. 10.5.153.0/24). If they are we should match the - * incoming network. - */ + struct export_dir *expdir = NULL; + struct export_item *host_s = NULL; + struct _mnt3_subnet_match_s snet_match_s = { + 0, + }; + + /* Validate args */ + GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, file, out); + GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, host, out); + + /* If the filehandle is defined, use that to perform authentication. + * All file operations that need authentication must follow this + * code path. + */ + if (fh) { + expdir = exp_file_dir_from_uuid(file, fh->mountid); + if (!expdir) + goto out; + } else { + /* Get the exports directory from the exports file */ + expdir = exp_file_get_dir(file, dir); + if (!expdir) + goto out; + } + + /* Extract the host from the export directory */ + host_s = exp_dir_get_host(expdir, host); + if (!host_s) + goto subnet_match; + else + goto out; + + /* If the host is not found, we need to walk through the hosts + * in the exports directory and see if any of the "hosts" are actually + * networks (e.g. 10.5.153.0/24). If they are we should match the + * incoming network. + */ subnet_match: - if (!expdir->hosts) - goto out; - snet_match_s.ip = (char *)host; - snet_match_s.host = &host_s; - dict_foreach (expdir->hosts, _mnt3_auth_subnet_match, &snet_match_s); + if (!expdir->hosts) + goto out; + snet_match_s.ip = (char *)host; + snet_match_s.host = &host_s; + dict_foreach(expdir->hosts, _mnt3_auth_subnet_match, &snet_match_s); out: - return host_s; + return host_s; } /* This struct represents all the parameters necessary to search through a * netgroups file to find a host. */ struct ng_auth_search { - const char *search_for; /* strings to search for */ - gf_boolean_t found; /* mark true once found */ - const struct netgroups_file *file; /* netgroups file to search */ - const char *expdir; - struct export_item *expitem; /* pointer to the export */ - const struct exports_file *expfile; - gf_boolean_t _is_host_dict; /* searching a host dict? */ - struct netgroup_entry *found_entry; /* the entry we found! */ + const char *search_for; /* strings to search for */ + gf_boolean_t found; /* mark true once found */ + const struct netgroups_file *file; /* netgroups file to search */ + const char *expdir; + struct export_item *expitem; /* pointer to the export */ + const struct exports_file *expfile; + gf_boolean_t _is_host_dict; /* searching a host dict? */ + struct netgroup_entry *found_entry; /* the entry we found! */ }; /** @@ -332,65 +335,65 @@ struct ng_auth_search { * Not for external use. */ static int -__netgroup_dict_search (dict_t *dict, char *key, data_t *val, void *data) +__netgroup_dict_search(dict_t *dict, char *key, data_t *val, void *data) { - struct ng_auth_search *ngsa = NULL; - struct netgroup_entry *ngentry = NULL; - data_t *hdata = NULL; - - /* 'ngsa' is the search params */ - ngsa = (struct ng_auth_search *)data; - ngentry = (struct netgroup_entry *)val->data; - - if (ngsa->_is_host_dict) { - /* If are on a host dict, we can simply hash the search key - * against the host dict and see if we find anything. - */ - hdata = dict_get (dict, (char *)ngsa->search_for); - if (hdata) { - /* If it was found, log the message, mark the search - * params dict as found and return. - */ - gf_msg_debug (GF_MNT_AUTH, errno, "key %s was hashed " - "and found", key); - ngsa->found = _gf_true; - ngsa->found_entry = (struct netgroup_entry *)hdata->data; - goto out; - } - } + struct ng_auth_search *ngsa = NULL; + struct netgroup_entry *ngentry = NULL; + data_t *hdata = NULL; - /* If the key is what we are searching for, mark the item as - * found and return. - */ - if (strcmp (key, ngsa->search_for) == 0) { - ngsa->found = _gf_true; - ngsa->found_entry = ngentry; - goto out; - } + /* 'ngsa' is the search params */ + ngsa = (struct ng_auth_search *)data; + ngentry = (struct netgroup_entry *)val->data; - /* If we have a netgroup hosts dict, then search the dict using this - * same function. + if (ngsa->_is_host_dict) { + /* If are on a host dict, we can simply hash the search key + * against the host dict and see if we find anything. */ - if (ngentry->netgroup_hosts) { - ngsa->_is_host_dict = _gf_true; - dict_foreach (ngentry->netgroup_hosts, __netgroup_dict_search, - ngsa); - } - - /* If that search was successful, just return */ - if (ngsa->found) - goto out; - - /* If we have a netgroup dict, then search the dict using this same - * function. - */ - if (ngentry->netgroup_ngs) { - ngsa->_is_host_dict = _gf_false; - dict_foreach (ngentry->netgroup_ngs, __netgroup_dict_search, - ngsa); + hdata = dict_get(dict, (char *)ngsa->search_for); + if (hdata) { + /* If it was found, log the message, mark the search + * params dict as found and return. + */ + gf_msg_debug(GF_MNT_AUTH, errno, + "key %s was hashed " + "and found", + key); + ngsa->found = _gf_true; + ngsa->found_entry = (struct netgroup_entry *)hdata->data; + goto out; } + } + + /* If the key is what we are searching for, mark the item as + * found and return. + */ + if (strcmp(key, ngsa->search_for) == 0) { + ngsa->found = _gf_true; + ngsa->found_entry = ngentry; + goto out; + } + + /* If we have a netgroup hosts dict, then search the dict using this + * same function. + */ + if (ngentry->netgroup_hosts) { + ngsa->_is_host_dict = _gf_true; + dict_foreach(ngentry->netgroup_hosts, __netgroup_dict_search, ngsa); + } + + /* If that search was successful, just return */ + if (ngsa->found) + goto out; + + /* If we have a netgroup dict, then search the dict using this same + * function. + */ + if (ngentry->netgroup_ngs) { + ngsa->_is_host_dict = _gf_false; + dict_foreach(ngentry->netgroup_ngs, __netgroup_dict_search, ngsa); + } out: - return 0; + return 0; } /** @@ -416,54 +419,51 @@ out: * Not for external use. */ static int -__export_dir_lookup_netgroup (dict_t *dict, char *key, data_t *val, - void *data) +__export_dir_lookup_netgroup(dict_t *dict, char *key, data_t *val, void *data) { - struct ng_auth_search *ngsa = NULL; /* Search params */ - struct netgroups_file *nfile = NULL; /* Netgroups file to search */ - struct netgroup_entry *ngentry = NULL; /* Entry in the netgroups file */ - struct export_dir *tmpdir = NULL; - - ngsa = (struct ng_auth_search *)data; - nfile = (struct netgroups_file *)ngsa->file; - - GF_ASSERT ((*key == '@')); - - /* We use ++key here because keys start with '@' for ngs */ - ngentry = ng_file_get_netgroup (nfile, (key + 1)); - if (!ngentry) { - gf_msg_debug (GF_MNT_AUTH, 0, "%s not found in %s", - key, nfile->filename); - goto out; - } - - tmpdir = exp_file_get_dir (ngsa->expfile, ngsa->expdir); - if (!tmpdir) - goto out; - - ngsa->expitem = exp_dir_get_netgroup (tmpdir, key); - if (!ngsa->expitem) - goto out; - - /* Run through the host dict */ - if (ngentry->netgroup_hosts) { - ngsa->_is_host_dict = _gf_true; - dict_foreach (ngentry->netgroup_hosts, __netgroup_dict_search, - ngsa); - } - - /* If the above search was successful, just return */ - if (ngsa->found) - goto out; - - /* Run through the netgroups dict */ - if (ngentry->netgroup_ngs) { - ngsa->_is_host_dict = _gf_false; - dict_foreach (ngentry->netgroup_ngs, __netgroup_dict_search, - ngsa); - } + struct ng_auth_search *ngsa = NULL; /* Search params */ + struct netgroups_file *nfile = NULL; /* Netgroups file to search */ + struct netgroup_entry *ngentry = NULL; /* Entry in the netgroups file */ + struct export_dir *tmpdir = NULL; + + ngsa = (struct ng_auth_search *)data; + nfile = (struct netgroups_file *)ngsa->file; + + GF_ASSERT((*key == '@')); + + /* We use ++key here because keys start with '@' for ngs */ + ngentry = ng_file_get_netgroup(nfile, (key + 1)); + if (!ngentry) { + gf_msg_debug(GF_MNT_AUTH, 0, "%s not found in %s", key, + nfile->filename); + goto out; + } + + tmpdir = exp_file_get_dir(ngsa->expfile, ngsa->expdir); + if (!tmpdir) + goto out; + + ngsa->expitem = exp_dir_get_netgroup(tmpdir, key); + if (!ngsa->expitem) + goto out; + + /* Run through the host dict */ + if (ngentry->netgroup_hosts) { + ngsa->_is_host_dict = _gf_true; + dict_foreach(ngentry->netgroup_hosts, __netgroup_dict_search, ngsa); + } + + /* If the above search was successful, just return */ + if (ngsa->found) + goto out; + + /* Run through the netgroups dict */ + if (ngentry->netgroup_ngs) { + ngsa->_is_host_dict = _gf_false; + dict_foreach(ngentry->netgroup_ngs, __netgroup_dict_search, ngsa); + } out: - return 0; + return 0; } /** @@ -476,25 +476,26 @@ out: * @nfile : The netgroups file to set * */ -void _mnt3_auth_setup_search_params (struct ng_auth_search *params, - const char *host, const char *dir, - const struct netgroups_file *nfile, - const struct exports_file *expfile) +void +_mnt3_auth_setup_search_params(struct ng_auth_search *params, const char *host, + const char *dir, + const struct netgroups_file *nfile, + const struct exports_file *expfile) { - GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, params, out); - GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, host, out); - GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, nfile, out); - - params->search_for = host; - params->found = _gf_false; - params->file = nfile; - params->_is_host_dict = _gf_false; - params->found_entry = NULL; - params->expitem = NULL; - params->expfile = expfile; - params->expdir = dir; + GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, params, out); + GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, host, out); + GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, nfile, out); + + params->search_for = host; + params->found = _gf_false; + params->file = nfile; + params->_is_host_dict = _gf_false; + params->found_entry = NULL; + params->expitem = NULL; + params->expfile = expfile; + params->expdir = dir; out: - return; + return; } /** @@ -521,43 +522,44 @@ out: * Not for external use. */ static struct netgroup_entry * -_mnt3_auth_check_host_in_netgroup (const struct mnt3_auth_params *auth_params, - struct nfs3_fh *fh, const char *host, - const char *dir, struct export_item **item) +_mnt3_auth_check_host_in_netgroup(const struct mnt3_auth_params *auth_params, + struct nfs3_fh *fh, const char *host, + const char *dir, struct export_item **item) { - struct export_dir *expdir = NULL; - struct ng_auth_search ngsa = {0, }; - struct netgroup_entry *found_entry = NULL; - struct exports_file *efile = auth_params->expfile; - struct netgroups_file *nfile = auth_params->ngfile; - - /* Validate args */ - GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, nfile, out); - GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, efile, out); - GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, host, out); - GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, item, out); - - if (fh) { - expdir = exp_file_dir_from_uuid (efile, fh->mountid); - if (!expdir) - goto out; - } else { - /* Get the exports directory */ - expdir = exp_file_get_dir (efile, dir); - if (!expdir) - goto out; - } - - /* Setup search struct */ - _mnt3_auth_setup_search_params (&ngsa, host, expdir->dir_name, nfile, - efile); - - /* Do the search */ - dict_foreach (expdir->netgroups, __export_dir_lookup_netgroup, &ngsa); - found_entry = ngsa.found_entry; - *item = ngsa.expitem; + struct export_dir *expdir = NULL; + struct ng_auth_search ngsa = { + 0, + }; + struct netgroup_entry *found_entry = NULL; + struct exports_file *efile = auth_params->expfile; + struct netgroups_file *nfile = auth_params->ngfile; + + /* Validate args */ + GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, nfile, out); + GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, efile, out); + GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, host, out); + GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, item, out); + + if (fh) { + expdir = exp_file_dir_from_uuid(efile, fh->mountid); + if (!expdir) + goto out; + } else { + /* Get the exports directory */ + expdir = exp_file_get_dir(efile, dir); + if (!expdir) + goto out; + } + + /* Setup search struct */ + _mnt3_auth_setup_search_params(&ngsa, host, expdir->dir_name, nfile, efile); + + /* Do the search */ + dict_foreach(expdir->netgroups, __export_dir_lookup_netgroup, &ngsa); + found_entry = ngsa.found_entry; + *item = ngsa.expitem; out: - return found_entry; + return found_entry; } /** @@ -570,22 +572,22 @@ out: * */ int -check_rw_access (struct export_item *item) +check_rw_access(struct export_item *item) { - struct export_options *opts = NULL; - int ret = -EROFS; + struct export_options *opts = NULL; + int ret = -EROFS; - if (!item) - goto out; + if (!item) + goto out; - opts = item->opts; - if (!opts) - goto out; + opts = item->opts; + if (!opts) + goto out; - if (opts->rw) - ret = 0; + if (opts->rw) + ret = 0; out: - return ret; + return ret; } /** @@ -609,36 +611,32 @@ out: * -EROFS for unauthorized write operations (rm, mkdir, write) * */ int -mnt3_auth_host (const struct mnt3_auth_params *auth_params, const char *host, - struct nfs3_fh *fh, const char *dir, gf_boolean_t is_write_op, - struct export_item **save_item) +mnt3_auth_host(const struct mnt3_auth_params *auth_params, const char *host, + struct nfs3_fh *fh, const char *dir, gf_boolean_t is_write_op, + struct export_item **save_item) { - int auth_status_code = -EACCES; - struct export_item *item = NULL; - - GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, auth_params, out); - GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, host, out); - - /* Find the host in the exports file */ - item = _mnt3_auth_check_host_in_export (auth_params->expfile, dir, - host, fh); - if (item) { - auth_status_code = (is_write_op) ? - check_rw_access (item) : 0; - goto out; - } + int auth_status_code = -EACCES; + struct export_item *item = NULL; - /* Find the host in the netgroups file for the exports directory */ - if (_mnt3_auth_check_host_in_netgroup (auth_params, fh, host, dir, - &item)) { - auth_status_code = (is_write_op) ? - check_rw_access (item) : 0; - goto out; - } + GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, auth_params, out); + GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, host, out); + + /* Find the host in the exports file */ + item = _mnt3_auth_check_host_in_export(auth_params->expfile, dir, host, fh); + if (item) { + auth_status_code = (is_write_op) ? check_rw_access(item) : 0; + goto out; + } + + /* Find the host in the netgroups file for the exports directory */ + if (_mnt3_auth_check_host_in_netgroup(auth_params, fh, host, dir, &item)) { + auth_status_code = (is_write_op) ? check_rw_access(item) : 0; + goto out; + } out: - if (save_item) - *save_item = item; + if (save_item) + *save_item = item; - return auth_status_code; + return auth_status_code; } diff --git a/xlators/nfs/server/src/mount3.c b/xlators/nfs/server/src/mount3.c index f3d7def64d..f0d8aff999 100644 --- a/xlators/nfs/server/src/mount3.c +++ b/xlators/nfs/server/src/mount3.c @@ -36,119 +36,121 @@ #include <sys/socket.h> #include <sys/uio.h> - /* This macro will assist in freeing up entire link list * of host_auth_spec structure. */ -#define FREE_HOSTSPEC(exp) do { \ - struct host_auth_spec *host= exp->hostspec; \ - while (NULL != host){ \ - struct host_auth_spec* temp = host; \ - host = host->next; \ - if (NULL != temp->host_addr) { \ - GF_FREE (temp->host_addr); \ - } \ - GF_FREE (temp); \ - } \ - exp->hostspec = NULL; \ - } while (0) +#define FREE_HOSTSPEC(exp) \ + do { \ + struct host_auth_spec *host = exp->hostspec; \ + while (NULL != host) { \ + struct host_auth_spec *temp = host; \ + host = host->next; \ + if (NULL != temp->host_addr) { \ + GF_FREE(temp->host_addr); \ + } \ + GF_FREE(temp); \ + } \ + exp->hostspec = NULL; \ + } while (0) /* Paths for export and netgroup files */ -const char *exports_file_path = GLUSTERD_DEFAULT_WORKDIR "/nfs/exports"; +const char *exports_file_path = GLUSTERD_DEFAULT_WORKDIR "/nfs/exports"; const char *netgroups_file_path = GLUSTERD_DEFAULT_WORKDIR "/nfs/netgroups"; -typedef ssize_t (*mnt3_serializer) (struct iovec outmsg, void *args); +typedef ssize_t (*mnt3_serializer)(struct iovec outmsg, void *args); extern void * -mount3udp_thread (void *argv); +mount3udp_thread(void *argv); static void -mnt3_export_free (struct mnt3_export *exp) +mnt3_export_free(struct mnt3_export *exp) { - if (!exp) - return; - - if (exp->exptype == MNT3_EXPTYPE_DIR) - FREE_HOSTSPEC (exp); - GF_FREE (exp->expname); - GF_FREE (exp->fullpath); - GF_FREE (exp); + if (!exp) + return; + + if (exp->exptype == MNT3_EXPTYPE_DIR) + FREE_HOSTSPEC(exp); + GF_FREE(exp->expname); + GF_FREE(exp->fullpath); + GF_FREE(exp); } /* Generic reply function for MOUNTv3 specific replies. */ int -mnt3svc_submit_reply (rpcsvc_request_t *req, void *arg, mnt3_serializer sfunc) +mnt3svc_submit_reply(rpcsvc_request_t *req, void *arg, mnt3_serializer sfunc) { - struct iovec outmsg = {0, }; - struct iobuf *iob = NULL; - struct mount3_state *ms = NULL; - int ret = -1; - ssize_t msglen = 0; - struct iobref *iobref = NULL; - - if (!req) - return -1; - - ms = (struct mount3_state *)rpcsvc_request_program_private (req); - if (!ms) { - gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, - NFS_MSG_MNT_STATE_NOT_FOUND, "mount state not found"); - goto ret; - } - - /* First, get the io buffer into which the reply in arg will - * be serialized. - */ - /* TODO: use 'xdrproc_t' instead of 'sfunc' to get the xdr-size */ - iob = iobuf_get (ms->iobpool); - if (!iob) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to get iobuf"); - goto ret; - } - - iobuf_to_iovec (iob, &outmsg); - /* Use the given serializer to translate the give C structure in arg - * to XDR format which will be written into the buffer in outmsg. - */ - msglen = sfunc (outmsg, arg); - if (msglen < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_ENCODE_MSG_FAIL, - "Failed to encode message"); - goto ret; - } - outmsg.iov_len = msglen; - - iobref = iobref_new (); - if (iobref == NULL) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to get iobref"); - goto ret; - } - - ret = iobref_add (iobref, iob); - if (ret) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to add iob to iobref"); - goto ret; - } - - /* Then, submit the message for transmission. */ - ret = rpcsvc_submit_message (req, &outmsg, 1, NULL, 0, iobref); - if (ret == -1) { - gf_msg (GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_REP_SUBMIT_FAIL, - "Reply submission failed"); - goto ret; - } + struct iovec outmsg = { + 0, + }; + struct iobuf *iob = NULL; + struct mount3_state *ms = NULL; + int ret = -1; + ssize_t msglen = 0; + struct iobref *iobref = NULL; + + if (!req) + return -1; - ret = 0; + ms = (struct mount3_state *)rpcsvc_request_program_private(req); + if (!ms) { + gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_MNT_STATE_NOT_FOUND, + "mount state not found"); + goto ret; + } + + /* First, get the io buffer into which the reply in arg will + * be serialized. + */ + /* TODO: use 'xdrproc_t' instead of 'sfunc' to get the xdr-size */ + iob = iobuf_get(ms->iobpool); + if (!iob) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to get iobuf"); + goto ret; + } + + iobuf_to_iovec(iob, &outmsg); + /* Use the given serializer to translate the give C structure in arg + * to XDR format which will be written into the buffer in outmsg. + */ + msglen = sfunc(outmsg, arg); + if (msglen < 0) { + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_ENCODE_MSG_FAIL, + "Failed to encode message"); + goto ret; + } + outmsg.iov_len = msglen; + + iobref = iobref_new(); + if (iobref == NULL) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to get iobref"); + goto ret; + } + + ret = iobref_add(iobref, iob); + if (ret) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to add iob to iobref"); + goto ret; + } + + /* Then, submit the message for transmission. */ + ret = rpcsvc_submit_message(req, &outmsg, 1, NULL, 0, iobref); + if (ret == -1) { + gf_msg(GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_REP_SUBMIT_FAIL, + "Reply submission failed"); + goto ret; + } + + ret = 0; ret: - if (NULL != iob) - iobuf_unref (iob); - if (NULL != iobref) - iobref_unref (iobref); + if (NULL != iob) + iobuf_unref(iob); + if (NULL != iobref) + iobref_unref(iobref); - return ret; + return ret; } /** * __mountdict_insert -- Insert a mount entry into the mount state @@ -159,39 +161,38 @@ ret: * Not for external use. */ void -__mountdict_insert (struct mount3_state *ms, struct mountentry *me) +__mountdict_insert(struct mount3_state *ms, struct mountentry *me) { - char *exname = NULL; - char *fpath = NULL; - data_t *medata = NULL; - - GF_VALIDATE_OR_GOTO (GF_MNT, ms, out); - GF_VALIDATE_OR_GOTO (GF_MNT, me, out); - - /* We don't want export names with leading slashes */ - exname = me->exname; - while (exname[0] == '/') - exname++; - - /* Get the fullpath for the export */ - fpath = me->fullpath; - if (me->has_full_path) { - while (fpath[0] == '/') - fpath++; - - /* Export names can either be just volumes or paths inside that - * volume. */ - exname = fpath; - } - - snprintf (me->hashkey, sizeof (me->hashkey), "%s:%s", exname, - me->hostname); - - medata = bin_to_data (me, sizeof (*me)); - dict_set (ms->mountdict, me->hashkey, medata); - gf_msg_trace (GF_MNT, 0, "Inserted into mountdict: %s", me->hashkey); + char *exname = NULL; + char *fpath = NULL; + data_t *medata = NULL; + + GF_VALIDATE_OR_GOTO(GF_MNT, ms, out); + GF_VALIDATE_OR_GOTO(GF_MNT, me, out); + + /* We don't want export names with leading slashes */ + exname = me->exname; + while (exname[0] == '/') + exname++; + + /* Get the fullpath for the export */ + fpath = me->fullpath; + if (me->has_full_path) { + while (fpath[0] == '/') + fpath++; + + /* Export names can either be just volumes or paths inside that + * volume. */ + exname = fpath; + } + + snprintf(me->hashkey, sizeof(me->hashkey), "%s:%s", exname, me->hostname); + + medata = bin_to_data(me, sizeof(*me)); + dict_set(ms->mountdict, me->hashkey, medata); + gf_msg_trace(GF_MNT, 0, "Inserted into mountdict: %s", me->hashkey); out: - return; + return; } /** @@ -203,91 +204,90 @@ out: * Not for external use. */ void -__mountdict_remove (struct mount3_state *ms, struct mountentry *me) +__mountdict_remove(struct mount3_state *ms, struct mountentry *me) { - dict_del (ms->mountdict, me->hashkey); + dict_del(ms->mountdict, me->hashkey); } /* Generic error reply function, just pass the err status * and it will do the rest, including transmission. */ int -mnt3svc_mnt_error_reply (rpcsvc_request_t *req, int mntstat) +mnt3svc_mnt_error_reply(rpcsvc_request_t *req, int mntstat) { - mountres3 res; + mountres3 res; - if (!req) - return -1; + if (!req) + return -1; - res.fhs_status = mntstat; - mnt3svc_submit_reply (req, (void *)&res, - (mnt3_serializer)xdr_serialize_mountres3); + res.fhs_status = mntstat; + mnt3svc_submit_reply(req, (void *)&res, + (mnt3_serializer)xdr_serialize_mountres3); - return 0; + return 0; } - mountstat3 -mnt3svc_errno_to_mnterr (int32_t errnum) +mnt3svc_errno_to_mnterr(int32_t errnum) { - mountstat3 stat; - - switch (errnum) { - - case 0: - stat = MNT3_OK; - break; - case ENOENT: - stat = MNT3ERR_NOENT; - break; - case EPERM: - stat = MNT3ERR_PERM; - break; - case EIO: - stat = MNT3ERR_IO; - break; - case EACCES: - stat = MNT3ERR_ACCES; - break; - case ENOTDIR: - stat = MNT3ERR_NOTDIR; - break; - case EINVAL: - stat = MNT3ERR_INVAL; - break; - case ENOSYS: - stat = MNT3ERR_NOTSUPP; - break; - case ENOMEM: - stat = MNT3ERR_SERVERFAULT; - break; - default: - stat = MNT3ERR_SERVERFAULT; - break; - } + mountstat3 stat; + + switch (errnum) { + case 0: + stat = MNT3_OK; + break; + case ENOENT: + stat = MNT3ERR_NOENT; + break; + case EPERM: + stat = MNT3ERR_PERM; + break; + case EIO: + stat = MNT3ERR_IO; + break; + case EACCES: + stat = MNT3ERR_ACCES; + break; + case ENOTDIR: + stat = MNT3ERR_NOTDIR; + break; + case EINVAL: + stat = MNT3ERR_INVAL; + break; + case ENOSYS: + stat = MNT3ERR_NOTSUPP; + break; + case ENOMEM: + stat = MNT3ERR_SERVERFAULT; + break; + default: + stat = MNT3ERR_SERVERFAULT; + break; + } - return stat; + return stat; } - mountres3 -mnt3svc_set_mountres3 (mountstat3 stat, struct nfs3_fh *fh, int *authflavor, - u_int aflen) +mnt3svc_set_mountres3(mountstat3 stat, struct nfs3_fh *fh, int *authflavor, + u_int aflen) { - mountres3 res = {0, }; - uint32_t fhlen = 0; + mountres3 res = { + 0, + }; + uint32_t fhlen = 0; - res.fhs_status = stat; + res.fhs_status = stat; - if (fh) - fhlen = nfs3_fh_compute_size (); + if (fh) + fhlen = nfs3_fh_compute_size(); - res.mountres3_u.mountinfo.fhandle.fhandle3_len = fhlen; - res.mountres3_u.mountinfo.fhandle.fhandle3_val = (char *)fh; - res.mountres3_u.mountinfo.auth_flavors.auth_flavors_val = authflavor; - res.mountres3_u.mountinfo.auth_flavors.auth_flavors_len = aflen; + res.mountres3_u.mountinfo.fhandle.fhandle3_len = fhlen; + res.mountres3_u.mountinfo.fhandle.fhandle3_val = (char *)fh; + res.mountres3_u.mountinfo.auth_flavors.auth_flavors_val = authflavor; + res.mountres3_u.mountinfo.auth_flavors.auth_flavors_len = aflen; - return res; + return res; } /* Read the rmtab from the store_handle and append (or not) the entries to the @@ -296,81 +296,82 @@ mnt3svc_set_mountres3 (mountstat3 stat, struct nfs3_fh *fh, int *authflavor, * Requires the store_handle to be locked. */ static int -__mount_read_rmtab (gf_store_handle_t *sh, struct list_head *mountlist, - gf_boolean_t append) +__mount_read_rmtab(gf_store_handle_t *sh, struct list_head *mountlist, + gf_boolean_t append) { - int ret = 0; - unsigned int idx = 0; - struct mountentry *me = NULL, *tmp = NULL; - /* me->hostname is a char[MNTPATHLEN] */ - char key[MNTPATHLEN + 11]; - - GF_ASSERT (sh && mountlist); - - if (!gf_store_locked_local (sh)) { - gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_READ_LOCKED, - "Not reading unlocked %s", sh->path); - return -1; - } + int ret = 0; + unsigned int idx = 0; + struct mountentry *me = NULL, *tmp = NULL; + /* me->hostname is a char[MNTPATHLEN] */ + char key[MNTPATHLEN + 11]; - if (!append) { - list_for_each_entry_safe (me, tmp, mountlist, mlist) { - list_del (&me->mlist); - GF_FREE (me); - } - me = NULL; - } + GF_ASSERT(sh && mountlist); - for (;;) { - char *value = NULL; - - if (me && append) { - /* do not add duplicates */ - list_for_each_entry (tmp, mountlist, mlist) { - if (!strcmp(tmp->hostname, me->hostname) && - !strcmp(tmp->exname, me->exname)) { - GF_FREE (me); - goto dont_add; - } - } - list_add_tail (&me->mlist, mountlist); - } else if (me) { - list_add_tail (&me->mlist, mountlist); - } + if (!gf_store_locked_local(sh)) { + gf_msg(GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_READ_LOCKED, + "Not reading unlocked %s", sh->path); + return -1; + } -dont_add: - me = GF_CALLOC (1, sizeof (*me), gf_nfs_mt_mountentry); - if (!me) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, - NFS_MSG_NO_MEMORY, "Out of memory"); - ret = -1; - goto out; + if (!append) { + list_for_each_entry_safe(me, tmp, mountlist, mlist) + { + list_del(&me->mlist); + GF_FREE(me); + } + me = NULL; + } + + for (;;) { + char *value = NULL; + + if (me && append) { + /* do not add duplicates */ + list_for_each_entry(tmp, mountlist, mlist) + { + if (!strcmp(tmp->hostname, me->hostname) && + !strcmp(tmp->exname, me->exname)) { + GF_FREE(me); + goto dont_add; } - - INIT_LIST_HEAD (&me->mlist); - - snprintf (key, 9 + MNTPATHLEN, "hostname-%d", idx); - ret = gf_store_retrieve_value (sh, key, &value); - if (ret) - break; - snprintf (me->hostname, MNTPATHLEN, "%s", value); - GF_FREE (value); - - snprintf (key, 11 + MNTPATHLEN, "mountpoint-%d", idx); - ret = gf_store_retrieve_value (sh, key, &value); - if (ret) - break; - snprintf (me->exname, MNTPATHLEN, "%s", value); - GF_FREE (value); - - idx++; - gf_msg_trace (GF_MNT, 0, "Read entries %s:%s", - me->hostname, me->exname); - } - gf_msg_debug (GF_MNT, 0, "Read %d entries from '%s'", idx, sh->path); - GF_FREE (me); + } + list_add_tail(&me->mlist, mountlist); + } else if (me) { + list_add_tail(&me->mlist, mountlist); + } + + dont_add: + me = GF_CALLOC(1, sizeof(*me), gf_nfs_mt_mountentry); + if (!me) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Out of memory"); + ret = -1; + goto out; + } + + INIT_LIST_HEAD(&me->mlist); + + snprintf(key, 9 + MNTPATHLEN, "hostname-%d", idx); + ret = gf_store_retrieve_value(sh, key, &value); + if (ret) + break; + snprintf(me->hostname, MNTPATHLEN, "%s", value); + GF_FREE(value); + + snprintf(key, 11 + MNTPATHLEN, "mountpoint-%d", idx); + ret = gf_store_retrieve_value(sh, key, &value); + if (ret) + break; + snprintf(me->exname, MNTPATHLEN, "%s", value); + GF_FREE(value); + + idx++; + gf_msg_trace(GF_MNT, 0, "Read entries %s:%s", me->hostname, me->exname); + } + gf_msg_debug(GF_MNT, 0, "Read %d entries from '%s'", idx, sh->path); + GF_FREE(me); out: - return ret; + return ret; } /* Overwrite the contents of the rwtab with the in-memory client list. @@ -379,98 +380,97 @@ out: static void __mount_rewrite_rmtab(struct mount3_state *ms, gf_store_handle_t *sh) { - struct mountentry *me = NULL; - char key[16]; - int fd, ret; - unsigned int idx = 0; - - if (!gf_store_locked_local (sh)) { - gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_MODIFY_LOCKED, - "Not modifying unlocked %s", sh->path); - return; - } + struct mountentry *me = NULL; + char key[16]; + int fd, ret; + unsigned int idx = 0; + + if (!gf_store_locked_local(sh)) { + gf_msg(GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_MODIFY_LOCKED, + "Not modifying unlocked %s", sh->path); + return; + } - fd = gf_store_mkstemp (sh); - if (fd == -1) { - gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Failed to open %s", sh->path); - return; - } + fd = gf_store_mkstemp(sh); + if (fd == -1) { + gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Failed to open %s", sh->path); + return; + } - list_for_each_entry (me, &ms->mountlist, mlist) { - snprintf (key, 16, "hostname-%d", idx); - ret = gf_store_save_value (fd, key, me->hostname); - if (ret) - goto fail; + list_for_each_entry(me, &ms->mountlist, mlist) + { + snprintf(key, 16, "hostname-%d", idx); + ret = gf_store_save_value(fd, key, me->hostname); + if (ret) + goto fail; - snprintf (key, 16, "mountpoint-%d", idx); - ret = gf_store_save_value (fd, key, me->exname); - if (ret) - goto fail; + snprintf(key, 16, "mountpoint-%d", idx); + ret = gf_store_save_value(fd, key, me->exname); + if (ret) + goto fail; - idx++; - } + idx++; + } - gf_msg_debug (GF_MNT, 0, "Updated rmtab with %d entries", idx); + gf_msg_debug(GF_MNT, 0, "Updated rmtab with %d entries", idx); - if (gf_store_rename_tmppath (sh)) - gf_msg (GF_MNT, GF_LOG_ERROR, errno, - NFS_MSG_RWTAB_OVERWRITE_FAIL, - "Failed to overwrite rwtab %s", sh->path); + if (gf_store_rename_tmppath(sh)) + gf_msg(GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_RWTAB_OVERWRITE_FAIL, + "Failed to overwrite rwtab %s", sh->path); - return; + return; fail: - gf_msg (GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_UPDATE_FAIL, - "Failed to update %s", sh->path); - gf_store_unlink_tmppath (sh); + gf_msg(GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_UPDATE_FAIL, + "Failed to update %s", sh->path); + gf_store_unlink_tmppath(sh); } static gf_boolean_t -mount_open_rmtab (const char *rmtab, gf_store_handle_t **sh) +mount_open_rmtab(const char *rmtab, gf_store_handle_t **sh) { - int ret = -1; + int ret = -1; - /* updating the rmtab is disabled, use in-memory only */ - if (!rmtab || rmtab[0] == '\0') - return _gf_false; + /* updating the rmtab is disabled, use in-memory only */ + if (!rmtab || rmtab[0] == '\0') + return _gf_false; - ret = gf_store_handle_new (rmtab, sh); - if (ret) { - gf_log (GF_MNT, GF_LOG_WARNING, "Failed to open '%s'", rmtab); - return _gf_false; - } + ret = gf_store_handle_new(rmtab, sh); + if (ret) { + gf_log(GF_MNT, GF_LOG_WARNING, "Failed to open '%s'", rmtab); + return _gf_false; + } - return _gf_true; + return _gf_true; } - /* Read the rmtab into a clean ms->mountlist. */ static void -mount_read_rmtab (struct mount3_state *ms) +mount_read_rmtab(struct mount3_state *ms) { - gf_store_handle_t *sh = NULL; - struct nfs_state *nfs = NULL; - gf_boolean_t read_rmtab = _gf_false; + gf_store_handle_t *sh = NULL; + struct nfs_state *nfs = NULL; + gf_boolean_t read_rmtab = _gf_false; - nfs = (struct nfs_state *)ms->nfsx->private; + nfs = (struct nfs_state *)ms->nfsx->private; - read_rmtab = mount_open_rmtab (nfs->rmtab, &sh); - if (!read_rmtab) - return; + read_rmtab = mount_open_rmtab(nfs->rmtab, &sh); + if (!read_rmtab) + return; - if (gf_store_lock (sh)) { - gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_LOCK_FAIL, - "Failed to lock '%s'", nfs->rmtab); - goto out; - } + if (gf_store_lock(sh)) { + gf_msg(GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_LOCK_FAIL, + "Failed to lock '%s'", nfs->rmtab); + goto out; + } - __mount_read_rmtab (sh, &ms->mountlist, _gf_false); - gf_store_unlock (sh); + __mount_read_rmtab(sh, &ms->mountlist, _gf_false); + gf_store_unlock(sh); out: - gf_store_handle_destroy (sh); + gf_store_handle_destroy(sh); } /* Write the ms->mountlist to the rmtab. @@ -491,77 +491,75 @@ out: * 9. releases the store_handle lock of the old rmtab */ void -mount_rewrite_rmtab (struct mount3_state *ms, char *new_rmtab) +mount_rewrite_rmtab(struct mount3_state *ms, char *new_rmtab) { - gf_store_handle_t *sh = NULL, *nsh = NULL; - struct nfs_state *nfs = NULL; - int ret; - char *rmtab = NULL; - gf_boolean_t got_old_rmtab = _gf_false; - - nfs = (struct nfs_state *)ms->nfsx->private; - - got_old_rmtab = mount_open_rmtab (nfs->rmtab, &sh); - if (!got_old_rmtab && !new_rmtab) - return; - - if (got_old_rmtab && gf_store_lock (sh)) { - gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_REWRITE_ERROR, - "Not rewriting '%s'", nfs->rmtab); - goto free_sh; - } + gf_store_handle_t *sh = NULL, *nsh = NULL; + struct nfs_state *nfs = NULL; + int ret; + char *rmtab = NULL; + gf_boolean_t got_old_rmtab = _gf_false; - if (new_rmtab) { - ret = gf_store_handle_new (new_rmtab, &nsh); - if (ret) { - gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_OPEN_FAIL, - "Failed to open '%s'", new_rmtab); - goto unlock_sh; - } + nfs = (struct nfs_state *)ms->nfsx->private; - if (gf_store_lock (nsh)) { - gf_msg (GF_MNT, GF_LOG_WARNING, 0, - NFS_MSG_REWRITE_ERROR, - "Not rewriting '%s'", new_rmtab); - goto free_nsh; - } + got_old_rmtab = mount_open_rmtab(nfs->rmtab, &sh); + if (!got_old_rmtab && !new_rmtab) + return; + + if (got_old_rmtab && gf_store_lock(sh)) { + gf_msg(GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_REWRITE_ERROR, + "Not rewriting '%s'", nfs->rmtab); + goto free_sh; + } + + if (new_rmtab) { + ret = gf_store_handle_new(new_rmtab, &nsh); + if (ret) { + gf_msg(GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_OPEN_FAIL, + "Failed to open '%s'", new_rmtab); + goto unlock_sh; } - /* always read the currently used rmtab */ - if (got_old_rmtab) - __mount_read_rmtab (sh, &ms->mountlist, _gf_true); - - if (new_rmtab) { - /* read the new rmtab and write changes to the new location */ - __mount_read_rmtab (nsh, &ms->mountlist, _gf_true); - __mount_rewrite_rmtab (ms, nsh); - - /* replace the nfs->rmtab reference to the new rmtab */ - rmtab = gf_strdup(new_rmtab); - if (rmtab == NULL) { - gf_msg (GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_NO_MEMORY, - "Out of memory, keeping %s as rmtab", - nfs->rmtab); - } else { - GF_FREE (nfs->rmtab); - nfs->rmtab = rmtab; - } + if (gf_store_lock(nsh)) { + gf_msg(GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_REWRITE_ERROR, + "Not rewriting '%s'", new_rmtab); + goto free_nsh; + } + } + + /* always read the currently used rmtab */ + if (got_old_rmtab) + __mount_read_rmtab(sh, &ms->mountlist, _gf_true); + + if (new_rmtab) { + /* read the new rmtab and write changes to the new location */ + __mount_read_rmtab(nsh, &ms->mountlist, _gf_true); + __mount_rewrite_rmtab(ms, nsh); - gf_store_unlock (nsh); + /* replace the nfs->rmtab reference to the new rmtab */ + rmtab = gf_strdup(new_rmtab); + if (rmtab == NULL) { + gf_msg(GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_NO_MEMORY, + "Out of memory, keeping %s as rmtab", nfs->rmtab); } else { - /* rewrite the current (unchanged location) rmtab */ - __mount_rewrite_rmtab (ms, sh); + GF_FREE(nfs->rmtab); + nfs->rmtab = rmtab; } + gf_store_unlock(nsh); + } else { + /* rewrite the current (unchanged location) rmtab */ + __mount_rewrite_rmtab(ms, sh); + } + free_nsh: - if (new_rmtab) - gf_store_handle_destroy (nsh); + if (new_rmtab) + gf_store_handle_destroy(nsh); unlock_sh: - if (got_old_rmtab) - gf_store_unlock (sh); + if (got_old_rmtab) + gf_store_unlock(sh); free_sh: - if (got_old_rmtab) - gf_store_handle_destroy (sh); + if (got_old_rmtab) + gf_store_handle_destroy(sh); } /* Add a new NFS-client to the ms->mountlist and update the rmtab if we can. @@ -576,374 +574,375 @@ free_sh: * common issue for all(?) NFS-servers. */ int -mnt3svc_update_mountlist (struct mount3_state *ms, rpcsvc_request_t *req, - const char *expname, const char *fullpath) +mnt3svc_update_mountlist(struct mount3_state *ms, rpcsvc_request_t *req, + const char *expname, const char *fullpath) { - struct mountentry *me = NULL; - struct mountentry *cur = NULL; - int ret = -1; - char *colon = NULL; - struct nfs_state *nfs = NULL; - gf_store_handle_t *sh = NULL; - gf_boolean_t update_rmtab = _gf_false; - - if ((!ms) || (!req) || (!expname)) - return -1; - - me = (struct mountentry *)GF_CALLOC (1, sizeof (*me), - gf_nfs_mt_mountentry); - if (!me) - return -1; - - nfs = (struct nfs_state *)ms->nfsx->private; - - update_rmtab = mount_open_rmtab (nfs->rmtab, &sh); + struct mountentry *me = NULL; + struct mountentry *cur = NULL; + int ret = -1; + char *colon = NULL; + struct nfs_state *nfs = NULL; + gf_store_handle_t *sh = NULL; + gf_boolean_t update_rmtab = _gf_false; + + if ((!ms) || (!req) || (!expname)) + return -1; - snprintf (me->exname, MNTPATHLEN, "%s", expname); - /* Sometimes we don't care about the full path - * so a NULL value for fullpath is valid. - */ - if (fullpath) { - if (strlen (fullpath) < MNTPATHLEN) { - strcpy (me->fullpath, fullpath); - me->has_full_path = _gf_true; - } - } + me = (struct mountentry *)GF_CALLOC(1, sizeof(*me), gf_nfs_mt_mountentry); + if (!me) + return -1; + nfs = (struct nfs_state *)ms->nfsx->private; - INIT_LIST_HEAD (&me->mlist); - /* Must get the IP or hostname of the client so we - * can map it into the mount entry. - */ - ret = rpcsvc_transport_peername (req->trans, me->hostname, MNTPATHLEN); - if (ret == -1) - goto free_err; + update_rmtab = mount_open_rmtab(nfs->rmtab, &sh); - colon = strrchr (me->hostname, ':'); - if (colon) { - *colon = '\0'; + snprintf(me->exname, MNTPATHLEN, "%s", expname); + /* Sometimes we don't care about the full path + * so a NULL value for fullpath is valid. + */ + if (fullpath) { + if (strlen(fullpath) < MNTPATHLEN) { + strcpy(me->fullpath, fullpath); + me->has_full_path = _gf_true; } - LOCK (&ms->mountlock); - { - /* in case locking fails, we just don't write the rmtab */ - if (update_rmtab && gf_store_lock (sh)) { - gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_LOCK_FAIL, - "Failed to lock '%s', changes will not be " - "written", nfs->rmtab); - } else if (update_rmtab) { - __mount_read_rmtab (sh, &ms->mountlist, _gf_false); - } + } - /* do not add duplicates */ - list_for_each_entry (cur, &ms->mountlist, mlist) { - if (!strcmp(cur->hostname, me->hostname) && - !strcmp(cur->exname, me->exname)) { - GF_FREE (me); - goto dont_add; - } - } - list_add_tail (&me->mlist, &ms->mountlist); - __mountdict_insert (ms, me); + INIT_LIST_HEAD(&me->mlist); + /* Must get the IP or hostname of the client so we + * can map it into the mount entry. + */ + ret = rpcsvc_transport_peername(req->trans, me->hostname, MNTPATHLEN); + if (ret == -1) + goto free_err; - /* only write the rmtab in case it was locked */ - if (update_rmtab && gf_store_locked_local (sh)) - __mount_rewrite_rmtab (ms, sh); - } + colon = strrchr(me->hostname, ':'); + if (colon) { + *colon = '\0'; + } + LOCK(&ms->mountlock); + { + /* in case locking fails, we just don't write the rmtab */ + if (update_rmtab && gf_store_lock(sh)) { + gf_msg(GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_LOCK_FAIL, + "Failed to lock '%s', changes will not be " + "written", + nfs->rmtab); + } else if (update_rmtab) { + __mount_read_rmtab(sh, &ms->mountlist, _gf_false); + } + + /* do not add duplicates */ + list_for_each_entry(cur, &ms->mountlist, mlist) + { + if (!strcmp(cur->hostname, me->hostname) && + !strcmp(cur->exname, me->exname)) { + GF_FREE(me); + goto dont_add; + } + } + list_add_tail(&me->mlist, &ms->mountlist); + __mountdict_insert(ms, me); + + /* only write the rmtab in case it was locked */ + if (update_rmtab && gf_store_locked_local(sh)) + __mount_rewrite_rmtab(ms, sh); + } dont_add: - if (update_rmtab && gf_store_locked_local (sh)) - gf_store_unlock (sh); + if (update_rmtab && gf_store_locked_local(sh)) + gf_store_unlock(sh); - UNLOCK (&ms->mountlock); + UNLOCK(&ms->mountlock); free_err: - if (update_rmtab) - gf_store_handle_destroy (sh); + if (update_rmtab) + gf_store_handle_destroy(sh); - if (ret == -1) - GF_FREE (me); + if (ret == -1) + GF_FREE(me); - return ret; + return ret; } - int -__mnt3_get_volume_id (struct mount3_state *ms, xlator_t *mntxl, - uuid_t volumeid) +__mnt3_get_volume_id(struct mount3_state *ms, xlator_t *mntxl, uuid_t volumeid) { - int ret = -1; - struct mnt3_export *exp = NULL; - - if ((!ms) || (!mntxl)) - return ret; - - LOCK (&ms->mountlock); - list_for_each_entry (exp, &ms->exportlist, explist) { - if (exp->vol == mntxl) { - gf_uuid_copy (volumeid, exp->volumeid); - ret = 0; - goto out; - } + int ret = -1; + struct mnt3_export *exp = NULL; + + if ((!ms) || (!mntxl)) + return ret; + + LOCK(&ms->mountlock); + list_for_each_entry(exp, &ms->exportlist, explist) + { + if (exp->vol == mntxl) { + gf_uuid_copy(volumeid, exp->volumeid); + ret = 0; + goto out; } + } out: - UNLOCK (&ms->mountlock); - return ret; + UNLOCK(&ms->mountlock); + return ret; } int -__mnt3_build_mountid_from_path (const char *path, uuid_t mountid) +__mnt3_build_mountid_from_path(const char *path, uuid_t mountid) { - uint32_t hashed_path = 0; - int ret = -1; + uint32_t hashed_path = 0; + int ret = -1; - if (!path) - goto out; + if (!path) + goto out; - while (strlen (path) > 0 && path[0] == '/') - path++; + while (strlen(path) > 0 && path[0] == '/') + path++; - /* Clear the mountid */ - gf_uuid_clear (mountid); + /* Clear the mountid */ + gf_uuid_clear(mountid); - hashed_path = SuperFastHash (path, strlen (path)); - if (hashed_path == 1) { - gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_HASH_PATH_FAIL, - "failed to hash path: %s", path); - goto out; - } + hashed_path = SuperFastHash(path, strlen(path)); + if (hashed_path == 1) { + gf_msg(GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_HASH_PATH_FAIL, + "failed to hash path: %s", path); + goto out; + } - memcpy (mountid, &hashed_path, sizeof (hashed_path)); - ret = 0; + memcpy(mountid, &hashed_path, sizeof(hashed_path)); + ret = 0; out: - return ret; + return ret; } int -__mnt3_get_mount_id (xlator_t *mntxl, uuid_t mountid) +__mnt3_get_mount_id(xlator_t *mntxl, uuid_t mountid) { - int ret = -1; - uint32_t hashed_path = 0; + int ret = -1; + uint32_t hashed_path = 0; + /* first clear the mountid */ + gf_uuid_clear(mountid); - /* first clear the mountid */ - gf_uuid_clear (mountid); + hashed_path = SuperFastHash(mntxl->name, strlen(mntxl->name)); + if (hashed_path == 1) { + gf_msg(GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_HASH_XLATOR_FAIL, + "failed to hash xlator name: %s", mntxl->name); + goto out; + } - hashed_path = SuperFastHash (mntxl->name, strlen (mntxl->name)); - if (hashed_path == 1) { - gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_HASH_XLATOR_FAIL, - "failed to hash xlator name: %s", mntxl->name); - goto out; - } - - memcpy (mountid, &hashed_path, sizeof (hashed_path)); - ret = 0; + memcpy(mountid, &hashed_path, sizeof(hashed_path)); + ret = 0; out: - return ret; + return ret; } - int32_t -mnt3svc_lookup_mount_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, int32_t op_errno, - inode_t *inode, struct iatt *buf, dict_t *xattr, - struct iatt *postparent) +mnt3svc_lookup_mount_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, dict_t *xattr, + struct iatt *postparent) { - mountres3 res = {0, }; - rpcsvc_request_t *req = NULL; - struct nfs3_fh fh = {{0}, }; - struct mount3_state *ms = NULL; - mountstat3 status = 0; - int autharr[10]; - int autharrlen = 0; - rpcsvc_t *svc = NULL; - xlator_t *mntxl = NULL; - uuid_t volumeid = {0, }; - char *path = NULL; - uuid_t mountid = {1, }; - char fhstr[1536]; - int alloclen = 0; - - req = (rpcsvc_request_t *)frame->local; - - if (!req) - return -1; - - mntxl = (xlator_t *)cookie; - ms = (struct mount3_state *)rpcsvc_request_program_private (req); - if (!ms) { - gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, - NFS_MSG_MNT_STATE_NOT_FOUND, - "mount state not found"); - op_ret = -1; - op_errno = EINVAL; - } - - if (op_ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, op_errno, - NFS_MSG_LOOKUP_MNT_ERROR, "error=%s", - strerror (op_errno)); - status = mnt3svc_errno_to_mnterr (op_errno); - } - if (status != MNT3_OK) - goto xmit_res; - - alloclen = strlen(mntxl->name) + 2; - path = GF_MALLOC (alloclen, gf_nfs_mt_char); - if (!path) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, - NFS_MSG_NO_MEMORY, - "Memory allocation failed."); - goto xmit_res; - } - - snprintf (path, alloclen, "/%s", mntxl->name); - mnt3svc_update_mountlist (ms, req, path, NULL); - GF_FREE (path); - if (gf_nfs_dvm_off (nfs_state (ms->nfsx))) { - fh = nfs3_fh_build_indexed_root_fh (ms->nfsx->children, mntxl); - goto xmit_res; - } + mountres3 res = { + 0, + }; + rpcsvc_request_t *req = NULL; + struct nfs3_fh fh = { + {0}, + }; + struct mount3_state *ms = NULL; + mountstat3 status = 0; + int autharr[10]; + int autharrlen = 0; + rpcsvc_t *svc = NULL; + xlator_t *mntxl = NULL; + uuid_t volumeid = { + 0, + }; + char *path = NULL; + uuid_t mountid = { + 1, + }; + char fhstr[1536]; + int alloclen = 0; + + req = (rpcsvc_request_t *)frame->local; + + if (!req) + return -1; - __mnt3_get_mount_id (mntxl, mountid); - __mnt3_get_volume_id (ms, mntxl, volumeid); - fh = nfs3_fh_build_uuid_root_fh (volumeid, mountid); + mntxl = (xlator_t *)cookie; + ms = (struct mount3_state *)rpcsvc_request_program_private(req); + if (!ms) { + gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_MNT_STATE_NOT_FOUND, + "mount state not found"); + op_ret = -1; + op_errno = EINVAL; + } + + if (op_ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, op_errno, NFS_MSG_LOOKUP_MNT_ERROR, + "error=%s", strerror(op_errno)); + status = mnt3svc_errno_to_mnterr(op_errno); + } + if (status != MNT3_OK) + goto xmit_res; + + alloclen = strlen(mntxl->name) + 2; + path = GF_MALLOC(alloclen, gf_nfs_mt_char); + if (!path) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed."); + goto xmit_res; + } + + snprintf(path, alloclen, "/%s", mntxl->name); + mnt3svc_update_mountlist(ms, req, path, NULL); + GF_FREE(path); + if (gf_nfs_dvm_off(nfs_state(ms->nfsx))) { + fh = nfs3_fh_build_indexed_root_fh(ms->nfsx->children, mntxl); + goto xmit_res; + } + + __mnt3_get_mount_id(mntxl, mountid); + __mnt3_get_volume_id(ms, mntxl, volumeid); + fh = nfs3_fh_build_uuid_root_fh(volumeid, mountid); xmit_res: - nfs3_fh_to_str (&fh, fhstr, sizeof (fhstr)); - gf_msg_debug (GF_MNT, 0, "MNT reply: fh %s, status: %d", fhstr, - status); - if (op_ret == 0) { - svc = rpcsvc_request_service (req); - autharrlen = rpcsvc_auth_array (svc, mntxl->name, autharr, - 10); - } - - res = mnt3svc_set_mountres3 (status, &fh, autharr, autharrlen); - mnt3svc_submit_reply (req, (void *)&res, - (mnt3_serializer)xdr_serialize_mountres3); - - return 0; + nfs3_fh_to_str(&fh, fhstr, sizeof(fhstr)); + gf_msg_debug(GF_MNT, 0, "MNT reply: fh %s, status: %d", fhstr, status); + if (op_ret == 0) { + svc = rpcsvc_request_service(req); + autharrlen = rpcsvc_auth_array(svc, mntxl->name, autharr, 10); + } + + res = mnt3svc_set_mountres3(status, &fh, autharr, autharrlen); + mnt3svc_submit_reply(req, (void *)&res, + (mnt3_serializer)xdr_serialize_mountres3); + + return 0; } - int -mnt3_match_dirpath_export (const char *expname, const char *dirpath, - gf_boolean_t export_parsing_match) +mnt3_match_dirpath_export(const char *expname, const char *dirpath, + gf_boolean_t export_parsing_match) { - int ret = 0; - size_t dlen; - char *fullpath = NULL; - char *second_slash = NULL; - char *dirdup = NULL; + int ret = 0; + size_t dlen; + char *fullpath = NULL; + char *second_slash = NULL; + char *dirdup = NULL; - if ((!expname) || (!dirpath)) - return 0; + if ((!expname) || (!dirpath)) + return 0; - dirdup = strdupa (dirpath); + dirdup = strdupa(dirpath); - /* Some clients send a dirpath for mount that includes the slash at the - * end. String compare for searching the export will fail because our - * exports list does not include that slash. Remove the slash to - * compare. - */ - dlen = strlen (dirdup); - if (dlen && dirdup[dlen - 1] == '/') - dirdup[dlen - 1] = '\0'; + /* Some clients send a dirpath for mount that includes the slash at the + * end. String compare for searching the export will fail because our + * exports list does not include that slash. Remove the slash to + * compare. + */ + dlen = strlen(dirdup); + if (dlen && dirdup[dlen - 1] == '/') + dirdup[dlen - 1] = '\0'; - /* Here we try to match fullpaths with export names */ - fullpath = dirdup; + /* Here we try to match fullpaths with export names */ + fullpath = dirdup; - if (export_parsing_match) { - if (dirdup[0] == '/') - fullpath = dirdup + 1; + if (export_parsing_match) { + if (dirdup[0] == '/') + fullpath = dirdup + 1; - second_slash = strchr (fullpath, '/'); - if (second_slash) - *second_slash = '\0'; - } + second_slash = strchr(fullpath, '/'); + if (second_slash) + *second_slash = '\0'; + } - /* The export name begins with a slash so move it forward by one - * to ignore the slash when we want to compare the fullpath and - * export. - */ - if (fullpath[0] != '/') - expname++; + /* The export name begins with a slash so move it forward by one + * to ignore the slash when we want to compare the fullpath and + * export. + */ + if (fullpath[0] != '/') + expname++; - if (strcmp (expname, fullpath) == 0) - ret = 1; + if (strcmp(expname, fullpath) == 0) + ret = 1; - return ret; + return ret; } - int -mnt3svc_mount_inode (rpcsvc_request_t *req, struct mount3_state *ms, - xlator_t * xl, inode_t *exportinode) +mnt3svc_mount_inode(rpcsvc_request_t *req, struct mount3_state *ms, + xlator_t *xl, inode_t *exportinode) { - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - loc_t exportloc = {0, }; - - if ((!req) || (!xl) || (!ms) || (!exportinode)) - return ret; - - ret = nfs_inode_loc_fill (exportinode, &exportloc, NFS_RESOLVE_EXIST); - if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_INODE_LOC_FILL_ERROR, - "Loc fill failed for export inode" - ": gfid %s, volume: %s", - uuid_utoa (exportinode->gfid), xl->name); - goto err; - } - - /* To service the mount request, all we need to do - * is to send a lookup fop that returns the stat - * for the root of the child volume. This is - * used to build the root fh sent to the client. - */ - nfs_request_user_init (&nfu, req); - ret = nfs_lookup (ms->nfsx, xl, &nfu, &exportloc, - mnt3svc_lookup_mount_cbk, (void *)req); + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + loc_t exportloc = { + 0, + }; + + if ((!req) || (!xl) || (!ms) || (!exportinode)) + return ret; - nfs_loc_wipe (&exportloc); + ret = nfs_inode_loc_fill(exportinode, &exportloc, NFS_RESOLVE_EXIST); + if (ret < 0) { + gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_INODE_LOC_FILL_ERROR, + "Loc fill failed for export inode" + ": gfid %s, volume: %s", + uuid_utoa(exportinode->gfid), xl->name); + goto err; + } + + /* To service the mount request, all we need to do + * is to send a lookup fop that returns the stat + * for the root of the child volume. This is + * used to build the root fh sent to the client. + */ + nfs_request_user_init(&nfu, req); + ret = nfs_lookup(ms->nfsx, xl, &nfu, &exportloc, mnt3svc_lookup_mount_cbk, + (void *)req); + + nfs_loc_wipe(&exportloc); err: - return ret; + return ret; } - /* For a volume mount request, we just have to create loc on the root inode, * and send a lookup. In the lookup callback the mount reply is send along with * the file handle. */ int -mnt3svc_volume_mount (rpcsvc_request_t *req, struct mount3_state *ms, - struct mnt3_export *exp) +mnt3svc_volume_mount(rpcsvc_request_t *req, struct mount3_state *ms, + struct mnt3_export *exp) { - inode_t *exportinode = NULL; - int ret = -EFAULT; - uuid_t rootgfid = {0, }; - - if ((!req) || (!exp) || (!ms)) - return ret; - - rootgfid[15] = 1; - exportinode = inode_find (exp->vol->itable, rootgfid); - if (!exportinode) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOENT, - NFS_MSG_GET_ROOT_INODE_FAIL, - "Failed to get root inode"); - ret = -ENOENT; - goto err; - } + inode_t *exportinode = NULL; + int ret = -EFAULT; + uuid_t rootgfid = { + 0, + }; + + if ((!req) || (!exp) || (!ms)) + return ret; + + rootgfid[15] = 1; + exportinode = inode_find(exp->vol->itable, rootgfid); + if (!exportinode) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOENT, NFS_MSG_GET_ROOT_INODE_FAIL, + "Failed to get root inode"); + ret = -ENOENT; + goto err; + } - ret = mnt3svc_mount_inode (req, ms, exp->vol, exportinode); - inode_unref (exportinode); + ret = mnt3svc_mount_inode(req, ms, exp->vol, exportinode); + inode_unref(exportinode); err: - return ret; + return ret; } - /* The catch with directory exports is that the first component of the export * name will be the name of the volume. * Any lookup that needs to be performed to build the directory's file handle @@ -951,280 +950,280 @@ err: * we need to strip out the volume name first. */ char * -mnt3_get_volume_subdir (char *dirpath, char **volname) +mnt3_get_volume_subdir(char *dirpath, char **volname) { - /* subdir points to the first / after the volume name while dirpath - * points to the first char of the volume name. - */ - char *subdir = NULL; - int volname_len = 0; - static char *root = "/"; - - /* all callers are expected to pass a valid *dirpath */ - GF_ASSERT (dirpath); - - if (dirpath[0] == '/') - dirpath++; - - subdir = index (dirpath, (int)'/'); - if (!subdir) { - subdir = root; - volname_len = strlen (dirpath); - } else { - volname_len = subdir - dirpath; - } - - if (!volname) - goto out; - - if (!*volname) - goto out; - - strncpy (*volname, dirpath, volname_len); - *(*volname + volname_len) = '\0'; + /* subdir points to the first / after the volume name while dirpath + * points to the first char of the volume name. + */ + char *subdir = NULL; + int volname_len = 0; + static char *root = "/"; + + /* all callers are expected to pass a valid *dirpath */ + GF_ASSERT(dirpath); + + if (dirpath[0] == '/') + dirpath++; + + subdir = index(dirpath, (int)'/'); + if (!subdir) { + subdir = root; + volname_len = strlen(dirpath); + } else { + volname_len = subdir - dirpath; + } + + if (!volname) + goto out; + + if (!*volname) + goto out; + + strncpy(*volname, dirpath, volname_len); + *(*volname + volname_len) = '\0'; out: - return subdir; + return subdir; } - void -mnt3_resolve_state_wipe (mnt3_resolve_t *mres) +mnt3_resolve_state_wipe(mnt3_resolve_t *mres) { - if (!mres) - return; - - nfs_loc_wipe (&mres->resolveloc); - GF_FREE (mres); + if (!mres) + return; + nfs_loc_wipe(&mres->resolveloc); + GF_FREE(mres); } - /* Sets up the component argument to contain the next component in the path and * sets up path as an absolute path starting from the next component. */ static char * -setup_next_component (char *path, size_t plen, char *component, size_t clen) +setup_next_component(char *path, size_t plen, char *component, size_t clen) { - char *comp = NULL; - char *nextcomp = NULL; - - if ((!path) || (!component)) - return NULL; - - strncpy (component, path, clen); - comp = index (component, (int)'/'); - if (!comp) - goto err; - - comp++; - nextcomp = index (comp, (int)'/'); - if (nextcomp) { - strncpy (path, nextcomp, plen); - *nextcomp = '\0'; - } else - path[0] = '\0'; + char *comp = NULL; + char *nextcomp = NULL; + + if ((!path) || (!component)) + return NULL; + + strncpy(component, path, clen); + comp = index(component, (int)'/'); + if (!comp) + goto err; + + comp++; + nextcomp = index(comp, (int)'/'); + if (nextcomp) { + strncpy(path, nextcomp, plen); + *nextcomp = '\0'; + } else + path[0] = '\0'; err: - return comp; + return comp; } int32_t -mnt3_resolve_subdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, dict_t *xattr, - struct iatt *postparent); +mnt3_resolve_subdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, dict_t *xattr, + struct iatt *postparent); int32_t -mnt3_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, const char *path, - struct iatt *buf, dict_t *xdata); +mnt3_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, const char *path, + struct iatt *buf, dict_t *xdata); /* There are multiple components in the directory export path and each one * needs to be looked up one after the other. */ int -__mnt3_resolve_export_subdir_comp (mnt3_resolve_t *mres) +__mnt3_resolve_export_subdir_comp(mnt3_resolve_t *mres) { - char dupsubdir[MNTPATHLEN]; - char *nextcomp = NULL; - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - uuid_t gfid = {0, }; - - if (!mres) - return ret; - - nextcomp = setup_next_component (mres->remainingdir, - sizeof (mres->remainingdir), - dupsubdir, sizeof (dupsubdir)); - if (!nextcomp) - goto err; - - /* Wipe the contents of the previous component */ - gf_uuid_copy (gfid, mres->resolveloc.inode->gfid); - nfs_loc_wipe (&mres->resolveloc); - ret = nfs_entry_loc_fill (mres->mstate->nfsx, mres->exp->vol->itable, - gfid, nextcomp, &mres->resolveloc, - NFS_RESOLVE_CREATE, NULL); - if ((ret < 0) && (ret != -2)) { - gf_msg (GF_MNT, GF_LOG_ERROR, EFAULT, - NFS_MSG_RESOLVE_INODE_FAIL, "Failed to resolve and " - "create inode: parent gfid %s, entry %s", - uuid_utoa (gfid), nextcomp); - ret = -EFAULT; - goto err; - } + char dupsubdir[MNTPATHLEN]; + char *nextcomp = NULL; + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + uuid_t gfid = { + 0, + }; + + if (!mres) + return ret; - nfs_request_user_init (&nfu, mres->req); - if (IA_ISLNK (mres->resolveloc.inode->ia_type)) { - ret = nfs_readlink (mres->mstate->nfsx, mres->exp->vol, &nfu, - &mres->resolveloc, mnt3_readlink_cbk, mres); - gf_msg_debug (GF_MNT, 0, "Symlink found , need to resolve" - " into directory handle"); - goto err; - } - ret = nfs_lookup (mres->mstate->nfsx, mres->exp->vol, &nfu, - &mres->resolveloc, mnt3_resolve_subdir_cbk, mres); + nextcomp = setup_next_component(mres->remainingdir, + sizeof(mres->remainingdir), dupsubdir, + sizeof(dupsubdir)); + if (!nextcomp) + goto err; + + /* Wipe the contents of the previous component */ + gf_uuid_copy(gfid, mres->resolveloc.inode->gfid); + nfs_loc_wipe(&mres->resolveloc); + ret = nfs_entry_loc_fill(mres->mstate->nfsx, mres->exp->vol->itable, gfid, + nextcomp, &mres->resolveloc, NFS_RESOLVE_CREATE, + NULL); + if ((ret < 0) && (ret != -2)) { + gf_msg(GF_MNT, GF_LOG_ERROR, EFAULT, NFS_MSG_RESOLVE_INODE_FAIL, + "Failed to resolve and " + "create inode: parent gfid %s, entry %s", + uuid_utoa(gfid), nextcomp); + ret = -EFAULT; + goto err; + } + + nfs_request_user_init(&nfu, mres->req); + if (IA_ISLNK(mres->resolveloc.inode->ia_type)) { + ret = nfs_readlink(mres->mstate->nfsx, mres->exp->vol, &nfu, + &mres->resolveloc, mnt3_readlink_cbk, mres); + gf_msg_debug(GF_MNT, 0, + "Symlink found , need to resolve" + " into directory handle"); + goto err; + } + ret = nfs_lookup(mres->mstate->nfsx, mres->exp->vol, &nfu, + &mres->resolveloc, mnt3_resolve_subdir_cbk, mres); err: - return ret; + return ret; } -int __mnt3_resolve_subdir (mnt3_resolve_t *mres); +int +__mnt3_resolve_subdir(mnt3_resolve_t *mres); /* * Per the AFR2 comments, this function performs the "fresh" lookup * by deleting the inode from cache and calling __mnt3_resolve_subdir * again. */ -int __mnt3_fresh_lookup (mnt3_resolve_t *mres) { - inode_unlink (mres->resolveloc.inode, - mres->resolveloc.parent, mres->resolveloc.name); - strncpy (mres->remainingdir, mres->resolveloc.path, - strlen(mres->resolveloc.path)); - nfs_loc_wipe (&mres->resolveloc); - return __mnt3_resolve_subdir (mres); +int +__mnt3_fresh_lookup(mnt3_resolve_t *mres) +{ + inode_unlink(mres->resolveloc.inode, mres->resolveloc.parent, + mres->resolveloc.name); + strncpy(mres->remainingdir, mres->resolveloc.path, + strlen(mres->resolveloc.path)); + nfs_loc_wipe(&mres->resolveloc); + return __mnt3_resolve_subdir(mres); } int32_t -mnt3_resolve_subdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, dict_t *xattr, - struct iatt *postparent) +mnt3_resolve_subdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, dict_t *xattr, + struct iatt *postparent) { - mnt3_resolve_t *mres = NULL; - mountstat3 mntstat = MNT3ERR_SERVERFAULT; - struct nfs3_fh fh = {{0}, }; - int autharr[10]; - int autharrlen = 0; - rpcsvc_t *svc = NULL; - mountres3 res = {0, }; - xlator_t *mntxl = NULL; - char *path = NULL; - struct mount3_state *ms = NULL; - int authcode = 0; - char *authorized_host = NULL; - char *authorized_path = NULL; - inode_t *linked_inode = NULL; - - mres = frame->local; - ms = mres->mstate; - mntxl = (xlator_t *)cookie; - if (op_ret == -1 && op_errno == ESTALE) { - /* Nuke inode from cache and try the LOOKUP - * request again. */ - return __mnt3_fresh_lookup (mres); - } else if (op_ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, op_errno, - NFS_MSG_RESOLVE_SUBDIR_FAIL, "path=%s (%s)", - mres->resolveloc.path, strerror (op_errno)); - mntstat = mnt3svc_errno_to_mnterr (op_errno); - goto err; + mnt3_resolve_t *mres = NULL; + mountstat3 mntstat = MNT3ERR_SERVERFAULT; + struct nfs3_fh fh = { + {0}, + }; + int autharr[10]; + int autharrlen = 0; + rpcsvc_t *svc = NULL; + mountres3 res = { + 0, + }; + xlator_t *mntxl = NULL; + char *path = NULL; + struct mount3_state *ms = NULL; + int authcode = 0; + char *authorized_host = NULL; + char *authorized_path = NULL; + inode_t *linked_inode = NULL; + + mres = frame->local; + ms = mres->mstate; + mntxl = (xlator_t *)cookie; + if (op_ret == -1 && op_errno == ESTALE) { + /* Nuke inode from cache and try the LOOKUP + * request again. */ + return __mnt3_fresh_lookup(mres); + } else if (op_ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, op_errno, NFS_MSG_RESOLVE_SUBDIR_FAIL, + "path=%s (%s)", mres->resolveloc.path, strerror(op_errno)); + mntstat = mnt3svc_errno_to_mnterr(op_errno); + goto err; + } + + linked_inode = inode_link(mres->resolveloc.inode, mres->resolveloc.parent, + mres->resolveloc.name, buf); + + if (linked_inode) + nfs_fix_generation(this, linked_inode); + + nfs3_fh_build_child_fh(&mres->parentfh, buf, &fh); + if (strlen(mres->remainingdir) <= 0) { + int alloclen; + op_ret = -1; + mntstat = MNT3_OK; + + /* Construct the full path */ + int resolveloc_path_len = strlen(mres->resolveloc.path); + alloclen = strlen(mres->exp->expname) + resolveloc_path_len + 1; + mres->exp->fullpath = GF_MALLOC(alloclen, gf_nfs_mt_char); + if (!mres->exp->fullpath) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed."); + goto err; + } + snprintf(mres->exp->fullpath, alloclen, "%s%s", mres->exp->expname, + mres->resolveloc.path); + + /* Check if this path is authorized to be mounted */ + authcode = mnt3_authenticate_request( + ms, mres->req, NULL, NULL, mres->exp->fullpath, &authorized_path, + &authorized_host, FALSE); + if (authcode != 0) { + mntstat = MNT3ERR_ACCES; + gf_msg_debug(GF_MNT, 0, "Client mount not allowed"); + op_ret = -1; + goto err; } - linked_inode = inode_link (mres->resolveloc.inode, - mres->resolveloc.parent, - mres->resolveloc.name, buf); - - if (linked_inode) - nfs_fix_generation (this, linked_inode); - - nfs3_fh_build_child_fh (&mres->parentfh, buf, &fh); - if (strlen (mres->remainingdir) <= 0) { - int alloclen; - op_ret = -1; - mntstat = MNT3_OK; - - /* Construct the full path */ - int resolveloc_path_len = strlen(mres->resolveloc.path); - alloclen = strlen (mres->exp->expname) + - resolveloc_path_len + 1; - mres->exp->fullpath = GF_MALLOC (alloclen, gf_nfs_mt_char); - if (!mres->exp->fullpath) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, - NFS_MSG_NO_MEMORY, - "Memory allocation failed."); - goto err; - } - snprintf (mres->exp->fullpath, alloclen, "%s%s", - mres->exp->expname, mres->resolveloc.path); - - /* Check if this path is authorized to be mounted */ - authcode = mnt3_authenticate_request (ms, mres->req, NULL, NULL, - mres->exp->fullpath, - &authorized_path, - &authorized_host, - FALSE); - if (authcode != 0) { - mntstat = MNT3ERR_ACCES; - gf_msg_debug (GF_MNT, 0, "Client mount not allowed"); - op_ret = -1; - goto err; - } - - alloclen = strlen (mres->exp->vol->name) + - resolveloc_path_len + 2; - path = GF_MALLOC (alloclen, gf_nfs_mt_char); - if (!path) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, - NFS_MSG_NO_MEMORY, - "Memory allocation failed"); - goto err; - } - /* Build mountid from the authorized path and stick it in the - * filehandle that will get passed back to the client - */ - __mnt3_build_mountid_from_path (authorized_path, fh.mountid); - - snprintf (path, alloclen, "/%s%s", mres->exp->vol->name, - mres->resolveloc.path); - - mnt3svc_update_mountlist (mres->mstate, mres->req, - path, mres->exp->fullpath); - GF_FREE (path); - } else { - mres->parentfh = fh; - op_ret = __mnt3_resolve_export_subdir_comp (mres); - if (op_ret < 0) - mntstat = mnt3svc_errno_to_mnterr (-op_ret); + alloclen = strlen(mres->exp->vol->name) + resolveloc_path_len + 2; + path = GF_MALLOC(alloclen, gf_nfs_mt_char); + if (!path) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); + goto err; } + /* Build mountid from the authorized path and stick it in the + * filehandle that will get passed back to the client + */ + __mnt3_build_mountid_from_path(authorized_path, fh.mountid); + + snprintf(path, alloclen, "/%s%s", mres->exp->vol->name, + mres->resolveloc.path); + + mnt3svc_update_mountlist(mres->mstate, mres->req, path, + mres->exp->fullpath); + GF_FREE(path); + } else { + mres->parentfh = fh; + op_ret = __mnt3_resolve_export_subdir_comp(mres); + if (op_ret < 0) + mntstat = mnt3svc_errno_to_mnterr(-op_ret); + } err: - if (op_ret == -1) { - gf_msg_debug (GF_MNT, 0, "Mount reply status: %d", mntstat); - svc = rpcsvc_request_service (mres->req); - autharrlen = rpcsvc_auth_array (svc, mntxl->name, autharr, - 10); - - res = mnt3svc_set_mountres3 (mntstat, &fh, autharr, autharrlen); - mnt3svc_submit_reply (mres->req, (void *)&res, - (mnt3_serializer)xdr_serialize_mountres3); - mnt3_resolve_state_wipe (mres); - } + if (op_ret == -1) { + gf_msg_debug(GF_MNT, 0, "Mount reply status: %d", mntstat); + svc = rpcsvc_request_service(mres->req); + autharrlen = rpcsvc_auth_array(svc, mntxl->name, autharr, 10); - GF_FREE (authorized_path); - GF_FREE (authorized_host); + res = mnt3svc_set_mountres3(mntstat, &fh, autharr, autharrlen); + mnt3svc_submit_reply(mres->req, (void *)&res, + (mnt3_serializer)xdr_serialize_mountres3); + mnt3_resolve_state_wipe(mres); + } - return 0; + GF_FREE(authorized_path); + GF_FREE(authorized_host); + + return 0; } /* This function resolves symbolic link into directory path from @@ -1251,105 +1250,106 @@ err: * similar to udp */ int32_t -mnt3_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, const char *path, - struct iatt *buf, dict_t *xdata) +mnt3_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, const char *path, + struct iatt *buf, dict_t *xdata) { - mnt3_resolve_t *mres = NULL; - int ret = -EFAULT; - char *real_loc = NULL; - size_t path_len = 0; - size_t parent_path_len = 0; - char *parent_path = NULL; - char *absolute_path = NULL; - char *relative_path = NULL; - int mntstat = 0; - - GF_ASSERT (frame); - - mres = frame->local; - if (!mres || !path || (path[0] == '/') || (op_ret < 0)) - goto mnterr; - - /* Finding current location of symlink */ - parent_path_len = strlen (mres->resolveloc.path) - strlen (mres->resolveloc.name); - parent_path = gf_strndup (mres->resolveloc.path, parent_path_len); - if (!parent_path) { - ret = -ENOMEM; - goto mnterr; - } - - relative_path = gf_strdup (path); - if (!relative_path) { - ret = -ENOMEM; - goto mnterr; - } - /* Resolving into absolute path */ - ret = gf_build_absolute_path (parent_path, relative_path, &absolute_path); - if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, ret, - NFS_MSG_RESOLVE_SYMLINK_ERROR, - "Cannot resolve symlink, path is out of boundary " - "from current location %s and with relative path " - "%s pointed by symlink", parent_path, relative_path); - - goto mnterr; - } - - /* Building the actual mount path to be mounted */ - path_len = strlen (mres->exp->vol->name) + strlen (absolute_path) - + strlen (mres->remainingdir) + 1; - real_loc = GF_MALLOC (path_len, gf_nfs_mt_char); - if (!real_loc) { - ret = -ENOMEM; - goto mnterr; - } - snprintf (real_loc, path_len, "%s%s", mres->exp->vol->name, absolute_path); - gf_path_strip_trailing_slashes (real_loc); - - /* There may entries after symlink in the mount path, - * we should include remaining entries too */ - if (strlen (mres->remainingdir) > 0) - strcat (real_loc, mres->remainingdir); - - gf_msg_debug (GF_MNT, 0, "Resolved path is : %s%s " - "and actual mount path is %s", - absolute_path, mres->remainingdir, real_loc); - - /* After the resolving the symlink , parsing should be done - * for the populated mount path - */ - ret = mnt3_parse_dir_exports (mres->req, mres->mstate, real_loc, - _gf_true); - - if (ret) { - gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_RESOLVE_ERROR, - "Resolved into an unknown path %s%s " - "from the current location of symlink %s", - absolute_path, mres->remainingdir, parent_path); - } - - GF_FREE (real_loc); - GF_FREE (absolute_path); - GF_FREE (parent_path); - GF_FREE (relative_path); - - return ret; + mnt3_resolve_t *mres = NULL; + int ret = -EFAULT; + char *real_loc = NULL; + size_t path_len = 0; + size_t parent_path_len = 0; + char *parent_path = NULL; + char *absolute_path = NULL; + char *relative_path = NULL; + int mntstat = 0; + + GF_ASSERT(frame); + + mres = frame->local; + if (!mres || !path || (path[0] == '/') || (op_ret < 0)) + goto mnterr; + + /* Finding current location of symlink */ + parent_path_len = strlen(mres->resolveloc.path) - + strlen(mres->resolveloc.name); + parent_path = gf_strndup(mres->resolveloc.path, parent_path_len); + if (!parent_path) { + ret = -ENOMEM; + goto mnterr; + } + + relative_path = gf_strdup(path); + if (!relative_path) { + ret = -ENOMEM; + goto mnterr; + } + /* Resolving into absolute path */ + ret = gf_build_absolute_path(parent_path, relative_path, &absolute_path); + if (ret < 0) { + gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RESOLVE_SYMLINK_ERROR, + "Cannot resolve symlink, path is out of boundary " + "from current location %s and with relative path " + "%s pointed by symlink", + parent_path, relative_path); + + goto mnterr; + } + + /* Building the actual mount path to be mounted */ + path_len = strlen(mres->exp->vol->name) + strlen(absolute_path) + + strlen(mres->remainingdir) + 1; + real_loc = GF_MALLOC(path_len, gf_nfs_mt_char); + if (!real_loc) { + ret = -ENOMEM; + goto mnterr; + } + snprintf(real_loc, path_len, "%s%s", mres->exp->vol->name, absolute_path); + gf_path_strip_trailing_slashes(real_loc); + + /* There may entries after symlink in the mount path, + * we should include remaining entries too */ + if (strlen(mres->remainingdir) > 0) + strcat(real_loc, mres->remainingdir); + + gf_msg_debug(GF_MNT, 0, + "Resolved path is : %s%s " + "and actual mount path is %s", + absolute_path, mres->remainingdir, real_loc); + + /* After the resolving the symlink , parsing should be done + * for the populated mount path + */ + ret = mnt3_parse_dir_exports(mres->req, mres->mstate, real_loc, _gf_true); + + if (ret) { + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_RESOLVE_ERROR, + "Resolved into an unknown path %s%s " + "from the current location of symlink %s", + absolute_path, mres->remainingdir, parent_path); + } + + GF_FREE(real_loc); + GF_FREE(absolute_path); + GF_FREE(parent_path); + GF_FREE(relative_path); + + return ret; mnterr: - if (mres) { - mntstat = mnt3svc_errno_to_mnterr (-ret); - mnt3svc_mnt_error_reply (mres->req, mntstat); - } else - gf_msg (GF_MNT, GF_LOG_CRITICAL, EINVAL, NFS_MSG_INVALID_ENTRY, - "mres == NULL, this should *never* happen"); - if (absolute_path) - GF_FREE (absolute_path); - if (parent_path) - GF_FREE (parent_path); - if (relative_path) - GF_FREE (relative_path); - return ret; + if (mres) { + mntstat = mnt3svc_errno_to_mnterr(-ret); + mnt3svc_mnt_error_reply(mres->req, mntstat); + } else + gf_msg(GF_MNT, GF_LOG_CRITICAL, EINVAL, NFS_MSG_INVALID_ENTRY, + "mres == NULL, this should *never* happen"); + if (absolute_path) + GF_FREE(absolute_path); + if (parent_path) + GF_FREE(parent_path); + if (relative_path) + GF_FREE(relative_path); + return ret; } /* We will always have to perform a hard lookup on all the components of a @@ -1364,69 +1364,72 @@ mnterr: * of the exported directory can be built. */ int -__mnt3_resolve_subdir (mnt3_resolve_t *mres) +__mnt3_resolve_subdir(mnt3_resolve_t *mres) { - char dupsubdir[MNTPATHLEN]; - char *firstcomp = NULL; - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - uuid_t rootgfid = {0, }; - - if (!mres) - return ret; - - firstcomp = setup_next_component (mres->remainingdir, - sizeof (mres->remainingdir), - dupsubdir, sizeof (dupsubdir)); - if (!firstcomp) - goto err; - - rootgfid[15] = 1; - ret = nfs_entry_loc_fill (mres->mstate->nfsx, mres->exp->vol->itable, - rootgfid, firstcomp, &mres->resolveloc, - NFS_RESOLVE_CREATE, NULL); - if ((ret < 0) && (ret != -2)) { - gf_msg (GF_MNT, GF_LOG_ERROR, EFAULT, - NFS_MSG_RESOLVE_INODE_FAIL, "Failed to resolve and " - "create inode for volume root: %s", - mres->exp->vol->name); - ret = -EFAULT; - goto err; - } + char dupsubdir[MNTPATHLEN]; + char *firstcomp = NULL; + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + uuid_t rootgfid = { + 0, + }; + + if (!mres) + return ret; - nfs_request_user_init (&nfu, mres->req); - if (IA_ISLNK (mres->resolveloc.inode->ia_type)) { - ret = nfs_readlink (mres->mstate->nfsx, mres->exp->vol, &nfu, - &mres->resolveloc, mnt3_readlink_cbk, mres); - gf_msg_debug (GF_MNT, 0, "Symlink found , need to resolve " - "into directory handle"); - goto err; - } - ret = nfs_lookup (mres->mstate->nfsx, mres->exp->vol, &nfu, - &mres->resolveloc, mnt3_resolve_subdir_cbk, mres); + firstcomp = setup_next_component(mres->remainingdir, + sizeof(mres->remainingdir), dupsubdir, + sizeof(dupsubdir)); + if (!firstcomp) + goto err; + + rootgfid[15] = 1; + ret = nfs_entry_loc_fill(mres->mstate->nfsx, mres->exp->vol->itable, + rootgfid, firstcomp, &mres->resolveloc, + NFS_RESOLVE_CREATE, NULL); + if ((ret < 0) && (ret != -2)) { + gf_msg(GF_MNT, GF_LOG_ERROR, EFAULT, NFS_MSG_RESOLVE_INODE_FAIL, + "Failed to resolve and " + "create inode for volume root: %s", + mres->exp->vol->name); + ret = -EFAULT; + goto err; + } + + nfs_request_user_init(&nfu, mres->req); + if (IA_ISLNK(mres->resolveloc.inode->ia_type)) { + ret = nfs_readlink(mres->mstate->nfsx, mres->exp->vol, &nfu, + &mres->resolveloc, mnt3_readlink_cbk, mres); + gf_msg_debug(GF_MNT, 0, + "Symlink found , need to resolve " + "into directory handle"); + goto err; + } + ret = nfs_lookup(mres->mstate->nfsx, mres->exp->vol, &nfu, + &mres->resolveloc, mnt3_resolve_subdir_cbk, mres); err: - return ret; + return ret; } - static gf_boolean_t -mnt3_match_subnet_v4 (struct addrinfo *ai, uint32_t saddr, uint32_t mask) +mnt3_match_subnet_v4(struct addrinfo *ai, uint32_t saddr, uint32_t mask) { - for (; ai; ai = ai->ai_next) { - struct sockaddr_in *sin = (struct sockaddr_in *)ai->ai_addr; + for (; ai; ai = ai->ai_next) { + struct sockaddr_in *sin = (struct sockaddr_in *)ai->ai_addr; - if (sin->sin_family != AF_INET) - continue; + if (sin->sin_family != AF_INET) + continue; - if (mask_match (saddr, sin->sin_addr.s_addr, mask)) - return _gf_true; - } + if (mask_match(saddr, sin->sin_addr.s_addr, mask)) + return _gf_true; + } - return _gf_false; + return _gf_false; } - /** * This function will verify if the client is allowed to mount * the directory or not. Client's IP address will be compared with @@ -1440,446 +1443,448 @@ mnt3_match_subnet_v4 (struct addrinfo *ai, uint32_t saddr, uint32_t mask) * TODO: Support IPv6 subnetwork */ int -mnt3_verify_auth (struct sockaddr_in *client_addr, struct mnt3_export *export) +mnt3_verify_auth(struct sockaddr_in *client_addr, struct mnt3_export *export) { - int retvalue = -EACCES; - int ret = 0; - struct host_auth_spec *host = NULL; - struct sockaddr_in *allowed_addr = NULL; - struct addrinfo *allowed_addrinfo = NULL; - - struct addrinfo hint = { - .ai_family = AF_INET, - .ai_protocol = (int)IPPROTO_TCP, - .ai_flags = AI_CANONNAME, - }; - - /* Sanity check */ - if ((NULL == client_addr) || - (NULL == export) || - (NULL == export->hostspec)) { - gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Invalid argument"); - return retvalue; - } - - host = export->hostspec; - - /* - * Currently IPv4 subnetwork is supported i.e. AF_INET. - * TODO: IPv6 subnetwork i.e. AF_INET6. - */ - if (client_addr->sin_family != AF_INET) { - gf_msg (GF_MNT, GF_LOG_ERROR, EAFNOSUPPORT, - NFS_MSG_UNSUPPORTED_VERSION, - "Only IPv4 is supported for subdir-auth"); - return retvalue; - } + int retvalue = -EACCES; + int ret = 0; + struct host_auth_spec *host = NULL; + struct sockaddr_in *allowed_addr = NULL; + struct addrinfo *allowed_addrinfo = NULL; + + struct addrinfo hint = { + .ai_family = AF_INET, + .ai_protocol = (int)IPPROTO_TCP, + .ai_flags = AI_CANONNAME, + }; + + /* Sanity check */ + if ((NULL == client_addr) || (NULL == export) || + (NULL == export->hostspec)) { + gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Invalid argument"); + return retvalue; + } - /* Try to see if the client IP matches the allowed IP list.*/ - while (NULL != host){ - GF_ASSERT (host->host_addr); + host = export->hostspec; - if (NULL != allowed_addrinfo) { - freeaddrinfo (allowed_addrinfo); - allowed_addrinfo = NULL; - } + /* + * Currently IPv4 subnetwork is supported i.e. AF_INET. + * TODO: IPv6 subnetwork i.e. AF_INET6. + */ + if (client_addr->sin_family != AF_INET) { + gf_msg(GF_MNT, GF_LOG_ERROR, EAFNOSUPPORT, NFS_MSG_UNSUPPORTED_VERSION, + "Only IPv4 is supported for subdir-auth"); + return retvalue; + } - /* Get the addrinfo for the allowed host (host_addr). */ - ret = getaddrinfo (host->host_addr, NULL, - &hint, &allowed_addrinfo); - if (0 != ret){ - /* - * getaddrinfo() FAILED for the host IP addr. Continue - * to search other allowed hosts in the hostspec list. - */ - gf_msg_debug (GF_MNT, 0, "getaddrinfo: %s\n", - gai_strerror (ret)); - host = host->next; - continue; - } + /* Try to see if the client IP matches the allowed IP list.*/ + while (NULL != host) { + GF_ASSERT(host->host_addr); - allowed_addr = (struct sockaddr_in *)(allowed_addrinfo->ai_addr); - if (NULL == allowed_addr) { - gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, - NFS_MSG_INVALID_ENTRY, "Invalid structure"); - break; - } + if (NULL != allowed_addrinfo) { + freeaddrinfo(allowed_addrinfo); + allowed_addrinfo = NULL; + } - /* Check if the network addr of both IPv4 socket match */ - if (mnt3_match_subnet_v4 (allowed_addrinfo, - client_addr->sin_addr.s_addr, - host->netmask)) { - retvalue = 0; - break; - } + /* Get the addrinfo for the allowed host (host_addr). */ + ret = getaddrinfo(host->host_addr, NULL, &hint, &allowed_addrinfo); + if (0 != ret) { + /* + * getaddrinfo() FAILED for the host IP addr. Continue + * to search other allowed hosts in the hostspec list. + */ + gf_msg_debug(GF_MNT, 0, "getaddrinfo: %s\n", gai_strerror(ret)); + host = host->next; + continue; + } - /* No match yet, continue the search */ - host = host->next; + allowed_addr = (struct sockaddr_in *)(allowed_addrinfo->ai_addr); + if (NULL == allowed_addr) { + gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Invalid structure"); + break; } - /* FREE the dynamic memory allocated by getaddrinfo() */ - if (NULL != allowed_addrinfo) { - freeaddrinfo (allowed_addrinfo); + /* Check if the network addr of both IPv4 socket match */ + if (mnt3_match_subnet_v4(allowed_addrinfo, client_addr->sin_addr.s_addr, + host->netmask)) { + retvalue = 0; + break; } - return retvalue; + /* No match yet, continue the search */ + host = host->next; + } + + /* FREE the dynamic memory allocated by getaddrinfo() */ + if (NULL != allowed_addrinfo) { + freeaddrinfo(allowed_addrinfo); + } + + return retvalue; } int -mnt3_resolve_subdir (rpcsvc_request_t *req, struct mount3_state *ms, - struct mnt3_export *exp, char *subdir, - gf_boolean_t send_reply) +mnt3_resolve_subdir(rpcsvc_request_t *req, struct mount3_state *ms, + struct mnt3_export *exp, char *subdir, + gf_boolean_t send_reply) { - mnt3_resolve_t *mres = NULL; - int ret = -EFAULT; - struct nfs3_fh pfh = GF_NFS3FH_STATIC_INITIALIZER; - struct sockaddr_in *sin = NULL; - - if ((!req) || (!ms) || (!exp) || (!subdir)) - return ret; - - sin = (struct sockaddr_in *)(&(req->trans->peerinfo.sockaddr)); - - /* Need to check AUTH */ - if (NULL != exp->hostspec) { - ret = mnt3_verify_auth (sin, exp); - if (0 != ret) { - gf_msg (GF_MNT, GF_LOG_ERROR, EACCES, - NFS_MSG_AUTH_VERIFY_FAILED, - "AUTH verification failed"); - return ret; - } - } + mnt3_resolve_t *mres = NULL; + int ret = -EFAULT; + struct nfs3_fh pfh = GF_NFS3FH_STATIC_INITIALIZER; + struct sockaddr_in *sin = NULL; - /* no reply is needed (WebNFS permissions checking), just return */ - if (!send_reply) - return 0; /* no error, mnt3_verify_auth() allowed it */ + if ((!req) || (!ms) || (!exp) || (!subdir)) + return ret; - mres = GF_CALLOC (1, sizeof (mnt3_resolve_t), gf_nfs_mt_mnt3_resolve); - if (!mres) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Memory allocation failed"); - goto err; + sin = (struct sockaddr_in *)(&(req->trans->peerinfo.sockaddr)); + + /* Need to check AUTH */ + if (NULL != exp->hostspec) { + ret = mnt3_verify_auth(sin, exp); + if (0 != ret) { + gf_msg(GF_MNT, GF_LOG_ERROR, EACCES, NFS_MSG_AUTH_VERIFY_FAILED, + "AUTH verification failed"); + return ret; } + } + + /* no reply is needed (WebNFS permissions checking), just return */ + if (!send_reply) + return 0; /* no error, mnt3_verify_auth() allowed it */ - mres->exp = exp; - mres->mstate = ms; - mres->req = req; + mres = GF_CALLOC(1, sizeof(mnt3_resolve_t), gf_nfs_mt_mnt3_resolve); + if (!mres) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); + goto err; + } - snprintf (mres->remainingdir, MNTPATHLEN, "%s", subdir); - gf_path_strip_trailing_slashes (mres->remainingdir); + mres->exp = exp; + mres->mstate = ms; + mres->req = req; - if (gf_nfs_dvm_off (nfs_state (ms->nfsx))) - pfh = nfs3_fh_build_indexed_root_fh ( - mres->mstate->nfsx->children, + snprintf(mres->remainingdir, MNTPATHLEN, "%s", subdir); + gf_path_strip_trailing_slashes(mres->remainingdir); + + if (gf_nfs_dvm_off(nfs_state(ms->nfsx))) + pfh = nfs3_fh_build_indexed_root_fh(mres->mstate->nfsx->children, mres->exp->vol); - else - pfh = nfs3_fh_build_uuid_root_fh (exp->volumeid, exp->mountid); + else + pfh = nfs3_fh_build_uuid_root_fh(exp->volumeid, exp->mountid); - mres->parentfh = pfh; - ret = __mnt3_resolve_subdir (mres); - if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RESOLVE_SUBDIR_FAIL, - "Failed to resolve export dir: %s", mres->exp->expname); - GF_FREE (mres); - } + mres->parentfh = pfh; + ret = __mnt3_resolve_subdir(mres); + if (ret < 0) { + gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RESOLVE_SUBDIR_FAIL, + "Failed to resolve export dir: %s", mres->exp->expname); + GF_FREE(mres); + } err: - return ret; + return ret; } - int -mnt3_resolve_export_subdir (rpcsvc_request_t *req, struct mount3_state *ms, - struct mnt3_export *exp) +mnt3_resolve_export_subdir(rpcsvc_request_t *req, struct mount3_state *ms, + struct mnt3_export *exp) { - char *volume_subdir = NULL; - int ret = -EFAULT; + char *volume_subdir = NULL; + int ret = -EFAULT; - if ((!req) || (!ms) || (!exp)) - return ret; + if ((!req) || (!ms) || (!exp)) + return ret; - volume_subdir = mnt3_get_volume_subdir (exp->expname, NULL); + volume_subdir = mnt3_get_volume_subdir(exp->expname, NULL); - ret = mnt3_resolve_subdir (req, ms, exp, volume_subdir, _gf_true); - if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RESOLVE_SUBDIR_FAIL, - "Failed to resolve export dir: %s", exp->expname); - goto err; - } + ret = mnt3_resolve_subdir(req, ms, exp, volume_subdir, _gf_true); + if (ret < 0) { + gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RESOLVE_SUBDIR_FAIL, + "Failed to resolve export dir: %s", exp->expname); + goto err; + } err: - return ret; + return ret; } - int -mnt3svc_mount (rpcsvc_request_t *req, struct mount3_state *ms, - struct mnt3_export *exp) +mnt3svc_mount(rpcsvc_request_t *req, struct mount3_state *ms, + struct mnt3_export *exp) { - int ret = -EFAULT; + int ret = -EFAULT; - if ((!req) || (!ms) || (!exp)) - return ret; + if ((!req) || (!ms) || (!exp)) + return ret; - if (exp->exptype == MNT3_EXPTYPE_VOLUME) - ret = mnt3svc_volume_mount (req, ms, exp); - else if (exp->exptype == MNT3_EXPTYPE_DIR) - ret = mnt3_resolve_export_subdir (req, ms, exp); + if (exp->exptype == MNT3_EXPTYPE_VOLUME) + ret = mnt3svc_volume_mount(req, ms, exp); + else if (exp->exptype == MNT3_EXPTYPE_DIR) + ret = mnt3_resolve_export_subdir(req, ms, exp); - return ret; + return ret; } - /* mnt3_mntpath_to_xlator sets this to 1 if the mount is for a full -* volume or 2 for a subdir in the volume. -* -* The parameter 'export_parsing_match' indicates whether this function -* is being called by an exports parser or whether it is being called -* during mount. The behavior is different since we don't have to resolve -* the path when doing the parse. -*/ + * volume or 2 for a subdir in the volume. + * + * The parameter 'export_parsing_match' indicates whether this function + * is being called by an exports parser or whether it is being called + * during mount. The behavior is different since we don't have to resolve + * the path when doing the parse. + */ struct mnt3_export * -mnt3_mntpath_to_export (struct mount3_state *ms, const char *dirpath, - gf_boolean_t export_parsing_match) +mnt3_mntpath_to_export(struct mount3_state *ms, const char *dirpath, + gf_boolean_t export_parsing_match) { - struct mnt3_export *exp = NULL; - struct mnt3_export *found = NULL; - - if ((!ms) || (!dirpath)) - return NULL; - - LOCK (&ms->mountlock); - list_for_each_entry (exp, &ms->exportlist, explist) { - - /* Search for the an exact match with the volume */ - if (mnt3_match_dirpath_export (exp->expname, dirpath, - export_parsing_match)) { - found = exp; - gf_msg_debug (GF_MNT, 0, "Found export volume: " - "%s", exp->vol->name); - goto foundexp; - } - } + struct mnt3_export *exp = NULL; + struct mnt3_export *found = NULL; - gf_msg_debug (GF_MNT, 0, "Export not found"); + if ((!ms) || (!dirpath)) + return NULL; + + LOCK(&ms->mountlock); + list_for_each_entry(exp, &ms->exportlist, explist) + { + /* Search for the an exact match with the volume */ + if (mnt3_match_dirpath_export(exp->expname, dirpath, + export_parsing_match)) { + found = exp; + gf_msg_debug(GF_MNT, 0, + "Found export volume: " + "%s", + exp->vol->name); + goto foundexp; + } + } + + gf_msg_debug(GF_MNT, 0, "Export not found"); foundexp: - UNLOCK (&ms->mountlock); - return found; + UNLOCK(&ms->mountlock); + return found; } - static int -mnt3_check_client_net_check (rpcsvc_t *svc, char *expvol, - char *ipaddr, uint16_t port) +mnt3_check_client_net_check(rpcsvc_t *svc, char *expvol, char *ipaddr, + uint16_t port) { - int ret = RPCSVC_AUTH_REJECT; - - if ((!svc) || (!expvol) || (!ipaddr)) - goto err; - - ret = rpcsvc_auth_check (svc, expvol, ipaddr); - if (ret == RPCSVC_AUTH_REJECT) { - gf_msg (GF_MNT, GF_LOG_INFO, 0, NFS_MSG_PEER_NOT_ALLOWED, - "Peer %s not allowed", ipaddr); - goto err; - } - - ret = rpcsvc_transport_privport_check (svc, expvol, port); - if (ret == RPCSVC_AUTH_REJECT) { - gf_msg (GF_MNT, GF_LOG_INFO, errno, NFS_MSG_PEER_NOT_ALLOWED, - "Peer %s rejected. Unprivileged " - "port %d not allowed", ipaddr, port); - goto err; - } - - ret = RPCSVC_AUTH_ACCEPT; + int ret = RPCSVC_AUTH_REJECT; + + if ((!svc) || (!expvol) || (!ipaddr)) + goto err; + + ret = rpcsvc_auth_check(svc, expvol, ipaddr); + if (ret == RPCSVC_AUTH_REJECT) { + gf_msg(GF_MNT, GF_LOG_INFO, 0, NFS_MSG_PEER_NOT_ALLOWED, + "Peer %s not allowed", ipaddr); + goto err; + } + + ret = rpcsvc_transport_privport_check(svc, expvol, port); + if (ret == RPCSVC_AUTH_REJECT) { + gf_msg(GF_MNT, GF_LOG_INFO, errno, NFS_MSG_PEER_NOT_ALLOWED, + "Peer %s rejected. Unprivileged " + "port %d not allowed", + ipaddr, port); + goto err; + } + + ret = RPCSVC_AUTH_ACCEPT; err: - return ret; + return ret; } int -mnt3_check_client_net_tcp (rpcsvc_request_t *req, char *volname) +mnt3_check_client_net_tcp(rpcsvc_request_t *req, char *volname) { - rpcsvc_t *svc = NULL; - rpc_transport_t *trans = NULL; - union gf_sock_union sock_union; - socklen_t socksize = sizeof (struct sockaddr_in); - char peer[RPCSVC_PEER_STRLEN] = {0,}; - char *ipaddr = NULL; - uint16_t port = 0; - int ret = RPCSVC_AUTH_REJECT; - - if ((!req) || (!volname)) - goto err; - - svc = rpcsvc_request_service (req); - trans = rpcsvc_request_transport (req); - if ((!svc) || (!trans)) - goto err; - - ret = rpcsvc_transport_peeraddr (trans, peer, RPCSVC_PEER_STRLEN, - &sock_union.storage, socksize); - if (ret != 0) { - gf_msg (GF_MNT, GF_LOG_WARNING, ENOENT, - NFS_MSG_GET_PEER_ADDR_FAIL, "Failed to get peer " - "addr: %s", gai_strerror (ret)); - ret = RPCSVC_AUTH_REJECT; - goto err; - } - - /* peer[] gets IP:PORT formar, slash the port out */ - if (!get_host_name ((char *)peer, &ipaddr)) - ipaddr = peer; - - port = ntohs (sock_union.sin.sin_port); - - ret = mnt3_check_client_net_check (svc, volname, ipaddr, port); + rpcsvc_t *svc = NULL; + rpc_transport_t *trans = NULL; + union gf_sock_union sock_union; + socklen_t socksize = sizeof(struct sockaddr_in); + char peer[RPCSVC_PEER_STRLEN] = { + 0, + }; + char *ipaddr = NULL; + uint16_t port = 0; + int ret = RPCSVC_AUTH_REJECT; + + if ((!req) || (!volname)) + goto err; + + svc = rpcsvc_request_service(req); + trans = rpcsvc_request_transport(req); + if ((!svc) || (!trans)) + goto err; + + ret = rpcsvc_transport_peeraddr(trans, peer, RPCSVC_PEER_STRLEN, + &sock_union.storage, socksize); + if (ret != 0) { + gf_msg(GF_MNT, GF_LOG_WARNING, ENOENT, NFS_MSG_GET_PEER_ADDR_FAIL, + "Failed to get peer " + "addr: %s", + gai_strerror(ret)); + ret = RPCSVC_AUTH_REJECT; + goto err; + } + + /* peer[] gets IP:PORT formar, slash the port out */ + if (!get_host_name((char *)peer, &ipaddr)) + ipaddr = peer; + + port = ntohs(sock_union.sin.sin_port); + + ret = mnt3_check_client_net_check(svc, volname, ipaddr, port); err: - return ret; + return ret; } static int -mnt3_check_client_net_udp (struct svc_req *req, char *volname, xlator_t *nfsx) +mnt3_check_client_net_udp(struct svc_req *req, char *volname, xlator_t *nfsx) { - rpcsvc_t *svc = NULL; - struct sockaddr_in *sin = NULL; - char ipaddr[INET_ADDRSTRLEN + 1] = {0, }; - uint16_t port = 0; - int ret = RPCSVC_AUTH_REJECT; - struct nfs_state *nfs = NULL; - - if ((!req) || (!volname) || (!nfsx)) - goto err; + rpcsvc_t *svc = NULL; + struct sockaddr_in *sin = NULL; + char ipaddr[INET_ADDRSTRLEN + 1] = { + 0, + }; + uint16_t port = 0; + int ret = RPCSVC_AUTH_REJECT; + struct nfs_state *nfs = NULL; + + if ((!req) || (!volname) || (!nfsx)) + goto err; #if !defined(_TIRPC_SVC_H) - sin = svc_getcaller (req->rq_xprt); + sin = svc_getcaller(req->rq_xprt); #else - sin = (struct sockaddr_in *)svc_getcaller (req->rq_xprt); - /* TIRPC's svc_getcaller() returns a pointer to a sockaddr_in6, even - * though it might actually be an IPv4 address. It ought return a - * struct sockaddr and make the caller upcast it to the proper - * address family. Sigh. - */ + sin = (struct sockaddr_in *)svc_getcaller(req->rq_xprt); + /* TIRPC's svc_getcaller() returns a pointer to a sockaddr_in6, even + * though it might actually be an IPv4 address. It ought return a + * struct sockaddr and make the caller upcast it to the proper + * address family. Sigh. + */ #endif - if (!sin) - goto err; - /* And let's make sure that it's actually an IPv4 address. */ + if (!sin) + goto err; + /* And let's make sure that it's actually an IPv4 address. */ - GF_ASSERT (sin->sin_family == AF_INET); + GF_ASSERT(sin->sin_family == AF_INET); - (void) inet_ntop (AF_INET, &sin->sin_addr, ipaddr, INET_ADDRSTRLEN); + (void)inet_ntop(AF_INET, &sin->sin_addr, ipaddr, INET_ADDRSTRLEN); - port = ntohs (sin->sin_port); + port = ntohs(sin->sin_port); - nfs = (struct nfs_state *)nfsx->private; - if (nfs != NULL) - svc = nfs->rpcsvc; + nfs = (struct nfs_state *)nfsx->private; + if (nfs != NULL) + svc = nfs->rpcsvc; - ret = mnt3_check_client_net_check (svc, volname, ipaddr, port); + ret = mnt3_check_client_net_check(svc, volname, ipaddr, port); err: - return ret; + return ret; } - int -mnt3_parse_dir_exports (rpcsvc_request_t *req, struct mount3_state *ms, - char *path, gf_boolean_t send_reply) +mnt3_parse_dir_exports(rpcsvc_request_t *req, struct mount3_state *ms, + char *path, gf_boolean_t send_reply) { - char volname[1024] = {0, }; - struct mnt3_export *exp = NULL; - char *volname_ptr = NULL; - char *subdir = NULL; - int ret = -ENOENT; - struct nfs_state *nfs = NULL; - - if ((!ms) || (!path)) - return -1; - - volname_ptr = volname; - subdir = mnt3_get_volume_subdir (path, &volname_ptr); + char volname[1024] = { + 0, + }; + struct mnt3_export *exp = NULL; + char *volname_ptr = NULL; + char *subdir = NULL; + int ret = -ENOENT; + struct nfs_state *nfs = NULL; + + if ((!ms) || (!path)) + return -1; - /* first try to match the full export/subdir */ - exp = mnt3_mntpath_to_export (ms, path, _gf_false); + volname_ptr = volname; + subdir = mnt3_get_volume_subdir(path, &volname_ptr); + + /* first try to match the full export/subdir */ + exp = mnt3_mntpath_to_export(ms, path, _gf_false); + if (!exp) { + gf_msg_trace(GF_MNT, 0, + "Could not find exact matching export " + "for path=%s", + path); + /* if no exact match is found, look for a fallback */ + exp = mnt3_mntpath_to_export(ms, volname, _gf_true); if (!exp) { - gf_msg_trace (GF_MNT, 0, "Could not find exact matching export " - "for path=%s", path); - /* if no exact match is found, look for a fallback */ - exp = mnt3_mntpath_to_export (ms, volname, _gf_true); - if (!exp) { - gf_msg_trace (GF_MNT, 0, "Could not find export for " - "volume %s", volname); - goto err; - } - } - gf_msg_trace (GF_MNT, 0, "volume %s and export %s will be used for " - "path %s", exp->vol->name, exp->expname, path); - - nfs = (struct nfs_state *)ms->nfsx->private; - if (!nfs) - goto err; - - if (!nfs_subvolume_started (nfs, exp->vol)) { - gf_msg_debug (GF_MNT, 0, "Volume %s not started", - exp->vol->name); - goto err; - } - - ret = mnt3_check_client_net_tcp (req, exp->vol->name); - if (ret == RPCSVC_AUTH_REJECT) { - gf_msg_debug (GF_MNT, 0, "Client mount not allowed"); - ret = -EACCES; - goto err; - } - - ret = mnt3_resolve_subdir (req, ms, exp, subdir, send_reply); - if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RESOLVE_SUBDIR_FAIL, - "Failed to resolve export dir: %s", subdir); - goto err; - } + gf_msg_trace(GF_MNT, 0, + "Could not find export for " + "volume %s", + volname); + goto err; + } + } + gf_msg_trace(GF_MNT, 0, + "volume %s and export %s will be used for " + "path %s", + exp->vol->name, exp->expname, path); + + nfs = (struct nfs_state *)ms->nfsx->private; + if (!nfs) + goto err; + + if (!nfs_subvolume_started(nfs, exp->vol)) { + gf_msg_debug(GF_MNT, 0, "Volume %s not started", exp->vol->name); + goto err; + } + + ret = mnt3_check_client_net_tcp(req, exp->vol->name); + if (ret == RPCSVC_AUTH_REJECT) { + gf_msg_debug(GF_MNT, 0, "Client mount not allowed"); + ret = -EACCES; + goto err; + } + + ret = mnt3_resolve_subdir(req, ms, exp, subdir, send_reply); + if (ret < 0) { + gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RESOLVE_SUBDIR_FAIL, + "Failed to resolve export dir: %s", subdir); + goto err; + } err: - return ret; + return ret; } - int -mnt3_find_export (rpcsvc_request_t *req, char *path, struct mnt3_export **e) +mnt3_find_export(rpcsvc_request_t *req, char *path, struct mnt3_export **e) { - int ret = -EFAULT; - struct mount3_state *ms = NULL; - struct mnt3_export *exp = NULL; - - if ((!req) || (!path) || (!e)) - return -1; - - ms = (struct mount3_state *) rpcsvc_request_program_private (req); - if (!ms) { - gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, - NFS_MSG_MNT_STATE_NOT_FOUND, "Mount state not present"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - goto err; - } + int ret = -EFAULT; + struct mount3_state *ms = NULL; + struct mnt3_export *exp = NULL; - gf_msg_debug (GF_MNT, 0, "dirpath: %s", path); - exp = mnt3_mntpath_to_export (ms, path, _gf_false); - if (exp) { - ret = 0; - *e = exp; - goto err; - } + if ((!req) || (!path) || (!e)) + return -1; - if (!gf_mnt3_export_dirs(ms)) { - ret = -1; - goto err; - } + ms = (struct mount3_state *)rpcsvc_request_program_private(req); + if (!ms) { + gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_MNT_STATE_NOT_FOUND, + "Mount state not present"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + goto err; + } + + gf_msg_debug(GF_MNT, 0, "dirpath: %s", path); + exp = mnt3_mntpath_to_export(ms, path, _gf_false); + if (exp) { + ret = 0; + *e = exp; + goto err; + } - ret = mnt3_parse_dir_exports (req, ms, path, _gf_true); + if (!gf_mnt3_export_dirs(ms)) { + ret = -1; + goto err; + } + + ret = mnt3_parse_dir_exports(req, ms, path, _gf_true); err: - return ret; + return ret; } /** @@ -1892,25 +1897,29 @@ err: * failure: NULL */ char * -_mnt3_get_peer_addr (const rpcsvc_request_t *req) +_mnt3_get_peer_addr(const rpcsvc_request_t *req) { - rpc_transport_t *trans = NULL; - struct sockaddr_storage sastorage = {0, }; - char peer[RPCSVC_PEER_STRLEN] = {0, }; - char *peerdup = NULL; - int ret = 0; - - GF_VALIDATE_OR_GOTO (GF_NFS, req, out); - - trans = rpcsvc_request_transport (req); - ret = rpcsvc_transport_peeraddr (trans, peer, RPCSVC_PEER_STRLEN, - &sastorage, sizeof (sastorage)); - if (ret != 0) - goto out; - - peerdup = gf_strdup (peer); + rpc_transport_t *trans = NULL; + struct sockaddr_storage sastorage = { + 0, + }; + char peer[RPCSVC_PEER_STRLEN] = { + 0, + }; + char *peerdup = NULL; + int ret = 0; + + GF_VALIDATE_OR_GOTO(GF_NFS, req, out); + + trans = rpcsvc_request_transport(req); + ret = rpcsvc_transport_peeraddr(trans, peer, RPCSVC_PEER_STRLEN, &sastorage, + sizeof(sastorage)); + if (ret != 0) + goto out; + + peerdup = gf_strdup(peer); out: - return peerdup; + return peerdup; } /** @@ -1925,27 +1934,27 @@ out: * */ char * -_mnt3_get_host_from_peer (const char *peer_addr) +_mnt3_get_host_from_peer(const char *peer_addr) { - char *part = NULL; - size_t host_len = 0; - char *colon = NULL; - - colon = strrchr (peer_addr, ':'); - if (!colon) { - gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_BAD_PEER, - "Bad peer %s", peer_addr); - goto out; - } - - host_len = colon - peer_addr; - if (host_len < RPCSVC_PEER_STRLEN) - part = gf_strndup (peer_addr, host_len); - else - gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_PEER_TOO_LONG, - "Peer too long %s", peer_addr); + char *part = NULL; + size_t host_len = 0; + char *colon = NULL; + + colon = strrchr(peer_addr, ':'); + if (!colon) { + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_BAD_PEER, "Bad peer %s", + peer_addr); + goto out; + } + + host_len = colon - peer_addr; + if (host_len < RPCSVC_PEER_STRLEN) + part = gf_strndup(peer_addr, host_len); + else + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_PEER_TOO_LONG, + "Peer too long %s", peer_addr); out: - return part; + return part; } /** @@ -1956,13 +1965,13 @@ out: * */ int -mnt3_check_cached_fh (struct mount3_state *ms, struct nfs3_fh *fh, - const char *host_addr, gf_boolean_t is_write_op) +mnt3_check_cached_fh(struct mount3_state *ms, struct nfs3_fh *fh, + const char *host_addr, gf_boolean_t is_write_op) { - if (!is_write_op) - return is_nfs_fh_cached (ms->authcache, fh, host_addr); + if (!is_write_op) + return is_nfs_fh_cached(ms->authcache, fh, host_addr); - return is_nfs_fh_cached_and_writeable (ms->authcache, fh, host_addr); + return is_nfs_fh_cached_and_writeable(ms->authcache, fh, host_addr); } /** @@ -1984,109 +1993,103 @@ mnt3_check_cached_fh (struct mount3_state *ms, struct nfs3_fh *fh, * -EROFS for unauthorized write operations (rm, mkdir, write) */ int -_mnt3_authenticate_req (struct mount3_state *ms, rpcsvc_request_t *req, - struct nfs3_fh *fh, const char *path, - char **authorized_export, char **authorized_host, - gf_boolean_t is_write_op) +_mnt3_authenticate_req(struct mount3_state *ms, rpcsvc_request_t *req, + struct nfs3_fh *fh, const char *path, + char **authorized_export, char **authorized_host, + gf_boolean_t is_write_op) { - char *peer_addr = NULL; - char *host_addr_ip = NULL; - char *host_addr_fqdn = NULL; - int auth_status_code = -EACCES; - char *pathdup = NULL; - size_t dlen = 0; - char *auth_host = NULL; - gf_boolean_t fh_cached = _gf_false; - struct export_item *expitem = NULL; - - GF_VALIDATE_OR_GOTO (GF_MNT, ms, out); - GF_VALIDATE_OR_GOTO (GF_MNT, req, out); - - peer_addr = _mnt3_get_peer_addr (req); - - if (!peer_addr) - goto free_and_out; - - host_addr_ip = _mnt3_get_host_from_peer (peer_addr); - - if (!host_addr_ip) - goto free_and_out; - - if (path) { - /* Need to strip out trailing '/' */ - pathdup = strdupa (path); - dlen = strlen (pathdup); - if (dlen > 0 && pathdup[dlen-1] == '/') - pathdup[dlen-1] = '\0'; - } - - /* Check if the filehandle is cached */ - fh_cached = mnt3_check_cached_fh (ms, fh, host_addr_ip, is_write_op); - if (fh_cached) { - gf_msg_trace (GF_MNT, 0, "Found cached FH for %s", - host_addr_ip); - auth_status_code = 0; - goto free_and_out; - } - - /* Check if the IP is authorized */ - auth_status_code = mnt3_auth_host (ms->auth_params, host_addr_ip, - fh, pathdup, is_write_op, &expitem); - - gf_msg_debug (GF_MNT, 0, "access from IP %s is %s", host_addr_ip, - auth_status_code ? "denied" : "allowed"); - - if (auth_status_code != 0) { - /* If not, check if the FQDN is authorized */ - host_addr_fqdn = gf_rev_dns_lookup (host_addr_ip); - auth_status_code = mnt3_auth_host (ms->auth_params, - host_addr_fqdn, - fh, pathdup, is_write_op, - &expitem); - - gf_msg_debug (GF_MNT, 0, "access from FQDN %s is %s", - host_addr_fqdn, auth_status_code ? "denied" : - "allowed"); - - if (auth_status_code == 0) - auth_host = host_addr_fqdn; - } else - auth_host = host_addr_ip; - - /* Skip the lines that set authorized export & - * host if they are null. - */ - if (!authorized_export || !authorized_host) { - /* Cache the file handle if it was authorized */ - if (fh && auth_status_code == 0) - cache_nfs_fh (ms->authcache, fh, host_addr_ip, expitem); - - goto free_and_out; - } - - if (!fh && auth_status_code == 0) { - *authorized_export = gf_strdup (pathdup); - if (!*authorized_export) - gf_msg (GF_MNT, GF_LOG_CRITICAL, ENOMEM, - NFS_MSG_NO_MEMORY, - "Allocation error when copying " - "authorized path"); - - *authorized_host = gf_strdup (auth_host); - if (!*authorized_host) - gf_msg (GF_MNT, GF_LOG_CRITICAL, ENOMEM, - NFS_MSG_NO_MEMORY, - "Allocation error when copying " - "authorized host"); - } + char *peer_addr = NULL; + char *host_addr_ip = NULL; + char *host_addr_fqdn = NULL; + int auth_status_code = -EACCES; + char *pathdup = NULL; + size_t dlen = 0; + char *auth_host = NULL; + gf_boolean_t fh_cached = _gf_false; + struct export_item *expitem = NULL; + + GF_VALIDATE_OR_GOTO(GF_MNT, ms, out); + GF_VALIDATE_OR_GOTO(GF_MNT, req, out); + + peer_addr = _mnt3_get_peer_addr(req); + + if (!peer_addr) + goto free_and_out; + + host_addr_ip = _mnt3_get_host_from_peer(peer_addr); + + if (!host_addr_ip) + goto free_and_out; + + if (path) { + /* Need to strip out trailing '/' */ + pathdup = strdupa(path); + dlen = strlen(pathdup); + if (dlen > 0 && pathdup[dlen - 1] == '/') + pathdup[dlen - 1] = '\0'; + } + + /* Check if the filehandle is cached */ + fh_cached = mnt3_check_cached_fh(ms, fh, host_addr_ip, is_write_op); + if (fh_cached) { + gf_msg_trace(GF_MNT, 0, "Found cached FH for %s", host_addr_ip); + auth_status_code = 0; + goto free_and_out; + } + + /* Check if the IP is authorized */ + auth_status_code = mnt3_auth_host(ms->auth_params, host_addr_ip, fh, + pathdup, is_write_op, &expitem); + + gf_msg_debug(GF_MNT, 0, "access from IP %s is %s", host_addr_ip, + auth_status_code ? "denied" : "allowed"); + + if (auth_status_code != 0) { + /* If not, check if the FQDN is authorized */ + host_addr_fqdn = gf_rev_dns_lookup(host_addr_ip); + auth_status_code = mnt3_auth_host(ms->auth_params, host_addr_fqdn, fh, + pathdup, is_write_op, &expitem); + + gf_msg_debug(GF_MNT, 0, "access from FQDN %s is %s", host_addr_fqdn, + auth_status_code ? "denied" : "allowed"); + + if (auth_status_code == 0) + auth_host = host_addr_fqdn; + } else + auth_host = host_addr_ip; + + /* Skip the lines that set authorized export & + * host if they are null. + */ + if (!authorized_export || !authorized_host) { + /* Cache the file handle if it was authorized */ + if (fh && auth_status_code == 0) + cache_nfs_fh(ms->authcache, fh, host_addr_ip, expitem); + + goto free_and_out; + } + + if (!fh && auth_status_code == 0) { + *authorized_export = gf_strdup(pathdup); + if (!*authorized_export) + gf_msg(GF_MNT, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY, + "Allocation error when copying " + "authorized path"); + + *authorized_host = gf_strdup(auth_host); + if (!*authorized_host) + gf_msg(GF_MNT, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY, + "Allocation error when copying " + "authorized host"); + } free_and_out: - /* Free allocated strings after doing the auth */ - GF_FREE (peer_addr); - GF_FREE (host_addr_fqdn); - GF_FREE (host_addr_ip); + /* Free allocated strings after doing the auth */ + GF_FREE(peer_addr); + GF_FREE(host_addr_fqdn); + GF_FREE(host_addr_ip); out: - return auth_status_code; + return auth_status_code; } /** @@ -2114,827 +2117,810 @@ out: * -EROFS for unauthorized write operations (rm, mkdir, write) */ int -mnt3_authenticate_request (struct mount3_state *ms, rpcsvc_request_t *req, - struct nfs3_fh *fh, const char *volname, - const char *path, char **authorized_path, - char **authorized_host, gf_boolean_t is_write_op) +mnt3_authenticate_request(struct mount3_state *ms, rpcsvc_request_t *req, + struct nfs3_fh *fh, const char *volname, + const char *path, char **authorized_path, + char **authorized_host, gf_boolean_t is_write_op) { - int auth_status_code = -EACCES; - char *parent_path = NULL; - const char *parent_old = NULL; - - GF_VALIDATE_OR_GOTO (GF_MNT, ms, out); - GF_VALIDATE_OR_GOTO (GF_MNT, req, out); - - /* If this option is not set, just allow it through */ - if (!ms->nfs->exports_auth) { - /* This function is called in a variety of use-cases (mount - * + each fop) so path/authorized_path are not always present. - * For the cases which it _is_ present we need to populate the - * authorized_path. */ - if (path && authorized_path) - *authorized_path = gf_strdup (path); - - auth_status_code = 0; - goto out; - } - - /* First check if the path is allowed */ - auth_status_code = _mnt3_authenticate_req (ms, req, fh, path, - authorized_path, - authorized_host, - is_write_op); - - /* If the filehandle is set, just exit since we have to make only - * one call to the function above - */ - if (fh) - goto out; - - parent_old = path; - while (auth_status_code != 0) { - /* Get the path's parent */ - parent_path = gf_resolve_path_parent (parent_old); - if (!parent_path) /* Nothing left in the path to resolve */ - goto out; - - /* Authenticate it */ - auth_status_code = _mnt3_authenticate_req (ms, req, fh, - parent_path, - authorized_path, - authorized_host, - is_write_op); - - parent_old = strdupa (parent_path); /* Copy the parent onto the - * stack. - */ - - GF_FREE (parent_path); /* Free the allocated parent string */ - } + int auth_status_code = -EACCES; + char *parent_path = NULL; + const char *parent_old = NULL; + + GF_VALIDATE_OR_GOTO(GF_MNT, ms, out); + GF_VALIDATE_OR_GOTO(GF_MNT, req, out); + + /* If this option is not set, just allow it through */ + if (!ms->nfs->exports_auth) { + /* This function is called in a variety of use-cases (mount + * + each fop) so path/authorized_path are not always present. + * For the cases which it _is_ present we need to populate the + * authorized_path. */ + if (path && authorized_path) + *authorized_path = gf_strdup(path); + + auth_status_code = 0; + goto out; + } + + /* First check if the path is allowed */ + auth_status_code = _mnt3_authenticate_req( + ms, req, fh, path, authorized_path, authorized_host, is_write_op); + + /* If the filehandle is set, just exit since we have to make only + * one call to the function above + */ + if (fh) + goto out; + + parent_old = path; + while (auth_status_code != 0) { + /* Get the path's parent */ + parent_path = gf_resolve_path_parent(parent_old); + if (!parent_path) /* Nothing left in the path to resolve */ + goto out; + + /* Authenticate it */ + auth_status_code = _mnt3_authenticate_req(ms, req, fh, parent_path, + authorized_path, + authorized_host, is_write_op); + + parent_old = strdupa(parent_path); /* Copy the parent onto the + * stack. + */ + + GF_FREE(parent_path); /* Free the allocated parent string */ + } out: - return auth_status_code; + return auth_status_code; } int -mnt3svc_mnt (rpcsvc_request_t *req) +mnt3svc_mnt(rpcsvc_request_t *req) { - struct iovec pvec = {0, }; - char path[MNTPATHLEN]; - int ret = -1; - struct mount3_state *ms = NULL; - mountstat3 mntstat = MNT3ERR_SERVERFAULT; - struct mnt3_export *exp = NULL; - struct nfs_state *nfs = NULL; - int authcode = 0; - - if (!req) - return -1; - - pvec.iov_base = path; - pvec.iov_len = MNTPATHLEN; - ret = xdr_to_mountpath (pvec, req->msg[0]); - if (ret == -1) { - gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Failed to decode args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } - - ms = (struct mount3_state *)rpcsvc_request_program_private (req); - if (!ms) { - gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, - NFS_MSG_MNT_STATE_NOT_FOUND, - "Mount state not present"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = -1; - goto rpcerr; - } - - nfs = (struct nfs_state *)ms->nfsx->private; - gf_msg_debug (GF_MNT, 0, "dirpath: %s", path); - ret = mnt3_find_export (req, path, &exp); - if (ret < 0) { - mntstat = mnt3svc_errno_to_mnterr (-ret); - goto mnterr; - } else if (!exp) { - /* - * SPECIAL CASE: exp is NULL if "path" is subdir in - * call to mnt3_find_export(). - * - * This is subdir mount, we are already DONE! - * nfs_subvolume_started() and mnt3_check_client_net_tcp() - * validation are done in mnt3_parse_dir_exports() - * which is invoked through mnt3_find_export(). - * - * TODO: All mount should happen thorugh mnt3svc_mount() - * It needs more clean up. - */ - return (0); - } - - if (!nfs_subvolume_started (nfs, exp->vol)) { - gf_msg_debug (GF_MNT, 0, "Volume %s not started", - exp->vol->name); - ret = -1; - mntstat = MNT3ERR_NOENT; - goto mnterr; - } - - ret = mnt3_check_client_net_tcp (req, exp->vol->name); - if (ret == RPCSVC_AUTH_REJECT) { - mntstat = MNT3ERR_ACCES; - gf_msg_debug (GF_MNT, 0, "Client mount not allowed"); - ret = -1; - goto mnterr; - } + struct iovec pvec = { + 0, + }; + char path[MNTPATHLEN]; + int ret = -1; + struct mount3_state *ms = NULL; + mountstat3 mntstat = MNT3ERR_SERVERFAULT; + struct mnt3_export *exp = NULL; + struct nfs_state *nfs = NULL; + int authcode = 0; + + if (!req) + return -1; - /* The second authentication check is the exports/netgroups - * check. + pvec.iov_base = path; + pvec.iov_len = MNTPATHLEN; + ret = xdr_to_mountpath(pvec, req->msg[0]); + if (ret == -1) { + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Failed to decode args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + ms = (struct mount3_state *)rpcsvc_request_program_private(req); + if (!ms) { + gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_MNT_STATE_NOT_FOUND, + "Mount state not present"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = -1; + goto rpcerr; + } + + nfs = (struct nfs_state *)ms->nfsx->private; + gf_msg_debug(GF_MNT, 0, "dirpath: %s", path); + ret = mnt3_find_export(req, path, &exp); + if (ret < 0) { + mntstat = mnt3svc_errno_to_mnterr(-ret); + goto mnterr; + } else if (!exp) { + /* + * SPECIAL CASE: exp is NULL if "path" is subdir in + * call to mnt3_find_export(). + * + * This is subdir mount, we are already DONE! + * nfs_subvolume_started() and mnt3_check_client_net_tcp() + * validation are done in mnt3_parse_dir_exports() + * which is invoked through mnt3_find_export(). + * + * TODO: All mount should happen thorugh mnt3svc_mount() + * It needs more clean up. */ - authcode = mnt3_authenticate_request (ms, req, NULL, NULL, path, NULL, - NULL, _gf_false); - if (authcode != 0) { - mntstat = MNT3ERR_ACCES; - gf_msg_debug (GF_MNT, 0, "Client mount not allowed"); - ret = -1; - goto mnterr; - } - - ret = mnt3svc_mount (req, ms, exp); - - if (ret < 0) - mntstat = mnt3svc_errno_to_mnterr (-ret); + return (0); + } + + if (!nfs_subvolume_started(nfs, exp->vol)) { + gf_msg_debug(GF_MNT, 0, "Volume %s not started", exp->vol->name); + ret = -1; + mntstat = MNT3ERR_NOENT; + goto mnterr; + } + + ret = mnt3_check_client_net_tcp(req, exp->vol->name); + if (ret == RPCSVC_AUTH_REJECT) { + mntstat = MNT3ERR_ACCES; + gf_msg_debug(GF_MNT, 0, "Client mount not allowed"); + ret = -1; + goto mnterr; + } + + /* The second authentication check is the exports/netgroups + * check. + */ + authcode = mnt3_authenticate_request(ms, req, NULL, NULL, path, NULL, NULL, + _gf_false); + if (authcode != 0) { + mntstat = MNT3ERR_ACCES; + gf_msg_debug(GF_MNT, 0, "Client mount not allowed"); + ret = -1; + goto mnterr; + } + + ret = mnt3svc_mount(req, ms, exp); + + if (ret < 0) + mntstat = mnt3svc_errno_to_mnterr(-ret); mnterr: - if (ret < 0) { - mnt3svc_mnt_error_reply (req, mntstat); - ret = 0; - } + if (ret < 0) { + mnt3svc_mnt_error_reply(req, mntstat); + ret = 0; + } rpcerr: - return ret; + return ret; } - int -mnt3svc_null (rpcsvc_request_t *req) +mnt3svc_null(rpcsvc_request_t *req) { - struct iovec dummyvec = {0, }; + struct iovec dummyvec = { + 0, + }; - if (!req) { - gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Got NULL request!"); - return 0; - } - rpcsvc_submit_generic (req, &dummyvec, 1, NULL, 0, NULL); + if (!req) { + gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Got NULL request!"); return 0; + } + rpcsvc_submit_generic(req, &dummyvec, 1, NULL, 0, NULL); + return 0; } - mountlist -__build_mountlist (struct mount3_state *ms, int *count) +__build_mountlist(struct mount3_state *ms, int *count) { - struct mountbody *mlist = NULL; - struct mountbody *prev = NULL; - struct mountbody *first = NULL; - size_t namelen = 0; - int ret = -1; - struct mountentry *me = NULL; - - if ((!ms) || (!count)) - return NULL; - - /* read rmtab, other peers might have updated it */ - mount_read_rmtab(ms); - - *count = 0; - gf_msg_debug (GF_MNT, 0, "Building mount list:"); - list_for_each_entry (me, &ms->mountlist, mlist) { - namelen = strlen (me->exname); - mlist = GF_CALLOC (1, sizeof (*mlist), gf_nfs_mt_mountbody); - if (!mlist) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, - NFS_MSG_NO_MEMORY, "Memory allocation failed"); - goto free_list; - } - if (!first) - first = mlist; - - mlist->ml_directory = GF_MALLOC (namelen + 2, - gf_nfs_mt_char); - if (!mlist->ml_directory) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, - NFS_MSG_NO_MEMORY, "Memory allocation failed"); - goto free_list; - } + struct mountbody *mlist = NULL; + struct mountbody *prev = NULL; + struct mountbody *first = NULL; + size_t namelen = 0; + int ret = -1; + struct mountentry *me = NULL; + + if ((!ms) || (!count)) + return NULL; - strcpy (mlist->ml_directory, me->exname); + /* read rmtab, other peers might have updated it */ + mount_read_rmtab(ms); - namelen = strlen (me->hostname); - mlist->ml_hostname = GF_MALLOC (namelen + 2, - gf_nfs_mt_char); - if (!mlist->ml_hostname) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, - NFS_MSG_NO_MEMORY, "Memory allocation failed"); - goto free_list; - } + *count = 0; + gf_msg_debug(GF_MNT, 0, "Building mount list:"); + list_for_each_entry(me, &ms->mountlist, mlist) + { + namelen = strlen(me->exname); + mlist = GF_CALLOC(1, sizeof(*mlist), gf_nfs_mt_mountbody); + if (!mlist) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); + goto free_list; + } + if (!first) + first = mlist; - strcat (mlist->ml_hostname, me->hostname); + mlist->ml_directory = GF_MALLOC(namelen + 2, gf_nfs_mt_char); + if (!mlist->ml_directory) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); + goto free_list; + } - gf_msg_debug (GF_MNT, 0, "mount entry: dir: %s, host: %s", - mlist->ml_directory, mlist->ml_hostname); - if (prev) { - prev->ml_next = mlist; - prev = mlist; - } else - prev = mlist; + strcpy(mlist->ml_directory, me->exname); - (*count)++; + namelen = strlen(me->hostname); + mlist->ml_hostname = GF_MALLOC(namelen + 2, gf_nfs_mt_char); + if (!mlist->ml_hostname) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); + goto free_list; } - ret = 0; + strcat(mlist->ml_hostname, me->hostname); + + gf_msg_debug(GF_MNT, 0, "mount entry: dir: %s, host: %s", + mlist->ml_directory, mlist->ml_hostname); + if (prev) { + prev->ml_next = mlist; + prev = mlist; + } else + prev = mlist; + + (*count)++; + } + + ret = 0; free_list: - if (ret == -1) { - xdr_free_mountlist (first); - first = NULL; - } + if (ret == -1) { + xdr_free_mountlist(first); + first = NULL; + } - return first; + return first; } - mountlist -mnt3svc_build_mountlist (struct mount3_state *ms, int *count) +mnt3svc_build_mountlist(struct mount3_state *ms, int *count) { - struct mountbody *first = NULL; + struct mountbody *first = NULL; - LOCK (&ms->mountlock); - { - first = __build_mountlist (ms, count); - } - UNLOCK (&ms->mountlock); + LOCK(&ms->mountlock); + { + first = __build_mountlist(ms, count); + } + UNLOCK(&ms->mountlock); - return first; + return first; } - int -mnt3svc_dump (rpcsvc_request_t *req) +mnt3svc_dump(rpcsvc_request_t *req) { - int ret = -1; - struct mount3_state *ms = NULL; - mountlist mlist; - mountstat3 mstat = 0; - mnt3_serializer sfunc = NULL; - void *arg = NULL; - - - if (!req) - return -1; + int ret = -1; + struct mount3_state *ms = NULL; + mountlist mlist; + mountstat3 mstat = 0; + mnt3_serializer sfunc = NULL; + void *arg = NULL; + + if (!req) + return -1; - ms = (struct mount3_state *)rpcsvc_request_program_private (req); - if (!ms) { - rpcsvc_request_seterr (req, SYSTEM_ERR); - goto rpcerr; - } + ms = (struct mount3_state *)rpcsvc_request_program_private(req); + if (!ms) { + rpcsvc_request_seterr(req, SYSTEM_ERR); + goto rpcerr; + } - sfunc = (mnt3_serializer)xdr_serialize_mountlist; - mlist = mnt3svc_build_mountlist (ms, &ret); - arg = &mlist; + sfunc = (mnt3_serializer)xdr_serialize_mountlist; + mlist = mnt3svc_build_mountlist(ms, &ret); + arg = &mlist; - if (!mlist) { - if (ret != 0) { - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = -1; - goto rpcerr; - } else { - arg = &mstat; - sfunc = (mnt3_serializer)xdr_serialize_mountstat3; - } + if (!mlist) { + if (ret != 0) { + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = -1; + goto rpcerr; + } else { + arg = &mstat; + sfunc = (mnt3_serializer)xdr_serialize_mountstat3; } + } - mnt3svc_submit_reply (req, arg, sfunc); + mnt3svc_submit_reply(req, arg, sfunc); - xdr_free_mountlist (mlist); - ret = 0; + xdr_free_mountlist(mlist); + ret = 0; rpcerr: - return ret; + return ret; } - int -mnt3svc_umount (struct mount3_state *ms, char *dirpath, char *hostname) +mnt3svc_umount(struct mount3_state *ms, char *dirpath, char *hostname) { - struct mountentry *me = NULL; - int ret = -1; - gf_store_handle_t *sh = NULL; - struct nfs_state *nfs = NULL; - gf_boolean_t update_rmtab = _gf_false; - - if ((!ms) || (!dirpath) || (!hostname)) - return -1; - - nfs = (struct nfs_state *)ms->nfsx->private; - - update_rmtab = mount_open_rmtab (nfs->rmtab, &sh); - if (update_rmtab) { - ret = gf_store_lock (sh); - if (ret) - goto out_free; - } - - LOCK (&ms->mountlock); - { - if (update_rmtab) - __mount_read_rmtab (sh, &ms->mountlist, _gf_false); + struct mountentry *me = NULL; + int ret = -1; + gf_store_handle_t *sh = NULL; + struct nfs_state *nfs = NULL; + gf_boolean_t update_rmtab = _gf_false; - if (list_empty (&ms->mountlist)) { - ret = 0; - goto out_unlock; - } + if ((!ms) || (!dirpath) || (!hostname)) + return -1; - ret = -1; - list_for_each_entry (me, &ms->mountlist, mlist) { - if ((strcmp (me->exname, dirpath) == 0) && - (strcmp (me->hostname, hostname) == 0)) { - ret = 0; - break; - } - } + nfs = (struct nfs_state *)ms->nfsx->private; - /* Need this check here because at the end of the search me - * might still be pointing to the last entry, which may not be - * the one we're looking for. - */ - if (ret == -1) {/* Not found in list. */ - gf_msg_trace (GF_MNT, 0, "Export not found"); - goto out_unlock; - } + update_rmtab = mount_open_rmtab(nfs->rmtab, &sh); + if (update_rmtab) { + ret = gf_store_lock(sh); + if (ret) + goto out_free; + } - if (!me) - goto out_unlock; + LOCK(&ms->mountlock); + { + if (update_rmtab) + __mount_read_rmtab(sh, &ms->mountlist, _gf_false); - gf_msg_debug (GF_MNT, 0, "Unmounting: dir %s, host: %s", - me->exname, me->hostname); + if (list_empty(&ms->mountlist)) { + ret = 0; + goto out_unlock; + } - list_del (&me->mlist); - GF_FREE (me); + ret = -1; + list_for_each_entry(me, &ms->mountlist, mlist) + { + if ((strcmp(me->exname, dirpath) == 0) && + (strcmp(me->hostname, hostname) == 0)) { + ret = 0; + break; + } + } - if (update_rmtab) - __mount_rewrite_rmtab (ms, sh); + /* Need this check here because at the end of the search me + * might still be pointing to the last entry, which may not be + * the one we're looking for. + */ + if (ret == -1) { /* Not found in list. */ + gf_msg_trace(GF_MNT, 0, "Export not found"); + goto out_unlock; } -out_unlock: - UNLOCK (&ms->mountlock); + + if (!me) + goto out_unlock; + + gf_msg_debug(GF_MNT, 0, "Unmounting: dir %s, host: %s", me->exname, + me->hostname); + + list_del(&me->mlist); + GF_FREE(me); if (update_rmtab) - gf_store_unlock (sh); + __mount_rewrite_rmtab(ms, sh); + } +out_unlock: + UNLOCK(&ms->mountlock); + + if (update_rmtab) + gf_store_unlock(sh); out_free: - if (update_rmtab) - gf_store_handle_destroy (sh); + if (update_rmtab) + gf_store_handle_destroy(sh); - return ret; + return ret; } - int -mnt3svc_umnt (rpcsvc_request_t *req) +mnt3svc_umnt(rpcsvc_request_t *req) { - char hostname[MNTPATHLEN]; - char dirpath[MNTPATHLEN]; - struct iovec pvec = {0, }; - int ret = -1; - struct mount3_state *ms = NULL; - mountstat3 mstat = MNT3_OK; - char *colon = NULL; - - if (!req) - return -1; - - /* Remove the mount point from the exports list. */ - pvec.iov_base = dirpath; - pvec.iov_len = MNTPATHLEN; - ret = xdr_to_mountpath (pvec, req->msg[0]); - if (ret == -1) { - gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Failed decode args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } - - ms = (struct mount3_state *)rpcsvc_request_program_private (req); - if (!ms) { - gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, - NFS_MSG_MNT_STATE_NOT_FOUND, "Mount state not present"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = -1; - goto rpcerr; - } - - ret = rpcsvc_transport_peername (req->trans, hostname, MNTPATHLEN); - if (ret != 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOENT, - NFS_MSG_GET_REMOTE_NAME_FAIL, - "Failed to get remote name: %s", gai_strerror (ret)); - goto rpcerr; - } + char hostname[MNTPATHLEN]; + char dirpath[MNTPATHLEN]; + struct iovec pvec = { + 0, + }; + int ret = -1; + struct mount3_state *ms = NULL; + mountstat3 mstat = MNT3_OK; + char *colon = NULL; + + if (!req) + return -1; - colon = strrchr (hostname, ':'); - if (colon) { - *colon= '\0'; - } - gf_path_strip_trailing_slashes (dirpath); - gf_msg_debug (GF_MNT, 0, "dirpath: %s, hostname: %s", dirpath, - hostname); - ret = mnt3svc_umount (ms, dirpath, hostname); + /* Remove the mount point from the exports list. */ + pvec.iov_base = dirpath; + pvec.iov_len = MNTPATHLEN; + ret = xdr_to_mountpath(pvec, req->msg[0]); + if (ret == -1) { + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Failed decode args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + ms = (struct mount3_state *)rpcsvc_request_program_private(req); + if (!ms) { + gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_MNT_STATE_NOT_FOUND, + "Mount state not present"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = -1; + goto rpcerr; + } + + ret = rpcsvc_transport_peername(req->trans, hostname, MNTPATHLEN); + if (ret != 0) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOENT, NFS_MSG_GET_REMOTE_NAME_FAIL, + "Failed to get remote name: %s", gai_strerror(ret)); + goto rpcerr; + } + + colon = strrchr(hostname, ':'); + if (colon) { + *colon = '\0'; + } + gf_path_strip_trailing_slashes(dirpath); + gf_msg_debug(GF_MNT, 0, "dirpath: %s, hostname: %s", dirpath, hostname); + ret = mnt3svc_umount(ms, dirpath, hostname); - if (ret == -1) { - ret = 0; - mstat = MNT3ERR_NOENT; - } - /* FIXME: also take care of the corner case where the - * client was resolvable at mount but not at the umount - vice-versa. - */ - mnt3svc_submit_reply (req, &mstat, - (mnt3_serializer)xdr_serialize_mountstat3); + if (ret == -1) { + ret = 0; + mstat = MNT3ERR_NOENT; + } + /* FIXME: also take care of the corner case where the + * client was resolvable at mount but not at the umount - vice-versa. + */ + mnt3svc_submit_reply(req, &mstat, + (mnt3_serializer)xdr_serialize_mountstat3); rpcerr: - return ret; + return ret; } - int -__mnt3svc_umountall (struct mount3_state *ms) +__mnt3svc_umountall(struct mount3_state *ms) { - struct mountentry *me = NULL; - struct mountentry *tmp = NULL; + struct mountentry *me = NULL; + struct mountentry *tmp = NULL; - if (!ms) - return -1; + if (!ms) + return -1; - if (list_empty (&ms->mountlist)) - return 0; + if (list_empty(&ms->mountlist)) + return 0; - list_for_each_entry_safe (me, tmp, &ms->mountlist, mlist) { - list_del (&me->mlist); /* Remove from the mount list */ - __mountdict_remove (ms, me); /* Remove from the mount dict */ - GF_FREE (me); - } + list_for_each_entry_safe(me, tmp, &ms->mountlist, mlist) + { + list_del(&me->mlist); /* Remove from the mount list */ + __mountdict_remove(ms, me); /* Remove from the mount dict */ + GF_FREE(me); + } - return 0; + return 0; } - int -mnt3svc_umountall (struct mount3_state *ms) +mnt3svc_umountall(struct mount3_state *ms) { - int ret = -1; - if (!ms) - return -1; + int ret = -1; + if (!ms) + return -1; - LOCK (&ms->mountlock); - { - ret = __mnt3svc_umountall (ms); - } - UNLOCK (&ms->mountlock); + LOCK(&ms->mountlock); + { + ret = __mnt3svc_umountall(ms); + } + UNLOCK(&ms->mountlock); - return ret; + return ret; } - int -mnt3svc_umntall (rpcsvc_request_t *req) +mnt3svc_umntall(rpcsvc_request_t *req) { - int ret = RPCSVC_ACTOR_ERROR; - struct mount3_state *ms = NULL; - mountstat3 mstat = MNT3_OK; - - if (!req) - return ret; - - ms = (struct mount3_state *)rpcsvc_request_program_private (req); - if (!ms) { - gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, - NFS_MSG_MNT_STATE_NOT_FOUND, "Mount state not present"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - goto rpcerr; - } + int ret = RPCSVC_ACTOR_ERROR; + struct mount3_state *ms = NULL; + mountstat3 mstat = MNT3_OK; + + if (!req) + return ret; + + ms = (struct mount3_state *)rpcsvc_request_program_private(req); + if (!ms) { + gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_MNT_STATE_NOT_FOUND, + "Mount state not present"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + goto rpcerr; + } - mnt3svc_umountall (ms); - mnt3svc_submit_reply (req, &mstat, - (mnt3_serializer)xdr_serialize_mountstat3); + mnt3svc_umountall(ms); + mnt3svc_submit_reply(req, &mstat, + (mnt3_serializer)xdr_serialize_mountstat3); - ret = RPCSVC_ACTOR_SUCCESS; + ret = RPCSVC_ACTOR_SUCCESS; rpcerr: - return ret; + return ret; } - exports -mnt3_xlchildren_to_exports (rpcsvc_t *svc, struct mount3_state *ms) +mnt3_xlchildren_to_exports(rpcsvc_t *svc, struct mount3_state *ms) { - struct exportnode *elist = NULL; - struct exportnode *prev = NULL; - struct exportnode *first = NULL; - size_t namelen = 0; - int ret = -1; - char *addrstr = NULL; - struct mnt3_export *ent = NULL; - struct nfs_state *nfs = NULL; - - if ((!ms) || (!svc)) - return NULL; - - nfs = (struct nfs_state *)ms->nfsx->private; - if (!nfs) - return NULL; - - LOCK (&ms->mountlock); - list_for_each_entry(ent, &ms->exportlist, explist) { - - /* If volume is not started yet, do not list it for tools like - * showmount. - */ - if (!nfs_subvolume_started (nfs, ent->vol)) - continue; - - elist = GF_CALLOC (1, sizeof (*elist), gf_nfs_mt_exportnode); - if (!elist) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, - NFS_MSG_NO_MEMORY, "Memory allocation failed"); - goto free_list; - } - if (!first) - first = elist; - namelen = strlen (ent->expname); - elist->ex_dir = GF_MALLOC (namelen + 2, - gf_nfs_mt_char); - if (!elist->ex_dir) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, - NFS_MSG_NO_MEMORY, "Memory allocation failed"); - goto free_list; + struct exportnode *elist = NULL; + struct exportnode *prev = NULL; + struct exportnode *first = NULL; + size_t namelen = 0; + int ret = -1; + char *addrstr = NULL; + struct mnt3_export *ent = NULL; + struct nfs_state *nfs = NULL; + + if ((!ms) || (!svc)) + return NULL; + + nfs = (struct nfs_state *)ms->nfsx->private; + if (!nfs) + return NULL; + + LOCK(&ms->mountlock); + list_for_each_entry(ent, &ms->exportlist, explist) + { + /* If volume is not started yet, do not list it for tools like + * showmount. + */ + if (!nfs_subvolume_started(nfs, ent->vol)) + continue; + + elist = GF_CALLOC(1, sizeof(*elist), gf_nfs_mt_exportnode); + if (!elist) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); + goto free_list; + } + if (!first) + first = elist; + namelen = strlen(ent->expname); + elist->ex_dir = GF_MALLOC(namelen + 2, gf_nfs_mt_char); + if (!elist->ex_dir) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); + goto free_list; + } + strcpy(elist->ex_dir, ent->expname); + + addrstr = rpcsvc_volume_allowed(svc->options, ent->vol->name); + if (addrstr) { + /* create a groupnode per allowed client */ + char *pos = NULL; + char *addr = NULL; + char *addrs = NULL; + struct groupnode *group = NULL; + struct groupnode *prev_group = NULL; + + /* strtok_r() modifies the string, dup it */ + addrs = gf_strdup(addrstr); + if (!addrs) + goto free_list; + + while (1) { + /* only pass addrs on the 1st call */ + addr = strtok_r(group ? NULL : addrs, ",", &pos); + if (addr == NULL) + /* no mode clients */ + break; + + group = GF_CALLOC(1, sizeof(struct groupnode), + gf_nfs_mt_groupnode); + if (!group) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory " + "allocation failed"); + GF_FREE(addrs); + goto free_list; } - strcpy (elist->ex_dir, ent->expname); - - addrstr = rpcsvc_volume_allowed (svc->options, ent->vol->name); - if (addrstr) { - /* create a groupnode per allowed client */ - char *pos = NULL; - char *addr = NULL; - char *addrs = NULL; - struct groupnode *group = NULL; - struct groupnode *prev_group = NULL; - - /* strtok_r() modifies the string, dup it */ - addrs = gf_strdup (addrstr); - if (!addrs) - goto free_list; - - while (1) { - /* only pass addrs on the 1st call */ - addr = strtok_r (group ? NULL : addrs, ",", - &pos); - if (addr == NULL) - /* no mode clients */ - break; - - group = GF_CALLOC (1, sizeof (struct groupnode), - gf_nfs_mt_groupnode); - if (!group) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, - NFS_MSG_NO_MEMORY, "Memory " - "allocation failed"); - GF_FREE (addrs); - goto free_list; - } - - group->gr_name = gf_strdup (addr); - if (!group->gr_name) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, - NFS_MSG_NO_MEMORY, "Memory " - "allocation failed"); - GF_FREE (group); - GF_FREE (addrs); - goto free_list; - } - - /* chain the groups together */ - if (!elist->ex_groups) - elist->ex_groups = group; - else if (!prev_group->gr_next) - prev_group->gr_next = group; - prev_group = group; - } - - GF_FREE (addrs); - } else { - elist->ex_groups = GF_CALLOC (1, - sizeof (struct groupnode), - gf_nfs_mt_groupnode); - if (!elist->ex_groups) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, - NFS_MSG_NO_MEMORY, "Memory allocation " - "failed"); - goto free_list; - } - - addrstr = gf_strdup ("No Access"); - if (!addrstr) - goto free_list; - - elist->ex_groups->gr_name = addrstr; + + group->gr_name = gf_strdup(addr); + if (!group->gr_name) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory " + "allocation failed"); + GF_FREE(group); + GF_FREE(addrs); + goto free_list; } - if (prev) { - prev->ex_next = elist; - prev = elist; - } else - prev = elist; + /* chain the groups together */ + if (!elist->ex_groups) + elist->ex_groups = group; + else if (!prev_group->gr_next) + prev_group->gr_next = group; + prev_group = group; + } + + GF_FREE(addrs); + } else { + elist->ex_groups = GF_CALLOC(1, sizeof(struct groupnode), + gf_nfs_mt_groupnode); + if (!elist->ex_groups) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation " + "failed"); + goto free_list; + } + + addrstr = gf_strdup("No Access"); + if (!addrstr) + goto free_list; + + elist->ex_groups->gr_name = addrstr; } - ret = 0; + if (prev) { + prev->ex_next = elist; + prev = elist; + } else + prev = elist; + } + + ret = 0; free_list: - UNLOCK (&ms->mountlock); - if (ret == -1) { - xdr_free_exports_list (first); - first = NULL; - } + UNLOCK(&ms->mountlock); + if (ret == -1) { + xdr_free_exports_list(first); + first = NULL; + } - return first; + return first; } - int -mnt3svc_export (rpcsvc_request_t *req) +mnt3svc_export(rpcsvc_request_t *req) { - struct mount3_state *ms = NULL; - exports elist = NULL; - int ret = -1; - - if (!req) - return -1; - - ms = (struct mount3_state *)rpcsvc_request_program_private (req); - if (!ms) { - gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, - NFS_MSG_MNT_STATE_NOT_FOUND, "mount state not found"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - goto err; - } + struct mount3_state *ms = NULL; + exports elist = NULL; + int ret = -1; - /* Using the children translator names, build the export list */ - elist = mnt3_xlchildren_to_exports (rpcsvc_request_service (req), - ms); - /* Do not return error when exports list is empty. An exports list can - * be empty when no subvolumes have come up. No point returning error - * and confusing the user. - if (!elist) { - gf_log (GF_MNT, GF_LOG_ERROR, "Failed to build exports list"); - nfs_rpcsvc_request_seterr (req, SYSTEM_ERR); - goto err; - } - */ - - /* Note how the serializer is passed to the generic reply function. */ - mnt3svc_submit_reply (req, &elist, - (mnt3_serializer)xdr_serialize_exports); + if (!req) + return -1; - xdr_free_exports_list (elist); - ret = 0; + ms = (struct mount3_state *)rpcsvc_request_program_private(req); + if (!ms) { + gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_MNT_STATE_NOT_FOUND, + "mount state not found"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + goto err; + } + + /* Using the children translator names, build the export list */ + elist = mnt3_xlchildren_to_exports(rpcsvc_request_service(req), ms); + /* Do not return error when exports list is empty. An exports list can + * be empty when no subvolumes have come up. No point returning error + * and confusing the user. + if (!elist) { + gf_log (GF_MNT, GF_LOG_ERROR, "Failed to build exports list"); + nfs_rpcsvc_request_seterr (req, SYSTEM_ERR); + goto err; + } + */ + + /* Note how the serializer is passed to the generic reply function. */ + mnt3svc_submit_reply(req, &elist, (mnt3_serializer)xdr_serialize_exports); + + xdr_free_exports_list(elist); + ret = 0; err: - return ret; + return ret; } - /* * __mnt3udp_get_mstate() Fetches mount3_state from xlator * Linkage: Static * Usage: Used only for UDP MOUNT codepath */ static struct mount3_state * -__mnt3udp_get_mstate (xlator_t *nfsx) +__mnt3udp_get_mstate(xlator_t *nfsx) { - struct nfs_state *nfs = NULL; - struct mount3_state *ms = NULL; + struct nfs_state *nfs = NULL; + struct mount3_state *ms = NULL; - if (nfsx == NULL) - return NULL; + if (nfsx == NULL) + return NULL; - nfs = (struct nfs_state *)nfsx->private; - if (nfs == NULL) - return NULL; + nfs = (struct nfs_state *)nfsx->private; + if (nfs == NULL) + return NULL; - ms = (struct mount3_state *)nfs->mstate; - return ms; + ms = (struct mount3_state *)nfs->mstate; + return ms; } extern int -glfs_resolve_at (struct glfs *, xlator_t *, inode_t *, - const char *, loc_t *, struct iatt *, int, int); +glfs_resolve_at(struct glfs *, xlator_t *, inode_t *, const char *, loc_t *, + struct iatt *, int, int); extern struct glfs * -glfs_new_from_ctx (glusterfs_ctx_t *); +glfs_new_from_ctx(glusterfs_ctx_t *); extern void -glfs_free_from_ctx (struct glfs *); +glfs_free_from_ctx(struct glfs *); static inode_t * -__mnt3udp_get_export_subdir_inode (struct svc_req *req, char *subdir, - char *expname, /* OUT */ - struct mnt3_export *exp) +__mnt3udp_get_export_subdir_inode(struct svc_req *req, char *subdir, + char *expname, /* OUT */ + struct mnt3_export *exp) { - inode_t *inode = NULL; - loc_t loc = {0, }; - struct iatt buf = {0, }; - int ret = -1; - glfs_t *fs = NULL; - - if ((!req) || (!subdir) || (!expname) || (!exp)) - return NULL; + inode_t *inode = NULL; + loc_t loc = { + 0, + }; + struct iatt buf = { + 0, + }; + int ret = -1; + glfs_t *fs = NULL; + + if ((!req) || (!subdir) || (!expname) || (!exp)) + return NULL; - /* AUTH check for subdir i.e. nfs.export-dir */ - if (exp->hostspec) { - struct sockaddr_in *sin = NULL; + /* AUTH check for subdir i.e. nfs.export-dir */ + if (exp->hostspec) { + struct sockaddr_in *sin = NULL; #if !defined(_TIRPC_SVC_H) - sin = svc_getcaller (req->rq_xprt); + sin = svc_getcaller(req->rq_xprt); #else - sin = (struct sockaddr_in *)svc_getcaller (req->rq_xprt); - /* TIRPC's svc_getcaller() returns a pointer to a - * sockaddr_in6, even though it might actually be an - * IPv4 address. It ought return a struct sockaddr and - * make the caller upcast it to the proper address family. - */ + sin = (struct sockaddr_in *)svc_getcaller(req->rq_xprt); + /* TIRPC's svc_getcaller() returns a pointer to a + * sockaddr_in6, even though it might actually be an + * IPv4 address. It ought return a struct sockaddr and + * make the caller upcast it to the proper address family. + */ #endif - /* And let's make sure that it's actually an IPv4 address. */ - GF_ASSERT (sin->sin_family == AF_INET); - - ret = mnt3_verify_auth (sin, exp); - if (ret) { - gf_msg (GF_MNT, GF_LOG_ERROR, EACCES, - NFS_MSG_AUTH_VERIFY_FAILED, - "AUTH(nfs.export-dir) verification failed"); - errno = EACCES; - return NULL; - } - } + /* And let's make sure that it's actually an IPv4 address. */ + GF_ASSERT(sin->sin_family == AF_INET); - /* - * IMP: glfs_t fs object is not used by glfs_resolve_at (). The main - * purpose is to not change the ABI of glfs_resolve_at () and not to - * pass a NULL object. - * - * TODO: Instead of linking against libgfapi.so, just for one API - * i.e. glfs_resolve_at(), It would be cleaner if PATH name to - * inode resolution code can be moved to libglusterfs.so or so. - * refer bugzilla for more details : - * https://bugzilla.redhat.com/show_bug.cgi?id=1161573 - */ - fs = glfs_new_from_ctx (exp->vol->ctx); - if (!fs) - return NULL; + ret = mnt3_verify_auth(sin, exp); + if (ret) { + gf_msg(GF_MNT, GF_LOG_ERROR, EACCES, NFS_MSG_AUTH_VERIFY_FAILED, + "AUTH(nfs.export-dir) verification failed"); + errno = EACCES; + return NULL; + } + } + + /* + * IMP: glfs_t fs object is not used by glfs_resolve_at (). The main + * purpose is to not change the ABI of glfs_resolve_at () and not to + * pass a NULL object. + * + * TODO: Instead of linking against libgfapi.so, just for one API + * i.e. glfs_resolve_at(), It would be cleaner if PATH name to + * inode resolution code can be moved to libglusterfs.so or so. + * refer bugzilla for more details : + * https://bugzilla.redhat.com/show_bug.cgi?id=1161573 + */ + fs = glfs_new_from_ctx(exp->vol->ctx); + if (!fs) + return NULL; - ret = glfs_resolve_at (fs, exp->vol, NULL, subdir, - &loc, &buf, 1 /* Follow link */, - 0 /* Hard lookup */); + ret = glfs_resolve_at(fs, exp->vol, NULL, subdir, &loc, &buf, + 1 /* Follow link */, 0 /* Hard lookup */); - glfs_free_from_ctx (fs); + glfs_free_from_ctx(fs); - if (ret != 0) { - loc_wipe (&loc); - return NULL; - } + if (ret != 0) { + loc_wipe(&loc); + return NULL; + } - inode = inode_ref (loc.inode); - snprintf (expname, PATH_MAX, "/%s%s", exp->vol->name, loc.path); + inode = inode_ref(loc.inode); + snprintf(expname, PATH_MAX, "/%s%s", exp->vol->name, loc.path); - loc_wipe (&loc); + loc_wipe(&loc); - return inode; + return inode; } static inode_t * -__mnt3udp_get_export_volume_inode (struct svc_req *req, char *volpath, - char *expname, /* OUT */ - struct mnt3_export *exp) +__mnt3udp_get_export_volume_inode(struct svc_req *req, char *volpath, + char *expname, /* OUT */ + struct mnt3_export *exp) { - char *rpath = NULL; - inode_t *inode = NULL; + char *rpath = NULL; + inode_t *inode = NULL; - if ((!req) || (!volpath) || (!expname) || (!exp)) - return NULL; + if ((!req) || (!volpath) || (!expname) || (!exp)) + return NULL; - rpath = strchr (volpath, '/'); - if (rpath == NULL) - rpath = "/"; + rpath = strchr(volpath, '/'); + if (rpath == NULL) + rpath = "/"; - inode = inode_from_path (exp->vol->itable, rpath); - snprintf (expname, PATH_MAX, "/%s", exp->vol->name); + inode = inode_from_path(exp->vol->itable, rpath); + snprintf(expname, PATH_MAX, "/%s", exp->vol->name); - return inode; + return inode; } /* @@ -2943,162 +2929,161 @@ __mnt3udp_get_export_volume_inode (struct svc_req *req, char *volpath, * when nfs.mount-udp is ENABLED (set to TRUE/ON). */ struct nfs3_fh * -nfs3_rootfh (struct svc_req *req, xlator_t *nfsx, - char *path, char *expname /* OUT */) +nfs3_rootfh(struct svc_req *req, xlator_t *nfsx, char *path, + char *expname /* OUT */) { - struct nfs3_fh *fh = NULL; - inode_t *inode = NULL; - struct mnt3_export *exp = NULL; - struct mount3_state *ms = NULL; - struct nfs_state *nfs = NULL; - int mnt3type = MNT3_EXPTYPE_DIR; - int ret = RPCSVC_AUTH_REJECT; - - if ((!req) || (!nfsx) || (!path) || (!expname)) { - errno = EFAULT; - return NULL; - } - - /* - * 1. First check if the MOUNT is for whole volume. - * i.e. __mnt3udp_get_export_volume_inode () - * 2. If NOT, then TRY for SUBDIR MOUNT. - * i.e. __mnt3udp_get_export_subdir_inode () - * 3. If a subdir is exported using nfs.export-dir, - * then the mount type would be MNT3_EXPTYPE_DIR, - * so make sure to find the proper path to be - * resolved using mnt3_get_volume_subdir() - * 3. Make sure subdir export is allowed. - */ - ms = __mnt3udp_get_mstate(nfsx); - if (!ms) { - errno = EFAULT; - return NULL; - } - - exp = mnt3_mntpath_to_export (ms, path , _gf_false); - if (exp != NULL) - mnt3type = exp->exptype; + struct nfs3_fh *fh = NULL; + inode_t *inode = NULL; + struct mnt3_export *exp = NULL; + struct mount3_state *ms = NULL; + struct nfs_state *nfs = NULL; + int mnt3type = MNT3_EXPTYPE_DIR; + int ret = RPCSVC_AUTH_REJECT; + + if ((!req) || (!nfsx) || (!path) || (!expname)) { + errno = EFAULT; + return NULL; + } + + /* + * 1. First check if the MOUNT is for whole volume. + * i.e. __mnt3udp_get_export_volume_inode () + * 2. If NOT, then TRY for SUBDIR MOUNT. + * i.e. __mnt3udp_get_export_subdir_inode () + * 3. If a subdir is exported using nfs.export-dir, + * then the mount type would be MNT3_EXPTYPE_DIR, + * so make sure to find the proper path to be + * resolved using mnt3_get_volume_subdir() + * 3. Make sure subdir export is allowed. + */ + ms = __mnt3udp_get_mstate(nfsx); + if (!ms) { + errno = EFAULT; + return NULL; + } - if (mnt3type == MNT3_EXPTYPE_DIR) { - char volname [MNTPATHLEN] = {0, }; - char *volptr = volname; + exp = mnt3_mntpath_to_export(ms, path, _gf_false); + if (exp != NULL) + mnt3type = exp->exptype; - /* Subdir export (nfs3.export-dirs) check */ - if (!gf_mnt3_export_dirs(ms)) { - errno = EACCES; - return NULL; - } + if (mnt3type == MNT3_EXPTYPE_DIR) { + char volname[MNTPATHLEN] = { + 0, + }; + char *volptr = volname; - path = mnt3_get_volume_subdir (path, &volptr); - if (exp == NULL) - exp = mnt3_mntpath_to_export (ms, volname , _gf_false); + /* Subdir export (nfs3.export-dirs) check */ + if (!gf_mnt3_export_dirs(ms)) { + errno = EACCES; + return NULL; } - if (exp == NULL) { - errno = ENOENT; - return NULL; - } + path = mnt3_get_volume_subdir(path, &volptr); + if (exp == NULL) + exp = mnt3_mntpath_to_export(ms, volname, _gf_false); + } - nfs = (struct nfs_state *)nfsx->private; - if (!nfs_subvolume_started (nfs, exp->vol)) { - errno = ENOENT; - return NULL; - } + if (exp == NULL) { + errno = ENOENT; + return NULL; + } - /* AUTH check: respect nfs.rpc-auth-allow/reject */ - ret = mnt3_check_client_net_udp (req, exp->vol->name, nfsx); - if (ret == RPCSVC_AUTH_REJECT) { - errno = EACCES; - return NULL; - } + nfs = (struct nfs_state *)nfsx->private; + if (!nfs_subvolume_started(nfs, exp->vol)) { + errno = ENOENT; + return NULL; + } - switch (mnt3type) { + /* AUTH check: respect nfs.rpc-auth-allow/reject */ + ret = mnt3_check_client_net_udp(req, exp->vol->name, nfsx); + if (ret == RPCSVC_AUTH_REJECT) { + errno = EACCES; + return NULL; + } + switch (mnt3type) { case MNT3_EXPTYPE_VOLUME: - inode = __mnt3udp_get_export_volume_inode (req, path, - expname, exp); - break; + inode = __mnt3udp_get_export_volume_inode(req, path, expname, exp); + break; case MNT3_EXPTYPE_DIR: - inode = __mnt3udp_get_export_subdir_inode (req, path, - expname, exp); - break; + inode = __mnt3udp_get_export_subdir_inode(req, path, expname, exp); + break; default: - /* Never reachable */ - gf_msg (GF_MNT, GF_LOG_ERROR, EFAULT, NFS_MSG_UNKNOWN_MNT_TYPE, - "Unknown MOUNT3 type"); - errno = EFAULT; - goto err; - } - - if (inode == NULL) { - /* Don't over-write errno */ - if (!errno) - errno = ENOENT; - goto err; - } - - /* Build the inode from FH */ - fh = GF_CALLOC (1, sizeof(*fh), gf_nfs_mt_nfs3_fh); - if (fh == NULL) { - errno = ENOMEM; - goto err; - } - - (void) nfs3_build_fh (inode, exp->volumeid, fh); + /* Never reachable */ + gf_msg(GF_MNT, GF_LOG_ERROR, EFAULT, NFS_MSG_UNKNOWN_MNT_TYPE, + "Unknown MOUNT3 type"); + errno = EFAULT; + goto err; + } + + if (inode == NULL) { + /* Don't over-write errno */ + if (!errno) + errno = ENOENT; + goto err; + } + + /* Build the inode from FH */ + fh = GF_CALLOC(1, sizeof(*fh), gf_nfs_mt_nfs3_fh); + if (fh == NULL) { + errno = ENOMEM; + goto err; + } + + (void)nfs3_build_fh(inode, exp->volumeid, fh); err: - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - return fh; + return fh; } int -mount3udp_add_mountlist (xlator_t *nfsx, char *host, char *export) +mount3udp_add_mountlist(xlator_t *nfsx, char *host, char *export) { - struct mountentry *me = NULL; - struct mount3_state *ms = NULL; + struct mountentry *me = NULL; + struct mount3_state *ms = NULL; - if ((!host) || (!export) || (!nfsx)) - return -1; + if ((!host) || (!export) || (!nfsx)) + return -1; - ms = __mnt3udp_get_mstate (nfsx); - if (!ms) - return -1; + ms = __mnt3udp_get_mstate(nfsx); + if (!ms) + return -1; - me = GF_CALLOC (1, sizeof (*me), gf_nfs_mt_mountentry); - if (!me) - return -1; + me = GF_CALLOC(1, sizeof(*me), gf_nfs_mt_mountentry); + if (!me) + return -1; - snprintf (me->exname, MNTPATHLEN, "%s", export); - snprintf (me->hostname, MNTPATHLEN, "%s", host); - INIT_LIST_HEAD (&me->mlist); - LOCK (&ms->mountlock); - { - list_add_tail (&me->mlist, &ms->mountlist); - mount_rewrite_rmtab(ms, NULL); - } - UNLOCK (&ms->mountlock); - return 0; + snprintf(me->exname, MNTPATHLEN, "%s", export); + snprintf(me->hostname, MNTPATHLEN, "%s", host); + INIT_LIST_HEAD(&me->mlist); + LOCK(&ms->mountlock); + { + list_add_tail(&me->mlist, &ms->mountlist); + mount_rewrite_rmtab(ms, NULL); + } + UNLOCK(&ms->mountlock); + return 0; } int -mount3udp_delete_mountlist (xlator_t *nfsx, char *hostname, char *export) +mount3udp_delete_mountlist(xlator_t *nfsx, char *hostname, char *export) { - struct mount3_state *ms = NULL; + struct mount3_state *ms = NULL; - if ((!hostname) || (!export) || (!nfsx)) - return -1; + if ((!hostname) || (!export) || (!nfsx)) + return -1; - ms = __mnt3udp_get_mstate (nfsx); - if (!ms) - return -1; + ms = __mnt3udp_get_mstate(nfsx); + if (!ms) + return -1; - mnt3svc_umount (ms, export, hostname); - return 0; + mnt3svc_umount(ms, export, hostname); + return 0; } /** @@ -3113,90 +3098,88 @@ mount3udp_delete_mountlist (xlator_t *nfsx, char *hostname, char *export) * NB: This does not support IPv6 currently. */ int -mnt3_export_fill_hostspec (struct host_auth_spec* hostspec, const char* hostip) +mnt3_export_fill_hostspec(struct host_auth_spec *hostspec, const char *hostip) { - char *ipdupstr = NULL; - char *savptr = NULL; - char *endptr = NULL; - char *ip = NULL; - char *token = NULL; - int ret = -1; - long prefixlen = IPv4_ADDR_SIZE; /* default */ - uint32_t shiftbits = 0; - size_t length = 0; - - /* Create copy of the string so that the source won't change - */ - ipdupstr = gf_strdup (hostip); - if (NULL == ipdupstr) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Memory allocation failed"); - goto err; - } - - ip = strtok_r (ipdupstr, "/", &savptr); - /* Validate the Hostname or IPv4 address - * TODO: IPv6 support for subdir auth. - */ - length = strlen (ip); - if ((!valid_ipv4_address (ip, (int)length, _gf_false)) && - (!valid_host_name (ip, (int)length))) { - gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Invalid hostname or IPv4 address: %s", ip); - goto err; - } - - hostspec->host_addr = gf_strdup (ip); - if (NULL == hostspec->host_addr) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Memory allocation failed"); - goto err; - } - - /** - * User provided CIDR address (xx.xx.xx.xx/n format) is split - * into HOST (IP addr or hostname) and network prefix(n) from - * which netmask would be calculated. This CIDR address may - * denote a single, distinct interface address or the beginning - * address of an entire network. - * - * e.g. the IPv4 block 192.168.100.0/24 represents the 256 - * IPv4 addresses from 192.168.100.0 to 192.168.100.255. - * Therefore to check if an IP matches 192.168.100.0/24 - * we should mask the IP with FFFFFF00 and compare it with - * host address part of CIDR. - * - * Refer: mask_match() in common-utils.c. - */ - token = strtok_r (NULL, "/", &savptr); - if (token != NULL) { - prefixlen = strtol (token, &endptr, 10); - if ((errno != 0) || (*endptr != '\0') || - (prefixlen < 0) || (prefixlen > IPv4_ADDR_SIZE)) { - gf_msg (THIS->name, GF_LOG_WARNING, EINVAL, - NFS_MSG_INVALID_ENTRY, - "Invalid IPv4 subnetwork mask"); - goto err; - } - } - - /* - * 1. Calculate the network mask address. - * 2. Convert it into Big-Endian format. - * 3. Store it in hostspec netmask. - */ - shiftbits = IPv4_ADDR_SIZE - prefixlen; - hostspec->netmask = htonl ((uint32_t)~0 << shiftbits); - - ret = 0; /* SUCCESS */ + char *ipdupstr = NULL; + char *savptr = NULL; + char *endptr = NULL; + char *ip = NULL; + char *token = NULL; + int ret = -1; + long prefixlen = IPv4_ADDR_SIZE; /* default */ + uint32_t shiftbits = 0; + size_t length = 0; + + /* Create copy of the string so that the source won't change + */ + ipdupstr = gf_strdup(hostip); + if (NULL == ipdupstr) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); + goto err; + } + + ip = strtok_r(ipdupstr, "/", &savptr); + /* Validate the Hostname or IPv4 address + * TODO: IPv6 support for subdir auth. + */ + length = strlen(ip); + if ((!valid_ipv4_address(ip, (int)length, _gf_false)) && + (!valid_host_name(ip, (int)length))) { + gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Invalid hostname or IPv4 address: %s", ip); + goto err; + } + + hostspec->host_addr = gf_strdup(ip); + if (NULL == hostspec->host_addr) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); + goto err; + } + + /** + * User provided CIDR address (xx.xx.xx.xx/n format) is split + * into HOST (IP addr or hostname) and network prefix(n) from + * which netmask would be calculated. This CIDR address may + * denote a single, distinct interface address or the beginning + * address of an entire network. + * + * e.g. the IPv4 block 192.168.100.0/24 represents the 256 + * IPv4 addresses from 192.168.100.0 to 192.168.100.255. + * Therefore to check if an IP matches 192.168.100.0/24 + * we should mask the IP with FFFFFF00 and compare it with + * host address part of CIDR. + * + * Refer: mask_match() in common-utils.c. + */ + token = strtok_r(NULL, "/", &savptr); + if (token != NULL) { + prefixlen = strtol(token, &endptr, 10); + if ((errno != 0) || (*endptr != '\0') || (prefixlen < 0) || + (prefixlen > IPv4_ADDR_SIZE)) { + gf_msg(THIS->name, GF_LOG_WARNING, EINVAL, NFS_MSG_INVALID_ENTRY, + "Invalid IPv4 subnetwork mask"); + goto err; + } + } + + /* + * 1. Calculate the network mask address. + * 2. Convert it into Big-Endian format. + * 3. Store it in hostspec netmask. + */ + shiftbits = IPv4_ADDR_SIZE - prefixlen; + hostspec->netmask = htonl((uint32_t)~0 << shiftbits); + + ret = 0; /* SUCCESS */ err: - if (NULL != ipdupstr) { - GF_FREE (ipdupstr); - } - return ret; + if (NULL != ipdupstr) { + GF_FREE(ipdupstr); + } + return ret; } - /** * This function will parse the AUTH parameter passed along with * "export-dir" option. If AUTH parameter is present then it will be @@ -3210,80 +3193,75 @@ err: * @return This function will return 0 on success and -1 on failure. */ int -mnt3_export_parse_auth_param (struct mnt3_export* exp, char* exportpath) +mnt3_export_parse_auth_param(struct mnt3_export *exp, char *exportpath) { - char *token = NULL; - char *savPtr = NULL; - char *hostip = NULL; - struct host_auth_spec *host = NULL; - int ret = 0; - - /* Using exportpath directly in strtok_r because we want - * to strip off AUTH parameter from exportpath. */ - token = strtok_r (exportpath, "(", &savPtr); - - /* Get the next token, which will be the AUTH parameter. */ - token = strtok_r (NULL, ")", &savPtr); - - if (NULL == token) { - /* If AUTH is not present then we should return success. */ - return 0; - } + char *token = NULL; + char *savPtr = NULL; + char *hostip = NULL; + struct host_auth_spec *host = NULL; + int ret = 0; - /* Free any previously allocated hostspec structure. */ - if (NULL != exp->hostspec) { - GF_FREE (exp->hostspec); - exp->hostspec = NULL; - } + /* Using exportpath directly in strtok_r because we want + * to strip off AUTH parameter from exportpath. */ + token = strtok_r(exportpath, "(", &savPtr); - exp->hostspec = GF_CALLOC (1, - sizeof (*(exp->hostspec)), - gf_nfs_mt_auth_spec); - if (NULL == exp->hostspec){ - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Memory allocation failed"); - return -1; - } + /* Get the next token, which will be the AUTH parameter. */ + token = strtok_r(NULL, ")", &savPtr); - /* AUTH parameter can have multiple entries. For each entry - * a host_auth_spec structure is created. */ - host = exp->hostspec; + if (NULL == token) { + /* If AUTH is not present then we should return success. */ + return 0; + } + + /* Free any previously allocated hostspec structure. */ + if (NULL != exp->hostspec) { + GF_FREE(exp->hostspec); + exp->hostspec = NULL; + } + + exp->hostspec = GF_CALLOC(1, sizeof(*(exp->hostspec)), gf_nfs_mt_auth_spec); + if (NULL == exp->hostspec) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); + return -1; + } - hostip = strtok_r (token, "|", &savPtr); + /* AUTH parameter can have multiple entries. For each entry + * a host_auth_spec structure is created. */ + host = exp->hostspec; - /* Parse all AUTH parameters separated by '|' */ - while (NULL != hostip){ - ret = mnt3_export_fill_hostspec (host, hostip); - if (0 != ret) { - gf_msg (GF_MNT, GF_LOG_WARNING, 0, - NFS_MSG_PARSE_HOSTSPEC_FAIL, - "Failed to parse hostspec: %s", hostip); - goto err; - } + hostip = strtok_r(token, "|", &savPtr); - hostip = strtok_r (NULL, "|", &savPtr); - if (NULL == hostip) { - break; - } + /* Parse all AUTH parameters separated by '|' */ + while (NULL != hostip) { + ret = mnt3_export_fill_hostspec(host, hostip); + if (0 != ret) { + gf_msg(GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_PARSE_HOSTSPEC_FAIL, + "Failed to parse hostspec: %s", hostip); + goto err; + } - host->next = GF_CALLOC (1, sizeof (*(host)), - gf_nfs_mt_auth_spec); - if (NULL == host->next){ - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, - NFS_MSG_NO_MEMORY, - "Memory allocation failed"); - goto err; - } - host = host->next; + hostip = strtok_r(NULL, "|", &savPtr); + if (NULL == hostip) { + break; } - /* In case of success return from here */ - return 0; + host->next = GF_CALLOC(1, sizeof(*(host)), gf_nfs_mt_auth_spec); + if (NULL == host->next) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); + goto err; + } + host = host->next; + } + + /* In case of success return from here */ + return 0; err: - /* In case of failure free up hostspec structure. */ - FREE_HOSTSPEC (exp); + /* In case of failure free up hostspec structure. */ + FREE_HOSTSPEC(exp); - return -1; + return -1; } /** @@ -3292,419 +3270,410 @@ err: * exportpath format: <abspath>[(hostdesc[|hostspec|...])] */ struct mnt3_export * -mnt3_init_export_ent (struct mount3_state *ms, xlator_t *xl, char *exportpath, - uuid_t volumeid) +mnt3_init_export_ent(struct mount3_state *ms, xlator_t *xl, char *exportpath, + uuid_t volumeid) { - struct mnt3_export *exp = NULL; - int alloclen = 0; - int ret = -1; - - if ((!ms) || (!xl)) - return NULL; - - exp = GF_CALLOC (1, sizeof (*exp), gf_nfs_mt_mnt3_export); - if (!exp) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Memory allocation failed"); - return NULL; - } - - if (NULL != exportpath) { - /* If exportpath is not NULL then we should check if AUTH - * parameter is present or not. If AUTH parameter is present - * then it will be stripped and stored in mnt3_export (exp) - * structure. - */ - if (0 != mnt3_export_parse_auth_param (exp, exportpath)){ - gf_msg (GF_MNT, GF_LOG_ERROR, 0, - NFS_MSG_PARSE_AUTH_PARAM_FAIL, - "Failed to parse auth param"); - goto err; - } - } - + struct mnt3_export *exp = NULL; + int alloclen = 0; + int ret = -1; - INIT_LIST_HEAD (&exp->explist); - if (exportpath) - alloclen = strlen (xl->name) + 2 + strlen (exportpath); - else - alloclen = strlen (xl->name) + 2; + if ((!ms) || (!xl)) + return NULL; - exp->expname = GF_MALLOC (alloclen, gf_nfs_mt_char); - if (!exp->expname) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Memory allocation failed"); - goto err; - } + exp = GF_CALLOC(1, sizeof(*exp), gf_nfs_mt_mnt3_export); + if (!exp) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); + return NULL; + } - if (exportpath) { - gf_msg_trace (GF_MNT, 0, "Initing dir export: %s:%s", - xl->name, exportpath); - exp->exptype = MNT3_EXPTYPE_DIR; - ret = snprintf (exp->expname, alloclen, "/%s%s", xl->name, - exportpath); - } else { - gf_msg_trace (GF_MNT, 0, "Initing volume export: %s", - xl->name); - exp->exptype = MNT3_EXPTYPE_VOLUME; - ret = snprintf (exp->expname, alloclen, "/%s", xl->name); - } - if (ret < 0) { - gf_msg (xl->name, GF_LOG_ERROR, ret, NFS_MSG_SET_EXP_FAIL, - "Failed to set the export name"); - goto err; - } - /* Just copy without discrimination, we'll determine whether to - * actually use it when a mount request comes in and a file handle - * needs to be built. + if (NULL != exportpath) { + /* If exportpath is not NULL then we should check if AUTH + * parameter is present or not. If AUTH parameter is present + * then it will be stripped and stored in mnt3_export (exp) + * structure. */ - gf_uuid_copy (exp->volumeid, volumeid); - exp->vol = xl; - - /* On success we should return from here*/ - return exp; + if (0 != mnt3_export_parse_auth_param(exp, exportpath)) { + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_PARSE_AUTH_PARAM_FAIL, + "Failed to parse auth param"); + goto err; + } + } + + INIT_LIST_HEAD(&exp->explist); + if (exportpath) + alloclen = strlen(xl->name) + 2 + strlen(exportpath); + else + alloclen = strlen(xl->name) + 2; + + exp->expname = GF_MALLOC(alloclen, gf_nfs_mt_char); + if (!exp->expname) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); + goto err; + } + + if (exportpath) { + gf_msg_trace(GF_MNT, 0, "Initing dir export: %s:%s", xl->name, + exportpath); + exp->exptype = MNT3_EXPTYPE_DIR; + ret = snprintf(exp->expname, alloclen, "/%s%s", xl->name, exportpath); + } else { + gf_msg_trace(GF_MNT, 0, "Initing volume export: %s", xl->name); + exp->exptype = MNT3_EXPTYPE_VOLUME; + ret = snprintf(exp->expname, alloclen, "/%s", xl->name); + } + if (ret < 0) { + gf_msg(xl->name, GF_LOG_ERROR, ret, NFS_MSG_SET_EXP_FAIL, + "Failed to set the export name"); + goto err; + } + /* Just copy without discrimination, we'll determine whether to + * actually use it when a mount request comes in and a file handle + * needs to be built. + */ + gf_uuid_copy(exp->volumeid, volumeid); + exp->vol = xl; + + /* On success we should return from here*/ + return exp; err: - /* On failure free exp and it's members.*/ - if (NULL != exp) { - mnt3_export_free (exp); - exp = NULL; - } + /* On failure free exp and it's members.*/ + if (NULL != exp) { + mnt3_export_free(exp); + exp = NULL; + } - return exp; + return exp; } - int -__mnt3_init_volume_direxports (struct mount3_state *ms, xlator_t *xlator, - char *optstr, uuid_t volumeid) +__mnt3_init_volume_direxports(struct mount3_state *ms, xlator_t *xlator, + char *optstr, uuid_t volumeid) { - struct mnt3_export *newexp = NULL; - int ret = -1; - char *savptr = NULL; - char *dupopt = NULL; - char *token = NULL; - - if ((!ms) || (!xlator) || (!optstr)) - return -1; - - dupopt = strdupa (optstr); - - token = strtok_r (dupopt, ",", &savptr); - while (token) { - newexp = mnt3_init_export_ent (ms, xlator, token, volumeid); - if (!newexp) { - gf_msg (GF_MNT, GF_LOG_ERROR, 0, - NFS_MSG_INIT_DIR_EXP_FAIL, "Failed to init dir " - "export: %s", token); - ret = -1; - goto err; - } + struct mnt3_export *newexp = NULL; + int ret = -1; + char *savptr = NULL; + char *dupopt = NULL; + char *token = NULL; - list_add_tail (&newexp->explist, &ms->exportlist); - token = strtok_r (NULL, ",", &savptr); + if ((!ms) || (!xlator) || (!optstr)) + return -1; + + dupopt = strdupa(optstr); + + token = strtok_r(dupopt, ",", &savptr); + while (token) { + newexp = mnt3_init_export_ent(ms, xlator, token, volumeid); + if (!newexp) { + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_INIT_DIR_EXP_FAIL, + "Failed to init dir " + "export: %s", + token); + ret = -1; + goto err; } - ret = 0; + list_add_tail(&newexp->explist, &ms->exportlist); + token = strtok_r(NULL, ",", &savptr); + } + + ret = 0; err: - return ret; + return ret; } - int -__mnt3_init_volume (struct mount3_state *ms, dict_t *opts, xlator_t *xlator) +__mnt3_init_volume(struct mount3_state *ms, dict_t *opts, xlator_t *xlator) { - struct mnt3_export *newexp = NULL; - int ret = -1; - char searchstr[1024]; - char *optstr = NULL; - uuid_t volumeid = {0, }; + struct mnt3_export *newexp = NULL; + int ret = -1; + char searchstr[1024]; + char *optstr = NULL; + uuid_t volumeid = { + 0, + }; + + if ((!ms) || (!xlator) || (!opts)) + return -1; - if ((!ms) || (!xlator) || (!opts)) - return -1; + gf_uuid_clear(volumeid); + if (gf_nfs_dvm_off(nfs_state(ms->nfsx))) + goto no_dvm; - gf_uuid_clear (volumeid); - if (gf_nfs_dvm_off (nfs_state (ms->nfsx))) - goto no_dvm; + ret = snprintf(searchstr, 1024, "nfs3.%s.volume-id", xlator->name); + if (ret < 0) { + gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_SNPRINTF_FAIL, + "snprintf failed"); + ret = -1; + goto err; + } - ret = snprintf (searchstr, 1024, "nfs3.%s.volume-id", xlator->name); + if (dict_get(opts, searchstr)) { + ret = dict_get_str(opts, searchstr, &optstr); if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_SNPRINTF_FAIL, - "snprintf failed"); - ret = -1; - goto err; - } - - if (dict_get (opts, searchstr)) { - ret = dict_get_str (opts, searchstr, &optstr); - if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, ret, - NFS_MSG_DICT_GET_FAILED, "Failed to read " - "option: %s", searchstr); - ret = -1; - goto err; - } - } else { - gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_VOLID_MISSING, - "DVM is on but volume-id not " - "given for volume: %s", xlator->name); - ret = -1; - goto err; - } - - if (optstr) { - ret = gf_uuid_parse (optstr, volumeid); - if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, ret, - NFS_MSG_PARSE_VOL_UUID_FAIL, "Failed to parse " - "volume UUID"); - ret = -1; - goto err; - } + gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_DICT_GET_FAILED, + "Failed to read " + "option: %s", + searchstr); + ret = -1; + goto err; + } + } else { + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_VOLID_MISSING, + "DVM is on but volume-id not " + "given for volume: %s", + xlator->name); + ret = -1; + goto err; + } + + if (optstr) { + ret = gf_uuid_parse(optstr, volumeid); + if (ret < 0) { + gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_PARSE_VOL_UUID_FAIL, + "Failed to parse " + "volume UUID"); + ret = -1; + goto err; } + } no_dvm: - ret = snprintf (searchstr, 1024, "nfs3.%s.export-dir", xlator->name); + ret = snprintf(searchstr, 1024, "nfs3.%s.export-dir", xlator->name); + if (ret < 0) { + gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_SNPRINTF_FAIL, + "snprintf failed"); + ret = -1; + goto err; + } + + if (dict_get(opts, searchstr)) { + ret = dict_get_str(opts, searchstr, &optstr); if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_SNPRINTF_FAIL, - "snprintf failed"); - ret = -1; - goto err; + gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_DICT_GET_FAILED, + "Failed to read " + "option: %s", + searchstr); + ret = -1; + goto err; } - if (dict_get (opts, searchstr)) { - ret = dict_get_str (opts, searchstr, &optstr); - if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, ret, - NFS_MSG_DICT_GET_FAILED, "Failed to read " - "option: %s", searchstr); - ret = -1; - goto err; - } - - ret = __mnt3_init_volume_direxports (ms, xlator, optstr, - volumeid); - if (ret == -1) { - gf_msg (GF_MNT, GF_LOG_ERROR, 0, - NFS_MSG_DIR_EXP_SETUP_FAIL, "Dir export " - "setup failed for volume: %s", xlator->name); - goto err; - } + ret = __mnt3_init_volume_direxports(ms, xlator, optstr, volumeid); + if (ret == -1) { + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_DIR_EXP_SETUP_FAIL, + "Dir export " + "setup failed for volume: %s", + xlator->name); + goto err; } + } - if (ms->export_volumes) { - newexp = mnt3_init_export_ent (ms, xlator, NULL, volumeid); - if (!newexp) { - ret = -1; - goto err; - } - - list_add_tail (&newexp->explist, &ms->exportlist); + if (ms->export_volumes) { + newexp = mnt3_init_export_ent(ms, xlator, NULL, volumeid); + if (!newexp) { + ret = -1; + goto err; } - ret = 0; + list_add_tail(&newexp->explist, &ms->exportlist); + } + ret = 0; err: - return ret; + return ret; } - int -__mnt3_init_volume_export (struct mount3_state *ms, dict_t *opts) +__mnt3_init_volume_export(struct mount3_state *ms, dict_t *opts) { - int ret = -1; - char *optstr = NULL; - /* On by default. */ - gf_boolean_t boolt = _gf_true; - - if ((!ms) || (!opts)) - return -1; - - if (!dict_get (opts, "nfs3.export-volumes")) { - ret = 0; - goto err; - } + int ret = -1; + char *optstr = NULL; + /* On by default. */ + gf_boolean_t boolt = _gf_true; - ret = dict_get_str (opts, "nfs3.export-volumes", &optstr); - if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_DICT_GET_FAILED, - "Failed to read option: nfs3.export-volumes"); - ret = -1; - goto err; - } + if ((!ms) || (!opts)) + return -1; - ret = gf_string2boolean (optstr, &boolt); - if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_STR2BOOL_FAIL, - "Failed to convert string to boolean"); - } + if (!dict_get(opts, "nfs3.export-volumes")) { + ret = 0; + goto err; + } + + ret = dict_get_str(opts, "nfs3.export-volumes", &optstr); + if (ret < 0) { + gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_DICT_GET_FAILED, + "Failed to read option: nfs3.export-volumes"); + ret = -1; + goto err; + } + + ret = gf_string2boolean(optstr, &boolt); + if (ret < 0) { + gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_STR2BOOL_FAIL, + "Failed to convert string to boolean"); + } err: - if (boolt == _gf_false) { - gf_msg_trace (GF_MNT, 0, "Volume exports disabled"); - ms->export_volumes = 0; - } else { - gf_msg_trace (GF_MNT, 0, "Volume exports enabled"); - ms->export_volumes = 1; - } - - return ret; + if (boolt == _gf_false) { + gf_msg_trace(GF_MNT, 0, "Volume exports disabled"); + ms->export_volumes = 0; + } else { + gf_msg_trace(GF_MNT, 0, "Volume exports enabled"); + ms->export_volumes = 1; + } + + return ret; } - int -__mnt3_init_dir_export (struct mount3_state *ms, dict_t *opts) +__mnt3_init_dir_export(struct mount3_state *ms, dict_t *opts) { - int ret = -1; - char *optstr = NULL; - /* On by default. */ - gf_boolean_t boolt = _gf_true; - - if ((!ms) || (!opts)) - return -1; + int ret = -1; + char *optstr = NULL; + /* On by default. */ + gf_boolean_t boolt = _gf_true; - if (!dict_get (opts, "nfs3.export-dirs")) { - ret = 0; - goto err; - } - - ret = dict_get_str (opts, "nfs3.export-dirs", &optstr); - if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_DICT_GET_FAILED, - "Failed to read option: nfs3.export-dirs"); - ret = -1; - goto err; - } + if ((!ms) || (!opts)) + return -1; - ret = gf_string2boolean (optstr, &boolt); - if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_STR2BOOL_FAIL, - "Failed to convert string to boolean"); - } + if (!dict_get(opts, "nfs3.export-dirs")) { + ret = 0; + goto err; + } + + ret = dict_get_str(opts, "nfs3.export-dirs", &optstr); + if (ret < 0) { + gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_DICT_GET_FAILED, + "Failed to read option: nfs3.export-dirs"); + ret = -1; + goto err; + } + + ret = gf_string2boolean(optstr, &boolt); + if (ret < 0) { + gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_STR2BOOL_FAIL, + "Failed to convert string to boolean"); + } err: - if (boolt == _gf_false) { - gf_msg_trace (GF_MNT, 0, "Dir exports disabled"); - ms->export_dirs = 0; - } else { - gf_msg_trace (GF_MNT, 0, "Dir exports enabled"); - ms->export_dirs = 1; - } - - return ret; + if (boolt == _gf_false) { + gf_msg_trace(GF_MNT, 0, "Dir exports disabled"); + ms->export_dirs = 0; + } else { + gf_msg_trace(GF_MNT, 0, "Dir exports enabled"); + ms->export_dirs = 1; + } + + return ret; } - int -mnt3_init_options (struct mount3_state *ms, dict_t *options) +mnt3_init_options(struct mount3_state *ms, dict_t *options) { - xlator_list_t *volentry = NULL; - int ret = -1; - - if ((!ms) || (!options)) - return -1; - - __mnt3_init_volume_export (ms, options); - __mnt3_init_dir_export (ms, options); - volentry = ms->nfsx->children; - while (volentry) { - gf_msg_trace (GF_MNT, 0, "Initing options for: %s", - volentry->xlator->name); - ret = __mnt3_init_volume (ms, options, volentry->xlator); - if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, ret, - NFS_MSG_VOL_INIT_FAIL, - "Volume init failed"); - goto err; - } + xlator_list_t *volentry = NULL; + int ret = -1; - volentry = volentry->next; + if ((!ms) || (!options)) + return -1; + + __mnt3_init_volume_export(ms, options); + __mnt3_init_dir_export(ms, options); + volentry = ms->nfsx->children; + while (volentry) { + gf_msg_trace(GF_MNT, 0, "Initing options for: %s", + volentry->xlator->name); + ret = __mnt3_init_volume(ms, options, volentry->xlator); + if (ret < 0) { + gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_VOL_INIT_FAIL, + "Volume init failed"); + goto err; } + volentry = volentry->next; + } - ret = 0; + ret = 0; err: - return ret; + return ret; } struct mount3_state * -mnt3_init_state (xlator_t *nfsx) +mnt3_init_state(xlator_t *nfsx) { - struct mount3_state *ms = NULL; - int ret = -1; - - if (!nfsx) - return NULL; + struct mount3_state *ms = NULL; + int ret = -1; - ms = GF_CALLOC (1, sizeof (*ms), gf_nfs_mt_mount3_state); - if (!ms) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Memory allocation failed"); - return NULL; - } + if (!nfsx) + return NULL; - ms->iobpool = nfsx->ctx->iobuf_pool; - ms->nfsx = nfsx; - INIT_LIST_HEAD (&ms->exportlist); - ret = mnt3_init_options (ms, nfsx->options); - if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_OPT_INIT_FAIL, - "Options init failed"); - return NULL; - } + ms = GF_CALLOC(1, sizeof(*ms), gf_nfs_mt_mount3_state); + if (!ms) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); + return NULL; + } + + ms->iobpool = nfsx->ctx->iobuf_pool; + ms->nfsx = nfsx; + INIT_LIST_HEAD(&ms->exportlist); + ret = mnt3_init_options(ms, nfsx->options); + if (ret < 0) { + gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_OPT_INIT_FAIL, + "Options init failed"); + return NULL; + } - INIT_LIST_HEAD (&ms->mountlist); - LOCK_INIT (&ms->mountlock); + INIT_LIST_HEAD(&ms->mountlist); + LOCK_INIT(&ms->mountlock); - return ms; + return ms; } int -mount_init_state (xlator_t *nfsx) +mount_init_state(xlator_t *nfsx) { - int ret = -1; - struct nfs_state *nfs = NULL; - - if (!nfsx) - goto out; - - nfs = (struct nfs_state *)nfs_state (nfsx); - /*Maintaining global state for MOUNT1 and MOUNT3*/ - nfs->mstate = mnt3_init_state (nfsx); - if (!nfs->mstate) { - gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to allocate mount state"); - goto out; - } - ret = 0; + int ret = -1; + struct nfs_state *nfs = NULL; + + if (!nfsx) + goto out; + + nfs = (struct nfs_state *)nfs_state(nfsx); + /*Maintaining global state for MOUNT1 and MOUNT3*/ + nfs->mstate = mnt3_init_state(nfsx); + if (!nfs->mstate) { + gf_msg(GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to allocate mount state"); + goto out; + } + ret = 0; out: - return ret; + return ret; } -rpcsvc_actor_t mnt3svc_actors[MOUNT3_PROC_COUNT] = { - {"NULL", MOUNT3_NULL, mnt3svc_null, NULL, 0, DRC_NA}, - {"MNT", MOUNT3_MNT, mnt3svc_mnt, NULL, 0, DRC_NA}, - {"DUMP", MOUNT3_DUMP, mnt3svc_dump, NULL, 0, DRC_NA}, - {"UMNT", MOUNT3_UMNT, mnt3svc_umnt, NULL, 0, DRC_NA}, - {"UMNTALL", MOUNT3_UMNTALL, mnt3svc_umntall, NULL, 0, DRC_NA}, - {"EXPORT", MOUNT3_EXPORT, mnt3svc_export, NULL, 0, DRC_NA} -}; - - +rpcsvc_actor_t mnt3svc_actors[MOUNT3_PROC_COUNT] = { + {"NULL", MOUNT3_NULL, mnt3svc_null, NULL, 0, DRC_NA}, + {"MNT", MOUNT3_MNT, mnt3svc_mnt, NULL, 0, DRC_NA}, + {"DUMP", MOUNT3_DUMP, mnt3svc_dump, NULL, 0, DRC_NA}, + {"UMNT", MOUNT3_UMNT, mnt3svc_umnt, NULL, 0, DRC_NA}, + {"UMNTALL", MOUNT3_UMNTALL, mnt3svc_umntall, NULL, 0, DRC_NA}, + {"EXPORT", MOUNT3_EXPORT, mnt3svc_export, NULL, 0, DRC_NA}}; /* Static init parts are assigned here, dynamic ones are done in * mnt3svc_init and mnt3_init_state. * Making MOUNT3 a synctask so that the blocking DNS calls during rpc auth * gets offloaded to syncenv, keeping the main/poll thread unblocked */ -rpcsvc_program_t mnt3prog = { - .progname = "MOUNT3", - .prognum = MOUNT_PROGRAM, - .progver = MOUNT_V3, - .progport = GF_MOUNTV3_PORT, - .actors = mnt3svc_actors, - .numactors = MOUNT3_PROC_COUNT, - .min_auth = AUTH_NULL, - .synctask = _gf_true, +rpcsvc_program_t mnt3prog = { + .progname = "MOUNT3", + .prognum = MOUNT_PROGRAM, + .progver = MOUNT_V3, + .progport = GF_MOUNTV3_PORT, + .actors = mnt3svc_actors, + .numactors = MOUNT3_PROC_COUNT, + .min_auth = AUTH_NULL, + .synctask = _gf_true, }; /** @@ -3718,79 +3687,82 @@ rpcsvc_program_t mnt3prog = { * */ int -__mnt3_mounted_exports_walk (dict_t *dict, char *key, data_t *val, void *tmp) +__mnt3_mounted_exports_walk(dict_t *dict, char *key, data_t *val, void *tmp) { - char *path = NULL; - char *host_addr_ip = NULL; - char *host_addr_fqdn = NULL; - char *keydup = NULL; - char *colon = NULL; - struct mnt3_auth_params *auth_params = NULL; - int ret = 0; - int auth_status_code = 0; - - gf_msg_trace (GF_MNT, 0, "Checking if key %s is authorized.", key); - - auth_params = (struct mnt3_auth_params *)tmp; - - /* Since we haven't obtained a lock around the mount dict - * here, we want to duplicate the key and then process it. - * Otherwise we would potentially have a race condition - * by modifying the key in the dict when other threads - * are accessing it. - */ - keydup = strdupa (key); - - colon = strchr (keydup, ':'); - if (!colon) - return 0; - - *colon = '\0'; - - path = alloca (strlen (keydup) + 2); - snprintf (path, strlen (keydup) + 2, "/%s", keydup); - - /* Host is one character after ':' */ - host_addr_ip = colon + 1; - - /* Check if the IP is authorized */ - auth_status_code = mnt3_auth_host (auth_params, host_addr_ip, - NULL, path, FALSE, NULL); - if (auth_status_code == 0) { - goto out; - } - - ret = gf_get_hostname_from_ip (host_addr_ip, &host_addr_fqdn); - if (ret != 0) { - gf_msg (GF_MNT, GF_LOG_DEBUG, 0, NFS_MSG_AUTH_ERROR , - "Authorization failed for IP [%s], but name " - "resolution also failed!", host_addr_ip); - goto unmount; - } + char *path = NULL; + char *host_addr_ip = NULL; + char *host_addr_fqdn = NULL; + char *keydup = NULL; + char *colon = NULL; + struct mnt3_auth_params *auth_params = NULL; + int ret = 0; + int auth_status_code = 0; + + gf_msg_trace(GF_MNT, 0, "Checking if key %s is authorized.", key); + + auth_params = (struct mnt3_auth_params *)tmp; + + /* Since we haven't obtained a lock around the mount dict + * here, we want to duplicate the key and then process it. + * Otherwise we would potentially have a race condition + * by modifying the key in the dict when other threads + * are accessing it. + */ + keydup = strdupa(key); + + colon = strchr(keydup, ':'); + if (!colon) + return 0; - /* If not, check if the FQDN is authorized */ - gf_msg (GF_MNT, GF_LOG_DEBUG, 0, NFS_MSG_AUTH_ERROR, - "Authorization failed for IP [%s], attempting to" - " auth hostname [%s]...", host_addr_ip, host_addr_fqdn); - - auth_status_code = mnt3_auth_host (auth_params, host_addr_fqdn, - NULL, path, FALSE, NULL); - if (auth_status_code == 0) { - gf_msg (GF_MNT, GF_LOG_DEBUG, 0, NFS_MSG_AUTH_ERROR, - "Authorization succeeded for " - "Client [IP=%s, Hostname=%s].", - host_addr_ip, host_addr_fqdn); - goto out; - } + *colon = '\0'; + + path = alloca(strlen(keydup) + 2); + snprintf(path, strlen(keydup) + 2, "/%s", keydup); + + /* Host is one character after ':' */ + host_addr_ip = colon + 1; + + /* Check if the IP is authorized */ + auth_status_code = mnt3_auth_host(auth_params, host_addr_ip, NULL, path, + FALSE, NULL); + if (auth_status_code == 0) { + goto out; + } + + ret = gf_get_hostname_from_ip(host_addr_ip, &host_addr_fqdn); + if (ret != 0) { + gf_msg(GF_MNT, GF_LOG_DEBUG, 0, NFS_MSG_AUTH_ERROR, + "Authorization failed for IP [%s], but name " + "resolution also failed!", + host_addr_ip); + goto unmount; + } + + /* If not, check if the FQDN is authorized */ + gf_msg(GF_MNT, GF_LOG_DEBUG, 0, NFS_MSG_AUTH_ERROR, + "Authorization failed for IP [%s], attempting to" + " auth hostname [%s]...", + host_addr_ip, host_addr_fqdn); + + auth_status_code = mnt3_auth_host(auth_params, host_addr_fqdn, NULL, path, + FALSE, NULL); + if (auth_status_code == 0) { + gf_msg(GF_MNT, GF_LOG_DEBUG, 0, NFS_MSG_AUTH_ERROR, + "Authorization succeeded for " + "Client [IP=%s, Hostname=%s].", + host_addr_ip, host_addr_fqdn); + goto out; + } unmount: - gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_AUTH_ERROR, - "Client [IP=%s, Hostname=%s] not authorized for this mount. " - "Unmounting!", host_addr_ip, host_addr_fqdn); - mnt3svc_umount (auth_params->ms, path, host_addr_ip); + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_AUTH_ERROR, + "Client [IP=%s, Hostname=%s] not authorized for this mount. " + "Unmounting!", + host_addr_ip, host_addr_fqdn); + mnt3svc_umount(auth_params->ms, path, host_addr_ip); out: - GF_FREE (host_addr_fqdn); - return 0; + GF_FREE(host_addr_fqdn); + return 0; } /** @@ -3802,14 +3774,12 @@ out: * */ void -_mnt3_invalidate_old_mounts (struct mount3_state *ms) +_mnt3_invalidate_old_mounts(struct mount3_state *ms) { - gf_msg_debug (GF_MNT, 0, "Invalidating old mounts ..."); - dict_foreach (ms->mountdict, __mnt3_mounted_exports_walk, - ms->auth_params); + gf_msg_debug(GF_MNT, 0, "Invalidating old mounts ..."); + dict_foreach(ms->mountdict, __mnt3_mounted_exports_walk, ms->auth_params); } - /** * _mnt3_has_file_changed -- Checks if a file has changed on disk * @@ -3822,25 +3792,25 @@ _mnt3_invalidate_old_mounts (struct mount3_state *ms) * Uses get_file_mtime () in common-utils.c */ gf_boolean_t -_mnt3_has_file_changed (const char *path, time_t *oldmtime) +_mnt3_has_file_changed(const char *path, time_t *oldmtime) { - gf_boolean_t changed = _gf_false; - time_t mtime = {0}; - int ret = 0; + gf_boolean_t changed = _gf_false; + time_t mtime = {0}; + int ret = 0; - GF_VALIDATE_OR_GOTO (GF_MNT, path, out); - GF_VALIDATE_OR_GOTO (GF_MNT, oldmtime, out); + GF_VALIDATE_OR_GOTO(GF_MNT, path, out); + GF_VALIDATE_OR_GOTO(GF_MNT, oldmtime, out); - ret = get_file_mtime (path, &mtime); - if (ret < 0) - goto out; + ret = get_file_mtime(path, &mtime); + if (ret < 0) + goto out; - if (mtime != *oldmtime) { - changed = _gf_true; - *oldmtime = mtime; - } + if (mtime != *oldmtime) { + changed = _gf_true; + *oldmtime = mtime; + } out: - return changed; + return changed; } /** @@ -3853,84 +3823,82 @@ out: * @return: Always returns NULL */ void * -_mnt3_auth_param_refresh_thread (void *argv) +_mnt3_auth_param_refresh_thread(void *argv) { - struct mount3_state *mstate = (struct mount3_state *)argv; - char *exp_file_path = NULL; - char *ng_file_path = NULL; - size_t nbytes = 0; - time_t exp_time = 0; - time_t ng_time = 0; - gf_boolean_t any_file_changed = _gf_false; - int ret = 0; - - nbytes = strlen (exports_file_path) + 1; - exp_file_path = alloca (nbytes); - snprintf (exp_file_path, nbytes, "%s", exports_file_path); - - nbytes = strlen (netgroups_file_path) + 1; - ng_file_path = alloca (nbytes); - snprintf (ng_file_path, nbytes, "%s", netgroups_file_path); - - /* Set the initial timestamps to avoid reloading right after - * mnt3svc_init () spawns this thread */ - get_file_mtime (exp_file_path, &exp_time); - get_file_mtime (ng_file_path, &ng_time); - - while (_gf_true) { - if (mstate->stop_refresh) - break; - any_file_changed = _gf_false; - - /* Sleep before checking the file again */ - sleep (mstate->nfs->auth_refresh_time_secs); - - if (_mnt3_has_file_changed (exp_file_path, &exp_time)) { - gf_msg (GF_MNT, GF_LOG_INFO, 0, NFS_MSG_UPDATING_EXP, - "File %s changed, updating exports,", - exp_file_path); - - ret = mnt3_auth_set_exports_auth (mstate->auth_params, - exp_file_path); - if (ret) - gf_msg (GF_MNT, GF_LOG_ERROR, 0, - NFS_MSG_SET_EXP_AUTH_PARAM_FAIL, - "Failed to set export auth params."); - else - any_file_changed = _gf_true; - } - - if (_mnt3_has_file_changed (ng_file_path, &ng_time)) { - gf_msg (GF_MNT, GF_LOG_INFO, 0, - NFS_MSG_UPDATING_NET_GRP, "File %s changed," - "updating netgroups", ng_file_path); - - ret = mnt3_auth_set_netgroups_auth (mstate->auth_params, - ng_file_path); - if (ret) - gf_msg (GF_MNT, GF_LOG_ERROR, 0, - NFS_MSG_SET_NET_GRP_FAIL, - "Failed to set netgroup auth params."); - else - any_file_changed = _gf_true; - } - - /* If no files changed, go back to sleep */ - if (!any_file_changed) - continue; - - gf_msg (GF_MNT, GF_LOG_INFO, 0, NFS_MSG_PURGING_AUTH_CACHE, - "Purging auth cache."); - auth_cache_purge (mstate->authcache); - - /* Walk through mounts that are no longer authorized - * and unmount them on the server side. This will - * cause subsequent file ops to fail with access denied. - */ - _mnt3_invalidate_old_mounts (mstate); - } + struct mount3_state *mstate = (struct mount3_state *)argv; + char *exp_file_path = NULL; + char *ng_file_path = NULL; + size_t nbytes = 0; + time_t exp_time = 0; + time_t ng_time = 0; + gf_boolean_t any_file_changed = _gf_false; + int ret = 0; + + nbytes = strlen(exports_file_path) + 1; + exp_file_path = alloca(nbytes); + snprintf(exp_file_path, nbytes, "%s", exports_file_path); + + nbytes = strlen(netgroups_file_path) + 1; + ng_file_path = alloca(nbytes); + snprintf(ng_file_path, nbytes, "%s", netgroups_file_path); + + /* Set the initial timestamps to avoid reloading right after + * mnt3svc_init () spawns this thread */ + get_file_mtime(exp_file_path, &exp_time); + get_file_mtime(ng_file_path, &ng_time); + + while (_gf_true) { + if (mstate->stop_refresh) + break; + any_file_changed = _gf_false; + + /* Sleep before checking the file again */ + sleep(mstate->nfs->auth_refresh_time_secs); + + if (_mnt3_has_file_changed(exp_file_path, &exp_time)) { + gf_msg(GF_MNT, GF_LOG_INFO, 0, NFS_MSG_UPDATING_EXP, + "File %s changed, updating exports,", exp_file_path); + + ret = mnt3_auth_set_exports_auth(mstate->auth_params, + exp_file_path); + if (ret) + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SET_EXP_AUTH_PARAM_FAIL, + "Failed to set export auth params."); + else + any_file_changed = _gf_true; + } + + if (_mnt3_has_file_changed(ng_file_path, &ng_time)) { + gf_msg(GF_MNT, GF_LOG_INFO, 0, NFS_MSG_UPDATING_NET_GRP, + "File %s changed," + "updating netgroups", + ng_file_path); + + ret = mnt3_auth_set_netgroups_auth(mstate->auth_params, + ng_file_path); + if (ret) + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SET_NET_GRP_FAIL, + "Failed to set netgroup auth params."); + else + any_file_changed = _gf_true; + } + + /* If no files changed, go back to sleep */ + if (!any_file_changed) + continue; + + gf_msg(GF_MNT, GF_LOG_INFO, 0, NFS_MSG_PURGING_AUTH_CACHE, + "Purging auth cache."); + auth_cache_purge(mstate->authcache); + + /* Walk through mounts that are no longer authorized + * and unmount them on the server side. This will + * cause subsequent file ops to fail with access denied. + */ + _mnt3_invalidate_old_mounts(mstate); + } - return NULL; + return NULL; } /** @@ -3946,53 +3914,50 @@ _mnt3_auth_param_refresh_thread (void *argv) * bubbled up from the functions we call to set the params. */ int -_mnt3_init_auth_params (struct mount3_state *mstate) +_mnt3_init_auth_params(struct mount3_state *mstate) { - int ret = -EINVAL; - char *exp_file_path = NULL; - char *ng_file_path = NULL; - size_t nbytes = 0; - - GF_VALIDATE_OR_GOTO (GF_MNT, mstate, out); - - mstate->auth_params = mnt3_auth_params_init (mstate); - if (!mstate->auth_params) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to init mount auth params."); - ret = -ENOMEM; - goto out; - } - - nbytes = strlen (exports_file_path) + 1; - exp_file_path = alloca (nbytes); - snprintf (exp_file_path, nbytes, "%s", exports_file_path); - - ret = mnt3_auth_set_exports_auth (mstate->auth_params, exp_file_path); - if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, ret, - NFS_MSG_SET_EXP_AUTH_PARAM_FAIL, - "Failed to set export auth params."); - goto out; - } - - nbytes = strlen (netgroups_file_path) + 1; - ng_file_path = alloca (nbytes); - snprintf (ng_file_path, nbytes, "%s", netgroups_file_path); - - ret = mnt3_auth_set_netgroups_auth (mstate->auth_params, ng_file_path); - if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, ret, - NFS_MSG_SET_EXP_AUTH_PARAM_FAIL, - "Failed to set netgroup auth params."); - goto out; - } - - ret = 0; + int ret = -EINVAL; + char *exp_file_path = NULL; + char *ng_file_path = NULL; + size_t nbytes = 0; + + GF_VALIDATE_OR_GOTO(GF_MNT, mstate, out); + + mstate->auth_params = mnt3_auth_params_init(mstate); + if (!mstate->auth_params) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to init mount auth params."); + ret = -ENOMEM; + goto out; + } + + nbytes = strlen(exports_file_path) + 1; + exp_file_path = alloca(nbytes); + snprintf(exp_file_path, nbytes, "%s", exports_file_path); + + ret = mnt3_auth_set_exports_auth(mstate->auth_params, exp_file_path); + if (ret < 0) { + gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_SET_EXP_AUTH_PARAM_FAIL, + "Failed to set export auth params."); + goto out; + } + + nbytes = strlen(netgroups_file_path) + 1; + ng_file_path = alloca(nbytes); + snprintf(ng_file_path, nbytes, "%s", netgroups_file_path); + + ret = mnt3_auth_set_netgroups_auth(mstate->auth_params, ng_file_path); + if (ret < 0) { + gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_SET_EXP_AUTH_PARAM_FAIL, + "Failed to set netgroup auth params."); + goto out; + } + + ret = 0; out: - return ret; + return ret; } - /** * mnt3svc_deinit -- Function called by the nfs translator to cleanup all state * @@ -4001,289 +3966,278 @@ out: * as well as the threads that have been started. */ void -mnt3svc_deinit (xlator_t *nfsx) +mnt3svc_deinit(xlator_t *nfsx) { - struct mount3_state *mstate = NULL; - struct nfs_state *nfs = NULL; + struct mount3_state *mstate = NULL; + struct nfs_state *nfs = NULL; - if (!nfsx || !nfsx->private) - return; - - nfs = (struct nfs_state *)nfsx->private; - mstate = (struct mount3_state *)nfs->mstate; - - if (nfs->refresh_auth) { - /* Mark as true and wait for thread to exit */ - mstate->stop_refresh = _gf_true; - pthread_join (mstate->auth_refresh_thread, NULL); - } - - if (nfs->exports_auth) - mnt3_auth_params_deinit (mstate->auth_params); - - /* Unmount everything and clear mountdict */ - LOCK (&mstate->mountlock); - { - __mnt3svc_umountall (mstate); - dict_unref (mstate->mountdict); - } - UNLOCK (&mstate->mountlock); + if (!nfsx || !nfsx->private) + return; + nfs = (struct nfs_state *)nfsx->private; + mstate = (struct mount3_state *)nfs->mstate; + + if (nfs->refresh_auth) { + /* Mark as true and wait for thread to exit */ + mstate->stop_refresh = _gf_true; + pthread_join(mstate->auth_refresh_thread, NULL); + } + + if (nfs->exports_auth) + mnt3_auth_params_deinit(mstate->auth_params); + + /* Unmount everything and clear mountdict */ + LOCK(&mstate->mountlock); + { + __mnt3svc_umountall(mstate); + dict_unref(mstate->mountdict); + } + UNLOCK(&mstate->mountlock); } rpcsvc_program_t * -mnt3svc_init (xlator_t *nfsx) +mnt3svc_init(xlator_t *nfsx) { - struct mount3_state *mstate = NULL; - struct nfs_state *nfs = NULL; - dict_t *options = NULL; - char *portstr = NULL; - int ret = -1; - pthread_t udp_thread; - - if (!nfsx || !nfsx->private) - return NULL; - - nfs = (struct nfs_state *)nfsx->private; - - gf_msg_debug (GF_MNT, 0, "Initing Mount v3 state"); - mstate = (struct mount3_state *)nfs->mstate; - if (!mstate) { - gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_MNT_STATE_INIT_FAIL, - "Mount v3 state init failed"); - goto err; - } + struct mount3_state *mstate = NULL; + struct nfs_state *nfs = NULL; + dict_t *options = NULL; + char *portstr = NULL; + int ret = -1; + pthread_t udp_thread; + + if (!nfsx || !nfsx->private) + return NULL; - mstate->nfs = nfs; + nfs = (struct nfs_state *)nfsx->private; - mstate->mountdict = dict_new (); - if (!mstate->mountdict) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to setup mount dict. Allocation error."); - goto err; - } + gf_msg_debug(GF_MNT, 0, "Initing Mount v3 state"); + mstate = (struct mount3_state *)nfs->mstate; + if (!mstate) { + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_MNT_STATE_INIT_FAIL, + "Mount v3 state init failed"); + goto err; + } - if (nfs->exports_auth) { - ret = _mnt3_init_auth_params (mstate); - if (ret < 0) - goto err; + mstate->nfs = nfs; - mstate->authcache = auth_cache_init (nfs->auth_cache_ttl_sec); - if (!mstate->authcache) { - ret = -ENOMEM; - goto err; - } + mstate->mountdict = dict_new(); + if (!mstate->mountdict) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to setup mount dict. Allocation error."); + goto err; + } - mstate->stop_refresh = _gf_false; /* Allow thread to run */ - ret = gf_thread_create (&mstate->auth_refresh_thread, NULL, - _mnt3_auth_param_refresh_thread, - mstate, "nfsauth"); - if (ret) { - gf_msg_debug (GF_MNT, GF_LOG_DEBUG, - "Thread creation failed"); - } + if (nfs->exports_auth) { + ret = _mnt3_init_auth_params(mstate); + if (ret < 0) + goto err; - } else - gf_msg (GF_MNT, GF_LOG_INFO, 0, NFS_MSG_EXP_AUTH_DISABLED, - "Exports auth has been disabled!"); + mstate->authcache = auth_cache_init(nfs->auth_cache_ttl_sec); + if (!mstate->authcache) { + ret = -ENOMEM; + goto err; + } - mnt3prog.private = mstate; - options = dict_new (); + mstate->stop_refresh = _gf_false; /* Allow thread to run */ + ret = gf_thread_create(&mstate->auth_refresh_thread, NULL, + _mnt3_auth_param_refresh_thread, mstate, + "nfsauth"); + if (ret) { + gf_msg_debug(GF_MNT, GF_LOG_DEBUG, "Thread creation failed"); + } - ret = gf_asprintf (&portstr, "%d", GF_MOUNTV3_PORT); - if (ret == -1) - goto err; + } else + gf_msg(GF_MNT, GF_LOG_INFO, 0, NFS_MSG_EXP_AUTH_DISABLED, + "Exports auth has been disabled!"); - ret = dict_set_dynstr (options, "transport.socket.listen-port", - portstr); - if (ret == -1) - goto err; + mnt3prog.private = mstate; + options = dict_new(); - ret = dict_set_str (options, "transport-type", "socket"); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, - "dict_set_str error"); - goto err; - } + ret = gf_asprintf(&portstr, "%d", GF_MOUNTV3_PORT); + if (ret == -1) + goto err; - if (nfs->allow_insecure) { - ret = dict_set_str (options, "rpc-auth-allow-insecure", "on"); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, errno, - NFS_MSG_DICT_SET_FAILED, "dict_set_str error"); - goto err; - } - ret = dict_set_str (options, "rpc-auth.ports.insecure", "on"); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, errno, - NFS_MSG_DICT_SET_FAILED, "dict_set_str error"); - goto err; - } - } + ret = dict_set_dynstr(options, "transport.socket.listen-port", portstr); + if (ret == -1) + goto err; - ret= rpcsvc_create_listeners (nfs->rpcsvc, options, nfsx->name); + ret = dict_set_str(options, "transport-type", "socket"); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); + goto err; + } + + if (nfs->allow_insecure) { + ret = dict_set_str(options, "rpc-auth-allow-insecure", "on"); if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, errno, - NFS_MSG_LISTENERS_CREATE_FAIL, - "Unable to create listeners"); - dict_unref (options); - goto err; + gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); + goto err; } - - if (nfs->mount_udp) { - ret = gf_thread_create (&udp_thread, NULL, mount3udp_thread, - nfsx, "nfsudp"); - if (ret) { - gf_msg_debug (GF_MNT, GF_LOG_DEBUG, - "Thread creation failed"); - } + ret = dict_set_str(options, "rpc-auth.ports.insecure", "on"); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); + goto err; + } + } + + ret = rpcsvc_create_listeners(nfs->rpcsvc, options, nfsx->name); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_LISTENERS_CREATE_FAIL, + "Unable to create listeners"); + dict_unref(options); + goto err; + } + + if (nfs->mount_udp) { + ret = gf_thread_create(&udp_thread, NULL, mount3udp_thread, nfsx, + "nfsudp"); + if (ret) { + gf_msg_debug(GF_MNT, GF_LOG_DEBUG, "Thread creation failed"); } - return &mnt3prog; + } + return &mnt3prog; err: - return NULL; + return NULL; } - -rpcsvc_actor_t mnt1svc_actors[MOUNT1_PROC_COUNT] = { - {"NULL", MOUNT1_NULL, mnt3svc_null, NULL, 0, DRC_NA}, - {"MNT", MOUNT1_MNT, NULL, NULL, 0, DRC_NA }, - {"DUMP", MOUNT1_DUMP, mnt3svc_dump, NULL, 0, DRC_NA}, - {"UMNT", MOUNT1_UMNT, mnt3svc_umnt, NULL, 0, DRC_NA}, - {"UMNTALL", MOUNT1_UMNTALL, NULL, NULL, 0, DRC_NA}, - {"EXPORT", MOUNT1_EXPORT, mnt3svc_export, NULL, 0, DRC_NA} -}; - -rpcsvc_program_t mnt1prog = { - .progname = "MOUNT1", - .prognum = MOUNT_PROGRAM, - .progver = MOUNT_V1, - .progport = GF_MOUNTV1_PORT, - .actors = mnt1svc_actors, - .numactors = MOUNT1_PROC_COUNT, - .min_auth = AUTH_NULL, - .synctask = _gf_true, +rpcsvc_actor_t mnt1svc_actors[MOUNT1_PROC_COUNT] = { + {"NULL", MOUNT1_NULL, mnt3svc_null, NULL, 0, DRC_NA}, + {"MNT", MOUNT1_MNT, NULL, NULL, 0, DRC_NA}, + {"DUMP", MOUNT1_DUMP, mnt3svc_dump, NULL, 0, DRC_NA}, + {"UMNT", MOUNT1_UMNT, mnt3svc_umnt, NULL, 0, DRC_NA}, + {"UMNTALL", MOUNT1_UMNTALL, NULL, NULL, 0, DRC_NA}, + {"EXPORT", MOUNT1_EXPORT, mnt3svc_export, NULL, 0, DRC_NA}}; + +rpcsvc_program_t mnt1prog = { + .progname = "MOUNT1", + .prognum = MOUNT_PROGRAM, + .progver = MOUNT_V1, + .progport = GF_MOUNTV1_PORT, + .actors = mnt1svc_actors, + .numactors = MOUNT1_PROC_COUNT, + .min_auth = AUTH_NULL, + .synctask = _gf_true, }; - rpcsvc_program_t * -mnt1svc_init (xlator_t *nfsx) +mnt1svc_init(xlator_t *nfsx) { - struct mount3_state *mstate = NULL; - struct nfs_state *nfs = NULL; - dict_t *options = NULL; - char *portstr = NULL; - int ret = -1; - - if (!nfsx || !nfsx->private) - return NULL; - - nfs = (struct nfs_state *)nfsx->private; - - gf_msg_debug (GF_MNT, GF_LOG_DEBUG, "Initing Mount v1 state"); - mstate = (struct mount3_state *)nfs->mstate; - if (!mstate) { - gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, - NFS_MSG_MNT_STATE_INIT_FAIL, - "Mount v3 state init failed"); - goto err; - } + struct mount3_state *mstate = NULL; + struct nfs_state *nfs = NULL; + dict_t *options = NULL; + char *portstr = NULL; + int ret = -1; + + if (!nfsx || !nfsx->private) + return NULL; + + nfs = (struct nfs_state *)nfsx->private; - mnt1prog.private = mstate; + gf_msg_debug(GF_MNT, GF_LOG_DEBUG, "Initing Mount v1 state"); + mstate = (struct mount3_state *)nfs->mstate; + if (!mstate) { + gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_MNT_STATE_INIT_FAIL, + "Mount v3 state init failed"); + goto err; + } - options = dict_new (); + mnt1prog.private = mstate; - ret = gf_asprintf (&portstr, "%d", GF_MOUNTV1_PORT); - if (ret == -1) - goto err; + options = dict_new(); - ret = dict_set_dynstr (options, "transport.socket.listen-port", portstr); - if (ret == -1) - goto err; - ret = dict_set_str (options, "transport-type", "socket"); + ret = gf_asprintf(&portstr, "%d", GF_MOUNTV1_PORT); + if (ret == -1) + goto err; + + ret = dict_set_dynstr(options, "transport.socket.listen-port", portstr); + if (ret == -1) + goto err; + ret = dict_set_str(options, "transport-type", "socket"); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); + goto err; + } + + if (nfs->allow_insecure) { + ret = dict_set_str(options, "rpc-auth-allow-insecure", "on"); if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, - "dict_set_str error"); - goto err; + gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); + goto err; } - - if (nfs->allow_insecure) { - ret = dict_set_str (options, "rpc-auth-allow-insecure", "on"); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, errno, - NFS_MSG_DICT_SET_FAILED, - "dict_set_str error"); - goto err; - } - ret = dict_set_str (options, "rpc-auth.ports.insecure", "on"); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, errno, - NFS_MSG_DICT_SET_FAILED, - "dict_set_str error"); - goto err; - } + ret = dict_set_str(options, "rpc-auth.ports.insecure", "on"); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); + goto err; } + } #ifdef IPV6_DEFAULT - ret = dict_set_str (options, "transport.address-family", "inet6"); - if (ret == -1) { - gf_log (GF_NFS, GF_LOG_ERROR, - "dict_set_str error when trying to enable ipv6"); - goto err; - } + ret = dict_set_str(options, "transport.address-family", "inet6"); + if (ret == -1) { + gf_log(GF_NFS, GF_LOG_ERROR, + "dict_set_str error when trying to enable ipv6"); + goto err; + } #endif - ret = rpcsvc_create_listeners (nfs->rpcsvc, options, nfsx->name); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, errno, - NFS_MSG_LISTENERS_CREATE_FAIL, - "Unable to create listeners"); - dict_unref (options); - goto err; - } + ret = rpcsvc_create_listeners(nfs->rpcsvc, options, nfsx->name); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_LISTENERS_CREATE_FAIL, + "Unable to create listeners"); + dict_unref(options); + goto err; + } - return &mnt1prog; + return &mnt1prog; err: - return NULL; + return NULL; } int -mount_reconfigure_state (xlator_t *nfsx, dict_t *options) +mount_reconfigure_state(xlator_t *nfsx, dict_t *options) { - int ret = -1; - struct nfs_state *nfs = NULL; - struct mount3_state *ms = NULL; - struct mnt3_export *exp = NULL; - struct mnt3_export *texp = NULL; - - if ((!nfsx) || (!options)) - return (-1); - - nfs = (struct nfs_state *)nfs_state (nfsx); - if (!nfs) - return (-1); - - ms = nfs->mstate; - if (!ms) - return (-1); - - /* - * Free() up the old export list. mnt3_init_options() will - * rebuild the export list from scratch. Do it with locking - * to avoid unnecessary race conditions. - */ - LOCK (&ms->mountlock); - list_for_each_entry_safe (exp, texp, &ms->exportlist, explist) { - list_del (&exp->explist); - mnt3_export_free (exp); - } - ret = mnt3_init_options (ms, options); - UNLOCK (&ms->mountlock); - - if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RECONF_FAIL, - "Options reconfigure failed"); - return (-1); - } - - return (0); + int ret = -1; + struct nfs_state *nfs = NULL; + struct mount3_state *ms = NULL; + struct mnt3_export *exp = NULL; + struct mnt3_export *texp = NULL; + + if ((!nfsx) || (!options)) + return (-1); + + nfs = (struct nfs_state *)nfs_state(nfsx); + if (!nfs) + return (-1); + + ms = nfs->mstate; + if (!ms) + return (-1); + + /* + * Free() up the old export list. mnt3_init_options() will + * rebuild the export list from scratch. Do it with locking + * to avoid unnecessary race conditions. + */ + LOCK(&ms->mountlock); + list_for_each_entry_safe(exp, texp, &ms->exportlist, explist) + { + list_del(&exp->explist); + mnt3_export_free(exp); + } + ret = mnt3_init_options(ms, options); + UNLOCK(&ms->mountlock); + + if (ret < 0) { + gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RECONF_FAIL, + "Options reconfigure failed"); + return (-1); + } + + return (0); } diff --git a/xlators/nfs/server/src/mount3udp_svc.c b/xlators/nfs/server/src/mount3udp_svc.c index a9499bf003..d542e2951c 100644 --- a/xlators/nfs/server/src/mount3udp_svc.c +++ b/xlators/nfs/server/src/mount3udp_svc.c @@ -8,7 +8,6 @@ cases as published by the Free Software Foundation. */ - #include "xdr-nfs3.h" #include "logging.h" #include "mem-pool.h" @@ -23,224 +22,221 @@ #include <sys/socket.h> #include <netinet/in.h> - -extern struct nfs3_fh* -nfs3_rootfh (struct svc_req *req, xlator_t *nfsx, char *dp, char *expname); +extern struct nfs3_fh * +nfs3_rootfh(struct svc_req *req, xlator_t *nfsx, char *dp, char *expname); extern mountres3 -mnt3svc_set_mountres3 (mountstat3 stat, struct nfs3_fh *fh, - int *authflavor, u_int aflen); +mnt3svc_set_mountres3(mountstat3 stat, struct nfs3_fh *fh, int *authflavor, + u_int aflen); extern int -mount3udp_add_mountlist (xlator_t *nfsx, char *host, char *expname); +mount3udp_add_mountlist(xlator_t *nfsx, char *host, char *expname); extern int -mount3udp_delete_mountlist (xlator_t *nfsx, char *host, char *expname); +mount3udp_delete_mountlist(xlator_t *nfsx, char *host, char *expname); extern mountstat3 -mnt3svc_errno_to_mnterr (int32_t errnum); - +mnt3svc_errno_to_mnterr(int32_t errnum); /* only this thread will use this, no locking needed */ -char mnthost[INET_ADDRSTRLEN+1]; +char mnthost[INET_ADDRSTRLEN + 1]; #define MNT3UDP_AUTH_LEN 1 /* Only AUTH_UNIX for now */ mountres3 * mountudpproc3_mnt_3_svc(dirpath **dpp, struct svc_req *req) { - struct mountres3 *res = NULL; - int *autharr = NULL; - struct nfs3_fh *fh = NULL; - char *mpath = NULL; - xlator_t *nfsx = THIS; - char expname[PATH_MAX] = {0, }; - mountstat3 stat = MNT3ERR_SERVERFAULT; - - errno = 0; /* RESET errno */ - - mpath = (char *)*dpp; - while (*mpath == '/') - mpath++; - - res = GF_CALLOC (1, sizeof(*res), gf_nfs_mt_mountres3); - if (res == NULL) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Unable to allocate memory"); - goto err; - } - autharr = GF_CALLOC (MNT3UDP_AUTH_LEN, sizeof(int), gf_nfs_mt_int); - if (autharr == NULL) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Unable to allocate memory"); - goto err; - } - - autharr[0] = AUTH_UNIX; - - fh = nfs3_rootfh (req, nfsx, mpath, (char *)expname); - - /* FAILURE: No FH */ - if (fh == NULL) { - gf_msg (GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_GET_FH_FAIL, - "Unable to get fh for %s", mpath); - if (errno) - stat = mnt3svc_errno_to_mnterr (errno); - *res = mnt3svc_set_mountres3 (stat, NULL /* fh */, - autharr, MNT3UDP_AUTH_LEN); - return res; - } - - /* SUCCESS */ - stat = MNT3_OK; - *res = mnt3svc_set_mountres3 (stat, fh, autharr, MNT3UDP_AUTH_LEN); - (void) mount3udp_add_mountlist (nfsx, mnthost, (char *) expname); + struct mountres3 *res = NULL; + int *autharr = NULL; + struct nfs3_fh *fh = NULL; + char *mpath = NULL; + xlator_t *nfsx = THIS; + char expname[PATH_MAX] = { + 0, + }; + mountstat3 stat = MNT3ERR_SERVERFAULT; + + errno = 0; /* RESET errno */ + + mpath = (char *)*dpp; + while (*mpath == '/') + mpath++; + + res = GF_CALLOC(1, sizeof(*res), gf_nfs_mt_mountres3); + if (res == NULL) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Unable to allocate memory"); + goto err; + } + autharr = GF_CALLOC(MNT3UDP_AUTH_LEN, sizeof(int), gf_nfs_mt_int); + if (autharr == NULL) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Unable to allocate memory"); + goto err; + } + + autharr[0] = AUTH_UNIX; + + fh = nfs3_rootfh(req, nfsx, mpath, (char *)expname); + + /* FAILURE: No FH */ + if (fh == NULL) { + gf_msg(GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_GET_FH_FAIL, + "Unable to get fh for %s", mpath); + if (errno) + stat = mnt3svc_errno_to_mnterr(errno); + *res = mnt3svc_set_mountres3(stat, NULL /* fh */, autharr, + MNT3UDP_AUTH_LEN); return res; - - err: - GF_FREE (fh); - GF_FREE (res); - GF_FREE (autharr); - return NULL; + } + + /* SUCCESS */ + stat = MNT3_OK; + *res = mnt3svc_set_mountres3(stat, fh, autharr, MNT3UDP_AUTH_LEN); + (void)mount3udp_add_mountlist(nfsx, mnthost, (char *)expname); + return res; + +err: + GF_FREE(fh); + GF_FREE(res); + GF_FREE(autharr); + return NULL; } mountstat3 * mountudpproc3_umnt_3_svc(dirpath **dp, struct svc_req *req) { - mountstat3 *stat = NULL; - char *mpath = (char *) *dp; - xlator_t *nfsx = THIS; - - stat = GF_MALLOC (sizeof(mountstat3), gf_nfs_mt_mountstat3); - if (stat == NULL) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Unable to allocate memory"); - return NULL; - } - *stat = MNT3_OK; - (void) mount3udp_delete_mountlist (nfsx, mnthost, mpath); - return stat; + mountstat3 *stat = NULL; + char *mpath = (char *)*dp; + xlator_t *nfsx = THIS; + + stat = GF_MALLOC(sizeof(mountstat3), gf_nfs_mt_mountstat3); + if (stat == NULL) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Unable to allocate memory"); + return NULL; + } + *stat = MNT3_OK; + (void)mount3udp_delete_mountlist(nfsx, mnthost, mpath); + return stat; } static void mountudp_program_3(struct svc_req *rqstp, register SVCXPRT *transp) { - union { - dirpath mountudpproc3_mnt_3_arg; - } argument; - char *result = NULL; - xdrproc_t _xdr_argument = NULL, _xdr_result = NULL; - char *(*local)(char *, struct svc_req *) = NULL; - mountres3 *res = NULL; - struct sockaddr_in *sin = NULL; + union { + dirpath mountudpproc3_mnt_3_arg; + } argument; + char *result = NULL; + xdrproc_t _xdr_argument = NULL, _xdr_result = NULL; + char *(*local)(char *, struct svc_req *) = NULL; + mountres3 *res = NULL; + struct sockaddr_in *sin = NULL; #if !defined(_TIRPC_SVC_H) - sin = svc_getcaller (transp); + sin = svc_getcaller(transp); #else - sin = (struct sockaddr_in *)svc_getcaller (transp); - /* TIRPC's svc_getcaller() returns a pointer to a sockaddr_in6, even - * though it might actually be an IPv4 address. It ought return a - * struct sockaddr and make the caller upcast it to the proper - * address family. Sigh. - */ + sin = (struct sockaddr_in *)svc_getcaller(transp); + /* TIRPC's svc_getcaller() returns a pointer to a sockaddr_in6, even + * though it might actually be an IPv4 address. It ought return a + * struct sockaddr and make the caller upcast it to the proper + * address family. Sigh. + */ #endif - /* And let's make sure that it's actually an IPv4 address. */ - GF_ASSERT (sin->sin_family == AF_INET); + /* And let's make sure that it's actually an IPv4 address. */ + GF_ASSERT(sin->sin_family == AF_INET); - inet_ntop (AF_INET, &sin->sin_addr, mnthost, INET_ADDRSTRLEN+1); + inet_ntop(AF_INET, &sin->sin_addr, mnthost, INET_ADDRSTRLEN + 1); - switch (rqstp->rq_proc) { + switch (rqstp->rq_proc) { case NULLPROC: - (void) svc_sendreply (transp, (xdrproc_t) xdr_void, - (char *)NULL); - return; + (void)svc_sendreply(transp, (xdrproc_t)xdr_void, (char *)NULL); + return; case MOUNT3_MNT: - _xdr_argument = (xdrproc_t) xdr_dirpath; - _xdr_result = (xdrproc_t) xdr_mountres3; - local = (char *(*)(char *, - struct svc_req *)) mountudpproc3_mnt_3_svc; - break; + _xdr_argument = (xdrproc_t)xdr_dirpath; + _xdr_result = (xdrproc_t)xdr_mountres3; + local = (char *(*)(char *, + struct svc_req *))mountudpproc3_mnt_3_svc; + break; case MOUNT3_UMNT: - _xdr_argument = (xdrproc_t) xdr_dirpath; - _xdr_result = (xdrproc_t) xdr_mountstat3; - local = (char *(*)(char *, - struct svc_req *)) mountudpproc3_umnt_3_svc; - break; + _xdr_argument = (xdrproc_t)xdr_dirpath; + _xdr_result = (xdrproc_t)xdr_mountstat3; + local = (char *(*)(char *, + struct svc_req *))mountudpproc3_umnt_3_svc; + break; default: - svcerr_noproc (transp); - return; - } - memset ((char *)&argument, 0, sizeof (argument)); - if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, - (caddr_t) &argument)) { - svcerr_decode (transp); - return; - } - result = (*local)((char *)&argument, rqstp); - if (result == NULL) { - gf_msg_debug (GF_MNT, 0, "PROC returned error"); - svcerr_systemerr (transp); - } - if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, - result)) { - gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SVC_ERROR, - "svc_sendreply returned error"); - svcerr_systemerr (transp); - } - if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, - (caddr_t) &argument)) { - gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_ARG_FREE_FAIL, - "Unable to free arguments"); - } - if (result == NULL) - return; - /* free the result */ - switch (rqstp->rq_proc) { + svcerr_noproc(transp); + return; + } + memset((char *)&argument, 0, sizeof(argument)); + if (!svc_getargs(transp, (xdrproc_t)_xdr_argument, (caddr_t)&argument)) { + svcerr_decode(transp); + return; + } + result = (*local)((char *)&argument, rqstp); + if (result == NULL) { + gf_msg_debug(GF_MNT, 0, "PROC returned error"); + svcerr_systemerr(transp); + } + if (result != NULL && + !svc_sendreply(transp, (xdrproc_t)_xdr_result, result)) { + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SVC_ERROR, + "svc_sendreply returned error"); + svcerr_systemerr(transp); + } + if (!svc_freeargs(transp, (xdrproc_t)_xdr_argument, (caddr_t)&argument)) { + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_ARG_FREE_FAIL, + "Unable to free arguments"); + } + if (result == NULL) + return; + /* free the result */ + switch (rqstp->rq_proc) { case MOUNT3_MNT: - res = (mountres3 *) result; - GF_FREE (res->mountres3_u.mountinfo.fhandle.fhandle3_val); - GF_FREE (res->mountres3_u.mountinfo.auth_flavors.auth_flavors_val); - GF_FREE (res); - break; + res = (mountres3 *)result; + GF_FREE(res->mountres3_u.mountinfo.fhandle.fhandle3_val); + GF_FREE(res->mountres3_u.mountinfo.auth_flavors.auth_flavors_val); + GF_FREE(res); + break; case MOUNT3_UMNT: - GF_FREE (result); - break; - } - return; + GF_FREE(result); + break; + } + return; } void * -mount3udp_thread (void *argv) +mount3udp_thread(void *argv) { - xlator_t *nfsx = argv; - register SVCXPRT *transp = NULL; - - GF_ASSERT (nfsx); - - if (glusterfs_this_set(nfsx)) { - gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_XLATOR_SET_FAIL, - "Failed to set xlator, nfs.mount-udp will not work"); - return NULL; - } - - transp = svcudp_create(RPC_ANYSOCK); - if (transp == NULL) { - gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SVC_ERROR, - "svcudp_create error"); - return NULL; - } - if (!svc_register(transp, MOUNT_PROGRAM, MOUNT_V3, - mountudp_program_3, IPPROTO_UDP)) { - gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SVC_ERROR, - "svc_register error"); - return NULL; - } - - svc_run (); - gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SVC_RUN_RETURNED, - "svc_run returned"); + xlator_t *nfsx = argv; + register SVCXPRT *transp = NULL; + + GF_ASSERT(nfsx); + + if (glusterfs_this_set(nfsx)) { + gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_XLATOR_SET_FAIL, + "Failed to set xlator, nfs.mount-udp will not work"); return NULL; + } + + transp = svcudp_create(RPC_ANYSOCK); + if (transp == NULL) { + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SVC_ERROR, + "svcudp_create error"); + return NULL; + } + if (!svc_register(transp, MOUNT_PROGRAM, MOUNT_V3, mountudp_program_3, + IPPROTO_UDP)) { + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SVC_ERROR, + "svc_register error"); + return NULL; + } + + svc_run(); + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SVC_RUN_RETURNED, + "svc_run returned"); + return NULL; } diff --git a/xlators/nfs/server/src/netgroups.c b/xlators/nfs/server/src/netgroups.c index 01b50092a6..092d470720 100644 --- a/xlators/nfs/server/src/netgroups.c +++ b/xlators/nfs/server/src/netgroups.c @@ -16,9 +16,12 @@ #include "parse-utils.h" #include "nfs-messages.h" -static void _nge_print (const struct netgroup_entry *nge); -static void _netgroup_entry_deinit (struct netgroup_entry *ptr); -static void _netgroup_host_deinit (struct netgroup_host *host); +static void +_nge_print(const struct netgroup_entry *nge); +static void +_netgroup_entry_deinit(struct netgroup_entry *ptr); +static void +_netgroup_host_deinit(struct netgroup_host *host); static dict_t *__deleted_entries; static struct parser *ng_file_parser; @@ -31,36 +34,36 @@ static struct parser *ng_host_parser; * failure: -1 */ static int -_ng_init_parsers () +_ng_init_parsers() { - int ret = -1; - - /* Initialize the parsers. The only reason this should - * ever fail is because of 1) memory allocation errors - * 2) the regex in netgroups.h has been changed and no - * longer compiles. - */ - ng_file_parser = parser_init (NG_FILE_PARSE_REGEX); - if (!ng_file_parser) - goto out; - - ng_host_parser = parser_init (NG_HOST_PARSE_REGEX); - if (!ng_host_parser) - goto out; - - ret = 0; + int ret = -1; + + /* Initialize the parsers. The only reason this should + * ever fail is because of 1) memory allocation errors + * 2) the regex in netgroups.h has been changed and no + * longer compiles. + */ + ng_file_parser = parser_init(NG_FILE_PARSE_REGEX); + if (!ng_file_parser) + goto out; + + ng_host_parser = parser_init(NG_HOST_PARSE_REGEX); + if (!ng_host_parser) + goto out; + + ret = 0; out: - return ret; + return ret; } /** * _ng_deinit_parsers - Free the parsers used in this file */ static void -_ng_deinit_parsers () +_ng_deinit_parsers() { - parser_deinit (ng_file_parser); - parser_deinit (ng_host_parser); + parser_deinit(ng_file_parser); + parser_deinit(ng_host_parser); } /** @@ -71,18 +74,18 @@ _ng_deinit_parsers () * Not for external use. */ static struct netgroups_file * -_netgroups_file_init () +_netgroups_file_init() { - struct netgroups_file *file = GF_MALLOC (sizeof (*file), - gf_common_mt_nfs_netgroups); + struct netgroups_file *file = GF_MALLOC(sizeof(*file), + gf_common_mt_nfs_netgroups); - if (!file) - goto out; + if (!file) + goto out; - file->filename = NULL; - file->ng_file_dict = NULL; + file->filename = NULL; + file->ng_file_dict = NULL; out: - return file; + return file; } /** @@ -100,17 +103,17 @@ out: * Not for external use. */ static int -__ngf_free_walk (dict_t *dict, char *key, data_t *val, void *tmp) +__ngf_free_walk(dict_t *dict, char *key, data_t *val, void *tmp) { - struct netgroup_entry *nge = NULL; - - if (val) { - nge = (struct netgroup_entry *)val->data; - _netgroup_entry_deinit (nge); - val->data = NULL; - dict_del (dict, key); /* Remove the key from this dict */ - } - return 0; + struct netgroup_entry *nge = NULL; + + if (val) { + nge = (struct netgroup_entry *)val->data; + _netgroup_entry_deinit(nge); + val->data = NULL; + dict_del(dict, key); /* Remove the key from this dict */ + } + return 0; } /** @@ -128,10 +131,10 @@ __ngf_free_walk (dict_t *dict, char *key, data_t *val, void *tmp) * Not for external use. */ static int -__deleted_entries_free_walk (dict_t *dict, char *key, data_t *val, void *tmp) +__deleted_entries_free_walk(dict_t *dict, char *key, data_t *val, void *tmp) { - dict_del (dict, key); - return 0; + dict_del(dict, key); + return 0; } /** @@ -147,26 +150,26 @@ __deleted_entries_free_walk (dict_t *dict, char *key, data_t *val, void *tmp) * the memory allocated when parsing the file. */ void -ng_file_deinit (struct netgroups_file *ngfile) +ng_file_deinit(struct netgroups_file *ngfile) { - if (!ngfile) { - return; - } + if (!ngfile) { + return; + } - __deleted_entries = dict_new (); - GF_VALIDATE_OR_GOTO (GF_NG, __deleted_entries, out); + __deleted_entries = dict_new(); + GF_VALIDATE_OR_GOTO(GF_NG, __deleted_entries, out); - GF_FREE (ngfile->filename); - dict_foreach (ngfile->ng_file_dict, __ngf_free_walk, NULL); - dict_unref (ngfile->ng_file_dict); - GF_FREE (ngfile); + GF_FREE(ngfile->filename); + dict_foreach(ngfile->ng_file_dict, __ngf_free_walk, NULL); + dict_unref(ngfile->ng_file_dict); + GF_FREE(ngfile); - /* Clean up temporary dict we used to store "freed" names */ - dict_foreach (__deleted_entries, __deleted_entries_free_walk, NULL); - dict_unref (__deleted_entries); - __deleted_entries = NULL; + /* Clean up temporary dict we used to store "freed" names */ + dict_foreach(__deleted_entries, __deleted_entries_free_walk, NULL); + dict_unref(__deleted_entries); + __deleted_entries = NULL; out: - return; + return; } /** @@ -179,11 +182,11 @@ out: * Not for external use. */ static struct netgroup_entry * -_netgroup_entry_init () +_netgroup_entry_init() { - struct netgroup_entry *entry = GF_CALLOC (1, sizeof (*entry), - gf_common_mt_nfs_netgroups); - return entry; + struct netgroup_entry *entry = GF_CALLOC(1, sizeof(*entry), + gf_common_mt_nfs_netgroups); + return entry; } /** @@ -202,17 +205,17 @@ _netgroup_entry_init () * Not for external use. */ static int -__ngh_free_walk (dict_t *dict, char *key, data_t *val, void *tmp) +__ngh_free_walk(dict_t *dict, char *key, data_t *val, void *tmp) { - struct netgroup_host *ngh = NULL; - - if (val) { - ngh = (struct netgroup_host *)val->data; - _netgroup_host_deinit (ngh); - val->data = NULL; - dict_del (dict, key); - } - return 0; + struct netgroup_host *ngh = NULL; + + if (val) { + ngh = (struct netgroup_host *)val->data; + _netgroup_host_deinit(ngh); + val->data = NULL; + dict_del(dict, key); + } + return 0; } /** @@ -231,23 +234,23 @@ __ngh_free_walk (dict_t *dict, char *key, data_t *val, void *tmp) * Not for external use. */ static int -__nge_free_walk (dict_t *dict, char *key, data_t *val, void *tmp) +__nge_free_walk(dict_t *dict, char *key, data_t *val, void *tmp) { - struct netgroup_entry *nge = NULL; + struct netgroup_entry *nge = NULL; - GF_VALIDATE_OR_GOTO (GF_NG, dict, out); + GF_VALIDATE_OR_GOTO(GF_NG, dict, out); - if (val) { - nge = (struct netgroup_entry *)val->data; - if (!dict_get (__deleted_entries, key)) { - _netgroup_entry_deinit (nge); - val->data = NULL; - } - dict_del (dict, key); + if (val) { + nge = (struct netgroup_entry *)val->data; + if (!dict_get(__deleted_entries, key)) { + _netgroup_entry_deinit(nge); + val->data = NULL; } + dict_del(dict, key); + } out: - return 0; + return 0; } /** @@ -264,53 +267,53 @@ out: * Not for external use. */ static void -_netgroup_entry_deinit (struct netgroup_entry *ngentry) +_netgroup_entry_deinit(struct netgroup_entry *ngentry) { - dict_t *ng_dict = NULL; - dict_t *host_dict = NULL; - char *name = NULL; - data_t *dint = NULL; - - if (!ngentry) - return; - - ng_dict = ngentry->netgroup_ngs; - host_dict = ngentry->netgroup_hosts; - - if (ng_dict) { - /* Free the dict of netgroup entries */ - dict_foreach (ng_dict, __nge_free_walk, NULL); - dict_unref (ng_dict); - ngentry->netgroup_ngs = NULL; - } + dict_t *ng_dict = NULL; + dict_t *host_dict = NULL; + char *name = NULL; + data_t *dint = NULL; - if (host_dict) { - /* Free the dict of host entries */ - dict_foreach (host_dict, __ngh_free_walk, NULL); - dict_unref (host_dict); - ngentry->netgroup_hosts = NULL; - } + if (!ngentry) + return; - if (ngentry->netgroup_name) { - /* Keep track of the netgroup names we've deallocated - * We need to do this because of the nature of this data - * structure. This data structure may hold multiple - * pointers to an already freed object, but these are - * uniquely identifiable by the name. We keep track - * of these names so when we encounter a key who has - * an association to an already freed object, we don't - * free it twice. - */ - name = strdupa (ngentry->netgroup_name); + ng_dict = ngentry->netgroup_ngs; + host_dict = ngentry->netgroup_hosts; + + if (ng_dict) { + /* Free the dict of netgroup entries */ + dict_foreach(ng_dict, __nge_free_walk, NULL); + dict_unref(ng_dict); + ngentry->netgroup_ngs = NULL; + } + + if (host_dict) { + /* Free the dict of host entries */ + dict_foreach(host_dict, __ngh_free_walk, NULL); + dict_unref(host_dict); + ngentry->netgroup_hosts = NULL; + } + + if (ngentry->netgroup_name) { + /* Keep track of the netgroup names we've deallocated + * We need to do this because of the nature of this data + * structure. This data structure may hold multiple + * pointers to an already freed object, but these are + * uniquely identifiable by the name. We keep track + * of these names so when we encounter a key who has + * an association to an already freed object, we don't + * free it twice. + */ + name = strdupa(ngentry->netgroup_name); - dint = int_to_data (1); - dict_set (__deleted_entries, name, dint); + dint = int_to_data(1); + dict_set(__deleted_entries, name, dint); - GF_FREE (ngentry->netgroup_name); - ngentry->netgroup_name = NULL; - } + GF_FREE(ngentry->netgroup_name); + ngentry->netgroup_name = NULL; + } - GF_FREE (ngentry); + GF_FREE(ngentry); } /** @@ -324,11 +327,11 @@ _netgroup_entry_deinit (struct netgroup_entry *ngentry) * Not for external use. */ static struct netgroup_host * -_netgroup_host_init () +_netgroup_host_init() { - struct netgroup_host *host = GF_CALLOC (1, sizeof (*host), - gf_common_mt_nfs_netgroups); - return host; + struct netgroup_host *host = GF_CALLOC(1, sizeof(*host), + gf_common_mt_nfs_netgroups); + return host; } /** @@ -342,23 +345,23 @@ _netgroup_host_init () * Not for external use. */ static void -_netgroup_host_deinit (struct netgroup_host *host) +_netgroup_host_deinit(struct netgroup_host *host) { - /* Validate args */ - GF_VALIDATE_OR_GOTO (GF_NG, host, err); + /* Validate args */ + GF_VALIDATE_OR_GOTO(GF_NG, host, err); - GF_FREE (host->hostname); - host->hostname = NULL; + GF_FREE(host->hostname); + host->hostname = NULL; - GF_FREE (host->user); - host->user = NULL; + GF_FREE(host->user); + host->user = NULL; - GF_FREE (host->domain); - host->domain = NULL; + GF_FREE(host->domain); + host->domain = NULL; - GF_FREE (host); + GF_FREE(host); err: - return; + return; } /** @@ -377,19 +380,19 @@ err: * Not for external use. */ static struct netgroup_entry * -_nge_dict_get (dict_t *dict, const char *ngname) +_nge_dict_get(dict_t *dict, const char *ngname) { - data_t *ngdata = NULL; + data_t *ngdata = NULL; - /* Validate args */ - GF_VALIDATE_OR_GOTO (GF_NG, dict, err); - GF_VALIDATE_OR_GOTO (GF_NG, ngname, err); + /* Validate args */ + GF_VALIDATE_OR_GOTO(GF_NG, dict, err); + GF_VALIDATE_OR_GOTO(GF_NG, ngname, err); - ngdata = dict_get (dict, (char *)ngname); - if (ngdata) - return (struct netgroup_entry *)ngdata->data; + ngdata = dict_get(dict, (char *)ngname); + if (ngdata) + return (struct netgroup_entry *)ngdata->data; err: - return NULL; + return NULL; } /** @@ -405,17 +408,17 @@ err: * Not for external use. */ static void -_nge_dict_insert (dict_t *dict, struct netgroup_entry *nge) +_nge_dict_insert(dict_t *dict, struct netgroup_entry *nge) { - data_t *ngdata = NULL; + data_t *ngdata = NULL; - GF_VALIDATE_OR_GOTO (GF_NG, dict, err); - GF_VALIDATE_OR_GOTO (GF_NG, nge, err); + GF_VALIDATE_OR_GOTO(GF_NG, dict, err); + GF_VALIDATE_OR_GOTO(GF_NG, nge, err); - ngdata = bin_to_data (nge, sizeof (*nge)); - dict_set (dict, nge->netgroup_name, ngdata); + ngdata = bin_to_data(nge, sizeof(*nge)); + dict_set(dict, nge->netgroup_name, ngdata); err: - return; + return; } /** @@ -434,21 +437,21 @@ err: * Externally usable. */ struct netgroup_host * -ngh_dict_get (dict_t *dict, const char *hostname) +ngh_dict_get(dict_t *dict, const char *hostname) { - data_t *ngdata = NULL; + data_t *ngdata = NULL; - GF_VALIDATE_OR_GOTO (GF_NG, dict, err); - GF_VALIDATE_OR_GOTO (GF_NG, hostname, err); + GF_VALIDATE_OR_GOTO(GF_NG, dict, err); + GF_VALIDATE_OR_GOTO(GF_NG, hostname, err); - ngdata = dict_get (dict, (char *)hostname); - if (!ngdata) - goto err; + ngdata = dict_get(dict, (char *)hostname); + if (!ngdata) + goto err; - return (struct netgroup_host *)ngdata->data; + return (struct netgroup_host *)ngdata->data; err: - return NULL; + return NULL; } /** @@ -464,18 +467,18 @@ err: * Not for external use. */ static void -_ngh_dict_insert (dict_t *dict, struct netgroup_host *ngh) +_ngh_dict_insert(dict_t *dict, struct netgroup_host *ngh) { - data_t *ngdata = NULL; + data_t *ngdata = NULL; - /* Validate args */ - GF_VALIDATE_OR_GOTO (GF_NG, dict, err); - GF_VALIDATE_OR_GOTO (GF_NG, ngh, err); + /* Validate args */ + GF_VALIDATE_OR_GOTO(GF_NG, dict, err); + GF_VALIDATE_OR_GOTO(GF_NG, ngh, err); - ngdata = bin_to_data (ngh, sizeof (*ngh)); - dict_set (dict, ngh->hostname, ngdata); + ngdata = bin_to_data(ngh, sizeof(*ngh)); + dict_set(dict, ngh->hostname, ngdata); err: - return; + return; } /** @@ -489,15 +492,15 @@ err: * Not for external use. */ static void -_ngh_print (const struct netgroup_host *ngh) +_ngh_print(const struct netgroup_host *ngh) { - /* Validate args */ - GF_VALIDATE_OR_GOTO (GF_NG, ngh, err); + /* Validate args */ + GF_VALIDATE_OR_GOTO(GF_NG, ngh, err); - printf ("(%s,%s,%s)", ngh->hostname, ngh->user ? ngh->user : "", - ngh->domain ? ngh->domain : ""); + printf("(%s,%s,%s)", ngh->hostname, ngh->user ? ngh->user : "", + ngh->domain ? ngh->domain : ""); err: - return; + return; } /** @@ -517,12 +520,12 @@ err: * Not for external use. */ static int -__nge_print_walk (dict_t *dict, char *key, data_t *val, void *tmp) +__nge_print_walk(dict_t *dict, char *key, data_t *val, void *tmp) { - if (val) - _nge_print ((struct netgroup_entry *)val->data); + if (val) + _nge_print((struct netgroup_entry *)val->data); - return 0; + return 0; } /** @@ -543,12 +546,12 @@ __nge_print_walk (dict_t *dict, char *key, data_t *val, void *tmp) * Not for external use. */ static int -__ngh_print_walk (dict_t *dict, char *key, data_t *val, void *tmp) +__ngh_print_walk(dict_t *dict, char *key, data_t *val, void *tmp) { - if (val) - _ngh_print ((struct netgroup_host *)val->data); + if (val) + _ngh_print((struct netgroup_host *)val->data); - return 0; + return 0; } /** @@ -562,20 +565,20 @@ __ngh_print_walk (dict_t *dict, char *key, data_t *val, void *tmp) * Not for external use. */ static void -_nge_print (const struct netgroup_entry *nge) +_nge_print(const struct netgroup_entry *nge) { - /* Validate args */ - GF_VALIDATE_OR_GOTO (GF_NG, nge, err); + /* Validate args */ + GF_VALIDATE_OR_GOTO(GF_NG, nge, err); - printf ("%s ", nge->netgroup_name); - if (nge->netgroup_ngs) - dict_foreach (nge->netgroup_ngs, __nge_print_walk, NULL); + printf("%s ", nge->netgroup_name); + if (nge->netgroup_ngs) + dict_foreach(nge->netgroup_ngs, __nge_print_walk, NULL); - if (nge->netgroup_hosts) - dict_foreach (nge->netgroup_hosts, __ngh_print_walk, NULL); + if (nge->netgroup_hosts) + dict_foreach(nge->netgroup_hosts, __ngh_print_walk, NULL); err: - return; + return; } /** @@ -596,16 +599,16 @@ err: * Not for external use. */ static int -__ngf_print_walk (dict_t *dict, char *key, data_t *val, void *tmp) +__ngf_print_walk(dict_t *dict, char *key, data_t *val, void *tmp) { - struct netgroup_entry *snge = NULL; - - if (val) { - snge = (struct netgroup_entry *)val->data; - _nge_print (snge); - printf ("\n"); - } - return 0; + struct netgroup_entry *snge = NULL; + + if (val) { + snge = (struct netgroup_entry *)val->data; + _nge_print(snge); + printf("\n"); + } + return 0; } /** @@ -625,9 +628,9 @@ __ngf_print_walk (dict_t *dict, char *key, data_t *val, void *tmp) * Can be called on any valid 'struct netgroups_file *' type. */ void -ng_file_print (const struct netgroups_file *ngfile) +ng_file_print(const struct netgroups_file *ngfile) { - dict_foreach (ngfile->ng_file_dict, __ngf_print_walk, NULL); + dict_foreach(ngfile->ng_file_dict, __ngf_print_walk, NULL); } /** @@ -646,22 +649,21 @@ ng_file_print (const struct netgroups_file *ngfile) * *' as the lookup key. */ struct netgroup_entry * -ng_file_get_netgroup (const struct netgroups_file *ngfile, const char *netgroup) +ng_file_get_netgroup(const struct netgroups_file *ngfile, const char *netgroup) { - data_t *ndata = NULL; + data_t *ndata = NULL; - GF_VALIDATE_OR_GOTO (GF_NG, ngfile, err); - GF_VALIDATE_OR_GOTO (GF_NG, netgroup, err); + GF_VALIDATE_OR_GOTO(GF_NG, ngfile, err); + GF_VALIDATE_OR_GOTO(GF_NG, netgroup, err); - ndata = dict_get (ngfile->ng_file_dict, - (char *)netgroup); - if (!ndata) - goto err; + ndata = dict_get(ngfile->ng_file_dict, (char *)netgroup); + if (!ndata) + goto err; - return (struct netgroup_entry *)ndata->data; + return (struct netgroup_entry *)ndata->data; err: - return NULL; + return NULL; } /** @@ -679,30 +681,30 @@ err: * Not for external use. */ static gf_boolean_t -__check_host_entry_str (const char *host_str) +__check_host_entry_str(const char *host_str) { - unsigned int comma_count = 0; - unsigned int i = 0; - gf_boolean_t str_valid = _gf_true; + unsigned int comma_count = 0; + unsigned int i = 0; + gf_boolean_t str_valid = _gf_true; - GF_VALIDATE_OR_GOTO (GF_NG, host_str, out); + GF_VALIDATE_OR_GOTO(GF_NG, host_str, out); - for (i = 0; i < strlen (host_str); i++) { - if (host_str[i] == ',') - comma_count++; + for (i = 0; i < strlen(host_str); i++) { + if (host_str[i] == ',') + comma_count++; - /* Spaces are not allowed in this string. e.g, (a,b,c) is valid - * but (a, b,c) is not. - */ - if (host_str[i] == ' ') { - str_valid = _gf_false; - goto out; - } + /* Spaces are not allowed in this string. e.g, (a,b,c) is valid + * but (a, b,c) is not. + */ + if (host_str[i] == ' ') { + str_valid = _gf_false; + goto out; } + } - str_valid = (comma_count == 2); + str_valid = (comma_count == 2); out: - return str_valid; + return str_valid; } /** @@ -718,66 +720,65 @@ out: * Not for external use. */ static int -_parse_ng_host (char *ng_str, struct netgroup_host **ngh) +_parse_ng_host(char *ng_str, struct netgroup_host **ngh) { - struct netgroup_host *ng_host = NULL; - unsigned int parts = 0; - char *match = NULL; - int ret = -EINVAL; - - GF_VALIDATE_OR_GOTO (GF_NG, ng_str, out); - GF_VALIDATE_OR_GOTO (GF_NG, ngh, out); - - if (!__check_host_entry_str (ng_str)) { - ret = 1; /* Parse failed */ - goto out; - } - - ret = parser_set_string (ng_host_parser, ng_str); - if (ret < 0) - goto out; - - gf_msg_trace (GF_NG, 0, "parsing host string: %s", ng_str); - - ng_host = _netgroup_host_init (); - GF_CHECK_ALLOC (ng_host, ret, free_and_out); /* Sets ret to -ENOMEM on - * failure. - */ - while ((match = parser_get_next_match (ng_host_parser)) != NULL) { - gf_msg_trace (GF_NG, 0, "found match: %s (parts=%d)", match, - parts); - - switch (parts) { - case 0: - ng_host->hostname = match; - break; - case 1: - ng_host->user = match; - break; - case 2: - ng_host->domain = match; - break; - default: - GF_FREE (match); - break; - }; - - /* We only allow three parts in the host string; - * The format for the string is (a,b,c) - */ - parts++; - if (parts > 2) - break; - } + struct netgroup_host *ng_host = NULL; + unsigned int parts = 0; + char *match = NULL; + int ret = -EINVAL; + + GF_VALIDATE_OR_GOTO(GF_NG, ng_str, out); + GF_VALIDATE_OR_GOTO(GF_NG, ngh, out); + + if (!__check_host_entry_str(ng_str)) { + ret = 1; /* Parse failed */ + goto out; + } + + ret = parser_set_string(ng_host_parser, ng_str); + if (ret < 0) + goto out; + + gf_msg_trace(GF_NG, 0, "parsing host string: %s", ng_str); + + ng_host = _netgroup_host_init(); + GF_CHECK_ALLOC(ng_host, ret, free_and_out); /* Sets ret to -ENOMEM on + * failure. + */ + while ((match = parser_get_next_match(ng_host_parser)) != NULL) { + gf_msg_trace(GF_NG, 0, "found match: %s (parts=%d)", match, parts); + + switch (parts) { + case 0: + ng_host->hostname = match; + break; + case 1: + ng_host->user = match; + break; + case 2: + ng_host->domain = match; + break; + default: + GF_FREE(match); + break; + }; + + /* We only allow three parts in the host string; + * The format for the string is (a,b,c) + */ + parts++; + if (parts > 2) + break; + } - /* Set the parameter */ - *ngh = ng_host; - ret = 0; + /* Set the parameter */ + *ngh = ng_host; + ret = 0; free_and_out: - parser_unset_string (ng_host_parser); + parser_unset_string(ng_host_parser); out: - return ret; + return ret; } /** @@ -796,50 +797,47 @@ out: * Not for external use. */ static int -_ng_handle_host_part (char *match, struct netgroup_entry *ngp) +_ng_handle_host_part(char *match, struct netgroup_entry *ngp) { - struct netgroup_host *ngh = NULL; - int ret = -EINVAL; - - GF_VALIDATE_OR_GOTO (GF_NG, match, out); - GF_VALIDATE_OR_GOTO (GF_NG, ngp, out); - - if (!ngp->netgroup_name) { - gf_msg (GF_NG, GF_LOG_WARNING, EINVAL, NFS_MSG_INVALID_ENTRY, - "Invalid: Line starts with hostname!"); - goto out; - } - - /* Parse the host string and get a struct for it */ - ret = _parse_ng_host (match, &ngh); - if (ret < 0) { - gf_msg (GF_NG, GF_LOG_CRITICAL, -ret, NFS_MSG_PARSE_FAIL, - "Critical error : %s", strerror (-ret)); - goto out; - } - if (ret != 0) { - /* Cannot change to gf_msg - * gf_msg not giving output to STDOUT - * Bug id : BZ1215017 - */ - gf_log (GF_NG, GF_LOG_WARNING, - "Parse error for: %s", match); - goto out; - } - + struct netgroup_host *ngh = NULL; + int ret = -EINVAL; + + GF_VALIDATE_OR_GOTO(GF_NG, match, out); + GF_VALIDATE_OR_GOTO(GF_NG, ngp, out); + + if (!ngp->netgroup_name) { + gf_msg(GF_NG, GF_LOG_WARNING, EINVAL, NFS_MSG_INVALID_ENTRY, + "Invalid: Line starts with hostname!"); + goto out; + } + + /* Parse the host string and get a struct for it */ + ret = _parse_ng_host(match, &ngh); + if (ret < 0) { + gf_msg(GF_NG, GF_LOG_CRITICAL, -ret, NFS_MSG_PARSE_FAIL, + "Critical error : %s", strerror(-ret)); + goto out; + } + if (ret != 0) { + /* Cannot change to gf_msg + * gf_msg not giving output to STDOUT + * Bug id : BZ1215017 + */ + gf_log(GF_NG, GF_LOG_WARNING, "Parse error for: %s", match); + goto out; + } - /* Make dict for the parent entry's netgroup hosts */ - if (!ngp->netgroup_hosts) { - ngp->netgroup_hosts = dict_new (); - GF_CHECK_ALLOC (ngp->netgroup_hosts, ret, - out); - } + /* Make dict for the parent entry's netgroup hosts */ + if (!ngp->netgroup_hosts) { + ngp->netgroup_hosts = dict_new(); + GF_CHECK_ALLOC(ngp->netgroup_hosts, ret, out); + } - /* Insert this entry into the parent netgroup dict */ - _ngh_dict_insert (ngp->netgroup_hosts, ngh); + /* Insert this entry into the parent netgroup dict */ + _ngh_dict_insert(ngp->netgroup_hosts, ngh); out: - return ret; + return ret; } /** @@ -861,29 +859,29 @@ out: * Not for external use. */ static int -_ng_setup_netgroup_entry (char *match, struct netgroups_file *file, - struct netgroup_entry **ng_entry) +_ng_setup_netgroup_entry(char *match, struct netgroups_file *file, + struct netgroup_entry **ng_entry) { - struct netgroup_entry *nge = NULL; - int ret = -EINVAL; + struct netgroup_entry *nge = NULL; + int ret = -EINVAL; - GF_VALIDATE_OR_GOTO (GF_NG, match, out); - GF_VALIDATE_OR_GOTO (GF_NG, file, out); - GF_VALIDATE_OR_GOTO (GF_NG, ng_entry, out); + GF_VALIDATE_OR_GOTO(GF_NG, match, out); + GF_VALIDATE_OR_GOTO(GF_NG, file, out); + GF_VALIDATE_OR_GOTO(GF_NG, ng_entry, out); - nge = _netgroup_entry_init (); - GF_CHECK_ALLOC (nge, ret, out); + nge = _netgroup_entry_init(); + GF_CHECK_ALLOC(nge, ret, out); - nge->netgroup_name = match; + nge->netgroup_name = match; - /* Insert this new entry into the file dict */ - _nge_dict_insert (file->ng_file_dict, nge); + /* Insert this new entry into the file dict */ + _nge_dict_insert(file->ng_file_dict, nge); - *ng_entry = nge; + *ng_entry = nge; - ret = 0; + ret = 0; out: - return ret; + return ret; } /** @@ -952,119 +950,118 @@ out: * Not for external use. */ static int -_parse_ng_line (char *ng_str, struct netgroups_file *file, - struct netgroup_entry **ng_entry) +_parse_ng_line(char *ng_str, struct netgroups_file *file, + struct netgroup_entry **ng_entry) { - struct netgroup_entry *ngp = NULL; /* Parent netgroup entry */ - struct netgroup_entry *nge = NULL; /* Generic netgroup entry */ - char *match = NULL; - int ret = -EINVAL; - unsigned int num_entries = 0; - - /* Validate arguments */ - GF_VALIDATE_OR_GOTO (GF_NG, ng_str, out); - GF_VALIDATE_OR_GOTO (GF_NG, file, out); - - if (*ng_str == ' ' || *ng_str == '\0' || *ng_str == '\n') { - ret = 0; - goto out; - } + struct netgroup_entry *ngp = NULL; /* Parent netgroup entry */ + struct netgroup_entry *nge = NULL; /* Generic netgroup entry */ + char *match = NULL; + int ret = -EINVAL; + unsigned int num_entries = 0; - ret = parser_set_string (ng_file_parser, ng_str); - if (ret < 0) - goto out; + /* Validate arguments */ + GF_VALIDATE_OR_GOTO(GF_NG, ng_str, out); + GF_VALIDATE_OR_GOTO(GF_NG, file, out); - /* This is the first name in the line, and should be the - * parent netgroup entry. - */ - match = parser_get_next_match (ng_file_parser); - if (!match) { - ret = 1; - gf_msg (GF_NG, GF_LOG_WARNING, 0, - NFS_MSG_FIND_FIRST_MATCH_FAIL, "Unable to find " - "first match."); - gf_msg (GF_NG, GF_LOG_WARNING, 0, NFS_MSG_PARSE_FAIL, - "Error parsing str: %s", ng_str); - goto out; + if (*ng_str == ' ' || *ng_str == '\0' || *ng_str == '\n') { + ret = 0; + goto out; + } + + ret = parser_set_string(ng_file_parser, ng_str); + if (ret < 0) + goto out; + + /* This is the first name in the line, and should be the + * parent netgroup entry. + */ + match = parser_get_next_match(ng_file_parser); + if (!match) { + ret = 1; + gf_msg(GF_NG, GF_LOG_WARNING, 0, NFS_MSG_FIND_FIRST_MATCH_FAIL, + "Unable to find " + "first match."); + gf_msg(GF_NG, GF_LOG_WARNING, 0, NFS_MSG_PARSE_FAIL, + "Error parsing str: %s", ng_str); + goto out; + } + + /* Lookup to see if the match already exists, + * if not, set the parent. + */ + ngp = _nge_dict_get(file->ng_file_dict, match); + if (!ngp) { + ret = _ng_setup_netgroup_entry(match, file, &ngp); + if (ret < 0) { + /* Bubble up error to caller. We don't need to free ngp + * here because this can only fail if allocating the + * struct fails. + */ + goto out; } + } else + GF_FREE(match); - /* Lookup to see if the match already exists, - * if not, set the parent. + if (!ngp->netgroup_ngs) { + /* If a netgroup dict has not been allocated + * for this parent, allocate it. */ - ngp = _nge_dict_get (file->ng_file_dict, match); - if (!ngp) { - ret = _ng_setup_netgroup_entry (match, file, &ngp); + ngp->netgroup_ngs = dict_new(); + GF_CHECK_ALLOC(ngp->netgroup_ngs, ret, out); + /* No need to free anything here since ngp is already + * a part of the file. When the file gets + * deallocated, we will free ngp. + */ + } + + while ((match = parser_get_next_match(ng_file_parser)) != NULL) { + num_entries++; + /* This means that we hit a host entry in the line */ + if (*match == '(') { + ret = _ng_handle_host_part(match, ngp); + GF_FREE(match); + if (ret != 0) { + /* If parsing the host fails, bubble the error + * code up to the caller. + */ + goto out; + } + } else { + nge = _nge_dict_get(file->ng_file_dict, match); + if (!nge) { + ret = _ng_setup_netgroup_entry(match, file, &nge); if (ret < 0) { - /* Bubble up error to caller. We don't need to free ngp - * here because this can only fail if allocating the - * struct fails. - */ - goto out; + /* Bubble up error to caller. We don't + * need to free nge here because this + * can only fail if allocating the + * struct fails. + */ + goto out; } - } else - GF_FREE (match); + } else + GF_FREE(match); - if (!ngp->netgroup_ngs) { - /* If a netgroup dict has not been allocated - * for this parent, allocate it. - */ - ngp->netgroup_ngs = dict_new (); - GF_CHECK_ALLOC (ngp->netgroup_ngs, ret, out); - /* No need to free anything here since ngp is already - * a part of the file. When the file gets - * deallocated, we will free ngp. - */ - } - - while ((match = parser_get_next_match (ng_file_parser)) != NULL) { - num_entries++; - /* This means that we hit a host entry in the line */ - if (*match == '(') { - ret = _ng_handle_host_part (match, ngp); - GF_FREE (match); - if (ret != 0) { - /* If parsing the host fails, bubble the error - * code up to the caller. - */ - goto out; - } - } else { - nge = _nge_dict_get (file->ng_file_dict, match); - if (!nge) { - ret = _ng_setup_netgroup_entry (match, file, - &nge); - if (ret < 0) { - /* Bubble up error to caller. We don't - * need to free nge here because this - * can only fail if allocating the - * struct fails. - */ - goto out; - } - } else - GF_FREE (match); - - /* Insert the netgroup into the parent's dict */ - _nge_dict_insert (ngp->netgroup_ngs, nge); - } + /* Insert the netgroup into the parent's dict */ + _nge_dict_insert(ngp->netgroup_ngs, nge); } + } - /* If there are no entries on the RHS, log an error, but continue */ - if (!num_entries) { - /* Cannot change to gf_msg - * gf_msg not giving output to STDOUT - * Bug id : BZ1215017 - */ - gf_log (GF_NG, GF_LOG_WARNING, - "No netgroups were specified except for the parent."); - } + /* If there are no entries on the RHS, log an error, but continue */ + if (!num_entries) { + /* Cannot change to gf_msg + * gf_msg not giving output to STDOUT + * Bug id : BZ1215017 + */ + gf_log(GF_NG, GF_LOG_WARNING, + "No netgroups were specified except for the parent."); + } - *ng_entry = ngp; - ret = 0; + *ng_entry = ngp; + ret = 0; out: - parser_unset_string (ng_file_parser); - return ret; + parser_unset_string(ng_file_parser); + return ret; } /** @@ -1082,84 +1079,83 @@ out: * Externally facing function */ struct netgroups_file * -ng_file_parse (const char *filepath) +ng_file_parse(const char *filepath) { - FILE *fp = NULL; - size_t len = 0; - size_t read = 0; - char *line = NULL; - struct netgroups_file *file = NULL; - struct netgroup_entry *nge = NULL; - int ret = 0; - - GF_VALIDATE_OR_GOTO (GF_NG, filepath, err); - - fp = fopen (filepath, "r"); - if (!fp) - goto err; - - file = _netgroups_file_init (); - if (!file) - goto err; - - file->ng_file_dict = dict_new (); - if (!file->ng_file_dict) { - gf_msg (GF_NG, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to allocate netgroup file dict"); - goto err; - } - - file->filename = gf_strdup (filepath); - if (!file->filename) { - gf_msg (GF_NG, GF_LOG_CRITICAL, errno, NFS_MSG_FILE_OP_FAILED, - "Failed to duplicate filename"); - goto err; + FILE *fp = NULL; + size_t len = 0; + size_t read = 0; + char *line = NULL; + struct netgroups_file *file = NULL; + struct netgroup_entry *nge = NULL; + int ret = 0; + + GF_VALIDATE_OR_GOTO(GF_NG, filepath, err); + + fp = fopen(filepath, "r"); + if (!fp) + goto err; + + file = _netgroups_file_init(); + if (!file) + goto err; + + file->ng_file_dict = dict_new(); + if (!file->ng_file_dict) { + gf_msg(GF_NG, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to allocate netgroup file dict"); + goto err; + } + + file->filename = gf_strdup(filepath); + if (!file->filename) { + gf_msg(GF_NG, GF_LOG_CRITICAL, errno, NFS_MSG_FILE_OP_FAILED, + "Failed to duplicate filename"); + goto err; + } + + ret = _ng_init_parsers(); + if (ret < 0) + goto err; + + /* Read the file line-by-line and parse it */ + while ((read = getline(&line, &len, fp)) != -1) { + if (*line == '#') /* Lines starting with # are comments */ + continue; + + /* Parse the line into a netgroup entry */ + ret = _parse_ng_line(line, file, &nge); + if (ret == -ENOMEM) { + gf_msg(GF_NG, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY, + "Allocation error " + "while parsing line!"); + goto err; } - - ret = _ng_init_parsers (); - if (ret < 0) - goto err; - - /* Read the file line-by-line and parse it */ - while ((read = getline (&line, &len, fp)) != -1) { - if (*line == '#') /* Lines starting with # are comments */ - continue; - - /* Parse the line into a netgroup entry */ - ret = _parse_ng_line (line, file, &nge); - if (ret == -ENOMEM) { - gf_msg (GF_NG, GF_LOG_CRITICAL, ENOMEM, - NFS_MSG_NO_MEMORY, "Allocation error " - "while parsing line!"); - goto err; - } - if (ret != 0) { - gf_msg_debug (GF_NG, 0, "Failed to parse line %s", - line); - continue; - } + if (ret != 0) { + gf_msg_debug(GF_NG, 0, "Failed to parse line %s", line); + continue; } + } - /* line got allocated through getline(), don't use GF_FREE() for it */ - free (line); + /* line got allocated through getline(), don't use GF_FREE() for it */ + free(line); - if (fp) - fclose(fp); + if (fp) + fclose(fp); - _ng_deinit_parsers (); + _ng_deinit_parsers(); - return file; + return file; err: - if (line) - free(line); + if (line) + free(line); - if (file) - ng_file_deinit (file); + if (file) + ng_file_deinit(file); - _ng_deinit_parsers (); + _ng_deinit_parsers(); - if (fp) - fclose (fp); - return NULL; + if (fp) + fclose(fp); + return NULL; } diff --git a/xlators/nfs/server/src/nfs-common.c b/xlators/nfs/server/src/nfs-common.c index 2f742d4436..2e8d401ba5 100644 --- a/xlators/nfs/server/src/nfs-common.c +++ b/xlators/nfs/server/src/nfs-common.c @@ -24,293 +24,285 @@ #include <libgen.h> xlator_t * -nfs_xlid_to_xlator (xlator_list_t *cl, uint8_t xlid) +nfs_xlid_to_xlator(xlator_list_t *cl, uint8_t xlid) { - xlator_t *xl = NULL; - uint8_t id = 0; - - while (id <= xlid) { - if (!cl) { - xl = NULL; - break; - } - - xl = cl->xlator; - cl = cl->next; - id++; + xlator_t *xl = NULL; + uint8_t id = 0; + + while (id <= xlid) { + if (!cl) { + xl = NULL; + break; } - return xl; -} + xl = cl->xlator; + cl = cl->next; + id++; + } + return xl; +} xlator_t * -nfs_path_to_xlator (xlator_list_t *cl, char *path) +nfs_path_to_xlator(xlator_list_t *cl, char *path) { - return NULL; + return NULL; } - uint16_t -nfs_xlator_to_xlid (xlator_list_t *cl, xlator_t *xl) +nfs_xlator_to_xlid(xlator_list_t *cl, xlator_t *xl) { - uint16_t xlid = 0; + uint16_t xlid = 0; - if ((!cl) || (!xl)) - return 0; + if ((!cl) || (!xl)) + return 0; - while (cl) { - if (xl == cl->xlator) - break; - cl = cl->next; - ++xlid; - } + while (cl) { + if (xl == cl->xlator) + break; + cl = cl->next; + ++xlid; + } - return xlid; + return xlid; } - xlator_t * -nfs_mntpath_to_xlator (xlator_list_t *cl, char *path) +nfs_mntpath_to_xlator(xlator_list_t *cl, char *path) { - char *volname = NULL; /* volume name only */ - char *volptr = NULL; /* ptr to original volname */ - size_t pathlen = -1; - xlator_t *targetxl = NULL; - int i = 0; - - if ((!cl) || (!path)) - return NULL; - - gf_msg_trace (GF_NFS, 0, "Subvolume search: %s", path); - - volname = volptr = gf_strdup (path); - if (!volname) - return NULL; - - if (volname[0] == '/') - volname++; - - pathlen = strlen (volname); - for (i = 0; i < pathlen; i++) { - if (volname[i] == '/') { - volname[i] = '\0'; - break; - } - } + char *volname = NULL; /* volume name only */ + char *volptr = NULL; /* ptr to original volname */ + size_t pathlen = -1; + xlator_t *targetxl = NULL; + int i = 0; - while (cl) { - gf_msg_trace (GF_NFS, 0, "Volname: %s and cl->xlator->name: %s", - volname, cl->xlator->name); + if ((!cl) || (!path)) + return NULL; - if (strcmp (volname, cl->xlator->name) == 0) { - targetxl = cl->xlator; - break; - } + gf_msg_trace(GF_NFS, 0, "Subvolume search: %s", path); - cl = cl->next; + volname = volptr = gf_strdup(path); + if (!volname) + return NULL; + + if (volname[0] == '/') + volname++; + + pathlen = strlen(volname); + for (i = 0; i < pathlen; i++) { + if (volname[i] == '/') { + volname[i] = '\0'; + break; } + } - GF_FREE (volptr); + while (cl) { + gf_msg_trace(GF_NFS, 0, "Volname: %s and cl->xlator->name: %s", volname, + cl->xlator->name); - return targetxl; -} + if (strcmp(volname, cl->xlator->name) == 0) { + targetxl = cl->xlator; + break; + } + + cl = cl->next; + } + GF_FREE(volptr); + + return targetxl; +} void -nfs_loc_wipe (loc_t *loc) +nfs_loc_wipe(loc_t *loc) { - loc_wipe (loc); + loc_wipe(loc); } - int -nfs_loc_copy (loc_t *dst, loc_t *src) +nfs_loc_copy(loc_t *dst, loc_t *src) { - int ret = -1; + int ret = -1; - ret = loc_copy (dst, src); + ret = loc_copy(dst, src); - return ret; + return ret; } - int -nfs_loc_fill (loc_t *loc, inode_t *inode, inode_t *parent, char *path) +nfs_loc_fill(loc_t *loc, inode_t *inode, inode_t *parent, char *path) { - int ret = -EFAULT; + 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 (!loc) + return ret; - 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++; + 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; + ret = 0; loc_wipe: - if (ret < 0) - nfs_loc_wipe (loc); + if (ret < 0) + nfs_loc_wipe(loc); - return ret; + return ret; } - int -nfs_inode_loc_fill (inode_t *inode, loc_t *loc, int how) +nfs_inode_loc_fill(inode_t *inode, loc_t *loc, int how) { - char *resolvedpath = NULL; - inode_t *parent = NULL; - int ret = -EFAULT; - - if ((!inode) || (!loc)) - return ret; - - /* If gfid is not null, then the inode is already linked to - * the inode table, and not a newly created one. For newly - * created inode, inode_path returns null gfid as the path. - */ - if (!gf_uuid_is_null (inode->gfid)) { - ret = inode_path (inode, NULL, &resolvedpath); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, - NFS_MSG_PATH_RESOLVE_FAIL, "path resolution " - "failed %s", resolvedpath); - goto err; - } - } + char *resolvedpath = NULL; + inode_t *parent = NULL; + int ret = -EFAULT; - if (resolvedpath == NULL) { - char tmp_path[GFID_STR_PFX_LEN + 1] = {0,}; - snprintf (tmp_path, sizeof (tmp_path), "<gfid:%s>", - uuid_utoa (loc->gfid)); - resolvedpath = gf_strdup (tmp_path); - } else { - parent = inode_parent (inode, loc->pargfid, NULL); - } + if ((!inode) || (!loc)) + return ret; - ret = nfs_loc_fill (loc, inode, parent, resolvedpath); + /* If gfid is not null, then the inode is already linked to + * the inode table, and not a newly created one. For newly + * created inode, inode_path returns null gfid as the path. + */ + if (!gf_uuid_is_null(inode->gfid)) { + ret = inode_path(inode, NULL, &resolvedpath); if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, -ret, - NFS_MSG_LOC_FILL_RESOLVE_FAIL, - "loc fill resolution failed %s", resolvedpath); - goto err; + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PATH_RESOLVE_FAIL, + "path resolution " + "failed %s", + resolvedpath); + goto err; } - - ret = 0; + } + + if (resolvedpath == NULL) { + char tmp_path[GFID_STR_PFX_LEN + 1] = { + 0, + }; + snprintf(tmp_path, sizeof(tmp_path), "<gfid:%s>", uuid_utoa(loc->gfid)); + resolvedpath = gf_strdup(tmp_path); + } else { + parent = inode_parent(inode, loc->pargfid, NULL); + } + + ret = nfs_loc_fill(loc, inode, parent, resolvedpath); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_LOC_FILL_RESOLVE_FAIL, + "loc fill resolution failed %s", resolvedpath); + goto err; + } + + ret = 0; err: - if (parent) - inode_unref (parent); + if (parent) + inode_unref(parent); - GF_FREE (resolvedpath); + GF_FREE(resolvedpath); - return ret; + return ret; } int -nfs_gfid_loc_fill (inode_table_t *itable, uuid_t gfid, loc_t *loc, int how) +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; - } + 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_trace (GF_NFS, 0, "Inode was found in the itable."); - } + 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); + 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; - } + 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; + if (inode) + inode_unref(inode); + return ret; } - int -nfs_root_loc_fill (inode_table_t *itable, loc_t *loc) +nfs_root_loc_fill(inode_table_t *itable, loc_t *loc) { - uuid_t rootgfid = {0, }; + uuid_t rootgfid = { + 0, + }; - rootgfid[15] = 1; - return nfs_gfid_loc_fill (itable, rootgfid, loc, NFS_RESOLVE_EXIST); + rootgfid[15] = 1; + return nfs_gfid_loc_fill(itable, rootgfid, loc, NFS_RESOLVE_EXIST); } - - int -nfs_parent_inode_loc_fill (inode_t *parent, inode_t *entryinode, char *entry, - loc_t *loc) +nfs_parent_inode_loc_fill(inode_t *parent, inode_t *entryinode, char *entry, + loc_t *loc) { - int ret = -EFAULT; - char *path = NULL; + int ret = -EFAULT; + char *path = NULL; - if ((!parent) || (!entry) || (!loc) || (!entryinode)) - return ret; + if ((!parent) || (!entry) || (!loc) || (!entryinode)) + return ret; - ret = inode_path (parent, entry, &path); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PATH_RESOLVE_FAIL, - "path resolution failed %s", path); - goto err; - } + ret = inode_path(parent, entry, &path); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PATH_RESOLVE_FAIL, + "path resolution failed %s", path); + goto err; + } - ret = nfs_loc_fill (loc, entryinode, parent, path); - GF_FREE (path); + ret = nfs_loc_fill(loc, entryinode, parent, path); + GF_FREE(path); err: - return ret; + return ret; } - /* Returns -1 if parent is not available, return -2 if the entry is not * available. In case the return is going to be -2, and how = NFS_RESOLVE_CREATE * it does however fill in the loc so that it can be used to perform a lookup @@ -318,151 +310,144 @@ err: * On other errors, return -3. 0 on success. */ int -nfs_entry_loc_fill (xlator_t *this, inode_table_t *itable, uuid_t pargfid, - char *entry, loc_t *loc, int how, gf_boolean_t *freshlookup) +nfs_entry_loc_fill(xlator_t *this, inode_table_t *itable, uuid_t pargfid, + char *entry, loc_t *loc, int how, gf_boolean_t *freshlookup) { - inode_t *parent = NULL; - inode_t *entryinode = NULL; - int ret = -3; - char *resolvedpath = NULL; - int pret = -3; - - if ((!itable) || (!entry) || (!loc)) - return ret; + inode_t *parent = NULL; + inode_t *entryinode = NULL; + int ret = -3; + char *resolvedpath = NULL; + int pret = -3; - parent = inode_find (itable, pargfid); - - ret = -1; - /* Will need hard resolution now */ - if (!parent || inode_ctx_get (parent, this, NULL)) - goto err; - - gf_uuid_copy (loc->pargfid, pargfid); - - ret = -2; - entryinode = inode_grep (itable, parent, entry); - if (!entryinode || inode_ctx_get (entryinode, this, NULL)) { - if (how == NFS_RESOLVE_CREATE) { - /* Even though we'll create the inode and the loc for - * a missing inode, we still need to return -2 so - * that the caller can use the filled loc to call - * lookup. - */ - if (!entryinode) { - entryinode = inode_new (itable); - if (freshlookup) - *freshlookup = _gf_true; - } - /* Cannot change ret because that must - * continue to have -2. - */ - pret = nfs_parent_inode_loc_fill (parent, entryinode, - entry, loc); - /* Only if parent loc fill fails, should we notify error - * through ret, otherwise, we still need to force a - * lookup by returning -2. - */ - if (pret < 0) - ret = -3; - } - goto err; - } - - ret = inode_path (parent, entry, &resolvedpath); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PATH_RESOLVE_FAIL, - "path resolution failed %s", resolvedpath); - ret = -3; - goto err; - } + if ((!itable) || (!entry) || (!loc)) + return ret; - ret = nfs_loc_fill (loc, entryinode, parent, resolvedpath); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_INODE_LOC_FILL_ERROR, - "loc_fill failed %s", resolvedpath); + parent = inode_find(itable, pargfid); + + ret = -1; + /* Will need hard resolution now */ + if (!parent || inode_ctx_get(parent, this, NULL)) + goto err; + + gf_uuid_copy(loc->pargfid, pargfid); + + ret = -2; + entryinode = inode_grep(itable, parent, entry); + if (!entryinode || inode_ctx_get(entryinode, this, NULL)) { + if (how == NFS_RESOLVE_CREATE) { + /* Even though we'll create the inode and the loc for + * a missing inode, we still need to return -2 so + * that the caller can use the filled loc to call + * lookup. + */ + if (!entryinode) { + entryinode = inode_new(itable); + if (freshlookup) + *freshlookup = _gf_true; + } + /* Cannot change ret because that must + * continue to have -2. + */ + pret = nfs_parent_inode_loc_fill(parent, entryinode, entry, loc); + /* Only if parent loc fill fails, should we notify error + * through ret, otherwise, we still need to force a + * lookup by returning -2. + */ + if (pret < 0) ret = -3; } + goto err; + } + + ret = inode_path(parent, entry, &resolvedpath); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PATH_RESOLVE_FAIL, + "path resolution failed %s", resolvedpath); + ret = -3; + goto err; + } + + ret = nfs_loc_fill(loc, entryinode, parent, resolvedpath); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_INODE_LOC_FILL_ERROR, + "loc_fill failed %s", resolvedpath); + ret = -3; + } err: - if (parent) - inode_unref (parent); + if (parent) + inode_unref(parent); - if (entryinode) - inode_unref (entryinode); + if (entryinode) + inode_unref(entryinode); - GF_FREE (resolvedpath); + GF_FREE(resolvedpath); - return ret; + return ret; } - uint32_t -nfs_hash_gfid (uuid_t gfid) +nfs_hash_gfid(uuid_t gfid) { - uint32_t hash = 0; - uint64_t msb64 = 0; - uint64_t lsb64 = 0; - uint32_t a1 = 0; - uint32_t a2 = 0; - uint32_t a3 = 0; - uint32_t a4 = 0; - uint32_t b1 = 0; - uint32_t b2 = 0; + uint32_t hash = 0; + uint64_t msb64 = 0; + uint64_t lsb64 = 0; + uint32_t a1 = 0; + uint32_t a2 = 0; + uint32_t a3 = 0; + uint32_t a4 = 0; + uint32_t b1 = 0; + uint32_t b2 = 0; - if (__is_root_gfid (gfid)) - return 0x1; + if (__is_root_gfid(gfid)) + return 0x1; - memcpy (&msb64, &gfid[8], 8); - memcpy (&lsb64, &gfid[0], 8); + memcpy(&msb64, &gfid[8], 8); + memcpy(&lsb64, &gfid[0], 8); - a1 = (msb64 << 32); - a2 = (msb64 >> 32); - a3 = (lsb64 << 32); - a4 = (lsb64 >> 32); + a1 = (msb64 << 32); + a2 = (msb64 >> 32); + a3 = (lsb64 << 32); + a4 = (lsb64 >> 32); - b1 = a1 ^ a4; - b2 = a2 ^ a3; + b1 = a1 ^ a4; + b2 = a2 ^ a3; - hash = b1 ^ b2; + hash = b1 ^ b2; - return hash; + return hash; } - void -nfs_fix_generation (xlator_t *this, inode_t *inode) +nfs_fix_generation(xlator_t *this, inode_t *inode) { - uint64_t raw_ctx = 0; - struct nfs_inode_ctx *ictx = NULL; - struct nfs_state *priv = NULL; - int ret = -1; - - if (!inode) { - return; - } - priv = this->private; - - if (inode_ctx_get(inode,this,&raw_ctx) == 0) { - ictx = (struct nfs_inode_ctx *)raw_ctx; - ictx->generation = priv->generation; + uint64_t raw_ctx = 0; + struct nfs_inode_ctx *ictx = NULL; + struct nfs_state *priv = NULL; + int ret = -1; + + if (!inode) { + return; + } + priv = this->private; + + if (inode_ctx_get(inode, this, &raw_ctx) == 0) { + ictx = (struct nfs_inode_ctx *)raw_ctx; + ictx->generation = priv->generation; + } else { + ictx = GF_CALLOC(1, sizeof(struct nfs_inode_ctx), gf_nfs_mt_inode_ctx); + if (!ictx) { + gf_msg(this->name, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "could not allocate nfs inode ctx"); + return; } - else { - ictx = GF_CALLOC (1, sizeof (struct nfs_inode_ctx), - gf_nfs_mt_inode_ctx); - if (!ictx) { - gf_msg (this->name, GF_LOG_ERROR, ENOMEM, - NFS_MSG_NO_MEMORY, - "could not allocate nfs inode ctx"); - return; - } - INIT_LIST_HEAD(&ictx->shares); - ictx->generation = priv->generation; - ret = inode_ctx_put (inode, this, (uint64_t)ictx); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, - NFS_MSG_INODE_CTX_STORE_FAIL, - "could not store nfs inode ctx"); - return; - } + INIT_LIST_HEAD(&ictx->shares); + ictx->generation = priv->generation; + ret = inode_ctx_put(inode, this, (uint64_t)ictx); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, NFS_MSG_INODE_CTX_STORE_FAIL, + "could not store nfs inode ctx"); + return; } + } } diff --git a/xlators/nfs/server/src/nfs-fops.c b/xlators/nfs/server/src/nfs-fops.c index 4414100136..9abb2ac4ee 100644 --- a/xlators/nfs/server/src/nfs-fops.c +++ b/xlators/nfs/server/src/nfs-fops.c @@ -26,355 +26,345 @@ static int gf_auth_max_groups_nfs_log = 0; void -nfs_fix_groups (xlator_t *this, call_stack_t *root) +nfs_fix_groups(xlator_t *this, call_stack_t *root) { - struct passwd mypw; - char mystrs[1024]; - struct passwd *result; - gid_t *mygroups; - int ngroups; - int i; - int max_groups; - struct nfs_state *priv = this->private; - const gid_list_t *agl; - gid_list_t gl; - - if (!priv->server_aux_gids) { - return; - } - - /* RPC enforces the GF_AUTH_GLUSTERFS_MAX_GROUPS limit */ - max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS(root->lk_owner.len, - AUTH_GLUSTERFS_v2); - - agl = gid_cache_lookup(&priv->gid_cache, root->uid, 0, 0); - if (agl) { - if (agl->gl_count > max_groups) { - GF_LOG_OCCASIONALLY (gf_auth_max_groups_nfs_log, - this->name, GF_LOG_WARNING, - "too many groups, reducing %d -> %d", - agl->gl_count, max_groups); - } - - for (ngroups = 0; ngroups < agl->gl_count - && ngroups <= max_groups; ngroups++) { - root->groups[ngroups] = agl->gl_list[ngroups]; - } - root->ngrps = ngroups; - gid_cache_release(&priv->gid_cache, agl); - return; - } - - /* No cached list found. */ - if (getpwuid_r(root->uid,&mypw,mystrs,sizeof(mystrs),&result) != 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, NFS_MSG_GETPWUID_FAIL, - "getpwuid_r(%u) failed", root->uid); - return; - } - - if (!result) { - gf_msg (this->name, GF_LOG_ERROR, 0, NFS_MSG_GETPWUID_FAIL, - "getpwuid_r(%u) found nothing", root->uid); - return; + struct passwd mypw; + char mystrs[1024]; + struct passwd *result; + gid_t *mygroups; + int ngroups; + int i; + int max_groups; + struct nfs_state *priv = this->private; + const gid_list_t *agl; + gid_list_t gl; + + if (!priv->server_aux_gids) { + return; + } + + /* RPC enforces the GF_AUTH_GLUSTERFS_MAX_GROUPS limit */ + max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS(root->lk_owner.len, + AUTH_GLUSTERFS_v2); + + agl = gid_cache_lookup(&priv->gid_cache, root->uid, 0, 0); + if (agl) { + if (agl->gl_count > max_groups) { + GF_LOG_OCCASIONALLY(gf_auth_max_groups_nfs_log, this->name, + GF_LOG_WARNING, + "too many groups, reducing %d -> %d", + agl->gl_count, max_groups); } - gf_msg_trace (this->name, 0, "mapped %u => %s", - root->uid, result->pw_name); - - ngroups = gf_getgrouplist (result->pw_name, root->gid, &mygroups); - if (ngroups == -1) { - gf_msg (this->name, GF_LOG_ERROR, 0, NFS_MSG_MAP_GRP_LIST_FAIL, - "could not map %s to group list", result->pw_name); - return; + for (ngroups = 0; ngroups < agl->gl_count && ngroups <= max_groups; + ngroups++) { + root->groups[ngroups] = agl->gl_list[ngroups]; } + root->ngrps = ngroups; + gid_cache_release(&priv->gid_cache, agl); + return; + } + /* No cached list found. */ + if (getpwuid_r(root->uid, &mypw, mystrs, sizeof(mystrs), &result) != 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, NFS_MSG_GETPWUID_FAIL, + "getpwuid_r(%u) failed", root->uid); + return; + } - /* RPC enforces the GF_AUTH_GLUSTERFS_MAX_GROUPS limit */ - if (ngroups > max_groups) { - GF_LOG_OCCASIONALLY (gf_auth_max_groups_nfs_log, - this->name, GF_LOG_WARNING, - "too many groups, reducing %d -> %d", - ngroups, max_groups); - - } + if (!result) { + gf_msg(this->name, GF_LOG_ERROR, 0, NFS_MSG_GETPWUID_FAIL, + "getpwuid_r(%u) found nothing", root->uid); + return; + } - /* Copy data to the frame. */ - for (i = 0; i < ngroups && i < max_groups; ++i) { - gf_msg_trace (this->name, 0, "%s is in group %u", - result->pw_name, mygroups[i]); - root->groups[i] = mygroups[i]; - } - root->ngrps = ngroups; + gf_msg_trace(this->name, 0, "mapped %u => %s", root->uid, result->pw_name); - /* Add the group data to the cache. */ - gl.gl_list = mygroups; - gl.gl_id = root->uid; - gl.gl_uid = 0; - gl.gl_gid = 0; - gl.gl_count = ngroups; - if (gid_cache_add(&priv->gid_cache, &gl) != 1) - GF_FREE(mygroups); + ngroups = gf_getgrouplist(result->pw_name, root->gid, &mygroups); + if (ngroups == -1) { + gf_msg(this->name, GF_LOG_ERROR, 0, NFS_MSG_MAP_GRP_LIST_FAIL, + "could not map %s to group list", result->pw_name); + return; + } + + /* RPC enforces the GF_AUTH_GLUSTERFS_MAX_GROUPS limit */ + if (ngroups > max_groups) { + GF_LOG_OCCASIONALLY( + gf_auth_max_groups_nfs_log, this->name, GF_LOG_WARNING, + "too many groups, reducing %d -> %d", ngroups, max_groups); + } + + /* Copy data to the frame. */ + for (i = 0; i < ngroups && i < max_groups; ++i) { + gf_msg_trace(this->name, 0, "%s is in group %u", result->pw_name, + mygroups[i]); + root->groups[i] = mygroups[i]; + } + root->ngrps = ngroups; + + /* Add the group data to the cache. */ + gl.gl_list = mygroups; + gl.gl_id = root->uid; + gl.gl_uid = 0; + gl.gl_gid = 0; + gl.gl_count = ngroups; + if (gid_cache_add(&priv->gid_cache, &gl) != 1) + GF_FREE(mygroups); } struct nfs_fop_local * -nfs_fop_local_init (xlator_t *nfsx) +nfs_fop_local_init(xlator_t *nfsx) { - struct nfs_fop_local *l = NULL; + struct nfs_fop_local *l = NULL; - if (!nfsx) - return NULL; + if (!nfsx) + return NULL; - l = mem_get (nfs_fop_mempool (nfsx)); + l = mem_get(nfs_fop_mempool(nfsx)); - memset (l, 0, sizeof (*l)); - return l; + memset(l, 0, sizeof(*l)); + return l; } void -nfs_fop_local_wipe (xlator_t *nfsx, struct nfs_fop_local *l) +nfs_fop_local_wipe(xlator_t *nfsx, struct nfs_fop_local *l) { - if ((!nfsx) || (!l)) - return; + if ((!nfsx) || (!l)) + return; - if (l->iobref) - iobref_unref (l->iobref); + if (l->iobref) + iobref_unref(l->iobref); - if (l->parent) - inode_unref (l->parent); + if (l->parent) + inode_unref(l->parent); - if (l->inode) - inode_unref (l->inode); + if (l->inode) + inode_unref(l->inode); - if (l->newparent) - inode_unref (l->newparent); + if (l->newparent) + inode_unref(l->newparent); - if (l->dictgfid) - dict_unref (l->dictgfid); + if (l->dictgfid) + dict_unref(l->dictgfid); - mem_put (l); + mem_put(l); - return; + return; } -#define nfs_stack_destroy(nfl, fram) \ - do { \ - nfs_fop_local_wipe ((nfl)->nfsx, nfl); \ - (fram)->local = NULL; \ - STACK_DESTROY ((fram)->root); \ - } while (0) \ - - -pthread_mutex_t ctr = PTHREAD_MUTEX_INITIALIZER; -unsigned int cval = 1; +#define nfs_stack_destroy(nfl, fram) \ + do { \ + nfs_fop_local_wipe((nfl)->nfsx, nfl); \ + (fram)->local = NULL; \ + STACK_DESTROY((fram)->root); \ + } while (0) +pthread_mutex_t ctr = PTHREAD_MUTEX_INITIALIZER; +unsigned int cval = 1; int -nfs_frame_getctr () +nfs_frame_getctr() { - uint64_t val = 0; - - pthread_mutex_lock (&ctr); - { - if (cval == 0) - cval = 1; - val = cval; - cval++; - } - pthread_mutex_unlock (&ctr); - - return val; + uint64_t val = 0; + + pthread_mutex_lock(&ctr); + { + if (cval == 0) + cval = 1; + val = cval; + cval++; + } + pthread_mutex_unlock(&ctr); + + return val; } - call_frame_t * -nfs_create_frame (xlator_t *xl, nfs_user_t *nfu) +nfs_create_frame(xlator_t *xl, nfs_user_t *nfu) { - call_frame_t *frame = NULL; - int x = 0; - int y = 0; - - if ((!xl) || (!nfu) || (nfu->ngrps > NFS_NGROUPS)) - return NULL; - - frame = create_frame (xl, (call_pool_t *)xl->ctx->pool); - if (!frame) - goto err; - if (call_stack_alloc_groups (frame->root, nfu->ngrps) != 0) { - STACK_DESTROY (frame->root); - frame = NULL; - goto err; - } - - frame->root->pid = NFS_PID; - frame->root->uid = nfu->uid; - frame->root->gid = nfu->gids[NFS_PRIMGID_IDX]; - memcpy (&frame->root->identifier, &nfu->identifier, UNIX_PATH_MAX); - frame->root->lk_owner = nfu->lk_owner; - - if (nfu->ngrps != 1) { - frame->root->ngrps = nfu->ngrps - 1; - - gf_msg_trace (GF_NFS, 0, "uid: %d, gid %d, gids: %d", - frame->root->uid, frame->root->gid, - frame->root->ngrps); - for(y = 0, x = 1; y < frame->root->ngrps; x++,y++) { - gf_msg_trace (GF_NFS, 0, "gid: %d", nfu->gids[x]); - frame->root->groups[y] = nfu->gids[x]; - } + call_frame_t *frame = NULL; + int x = 0; + int y = 0; + + if ((!xl) || (!nfu) || (nfu->ngrps > NFS_NGROUPS)) + return NULL; + + frame = create_frame(xl, (call_pool_t *)xl->ctx->pool); + if (!frame) + goto err; + if (call_stack_alloc_groups(frame->root, nfu->ngrps) != 0) { + STACK_DESTROY(frame->root); + frame = NULL; + goto err; + } + + frame->root->pid = NFS_PID; + frame->root->uid = nfu->uid; + frame->root->gid = nfu->gids[NFS_PRIMGID_IDX]; + memcpy(&frame->root->identifier, &nfu->identifier, UNIX_PATH_MAX); + frame->root->lk_owner = nfu->lk_owner; + + if (nfu->ngrps != 1) { + frame->root->ngrps = nfu->ngrps - 1; + + gf_msg_trace(GF_NFS, 0, "uid: %d, gid %d, gids: %d", frame->root->uid, + frame->root->gid, frame->root->ngrps); + for (y = 0, x = 1; y < frame->root->ngrps; x++, y++) { + gf_msg_trace(GF_NFS, 0, "gid: %d", nfu->gids[x]); + frame->root->groups[y] = nfu->gids[x]; } + } - /* - * It's tempting to do this *instead* of using nfu above, but we need - * to have those values in case nfs_fix_groups doesn't do anything. - */ - nfs_fix_groups(xl,frame->root); + /* + * It's tempting to do this *instead* of using nfu above, but we need + * to have those values in case nfs_fix_groups doesn't do anything. + */ + nfs_fix_groups(xl, frame->root); err: - return frame; + return frame; } -#define nfs_fop_handle_frame_create(fram, xla, nfuser, retval, errlabel) \ - do { \ - fram = nfs_create_frame (xla, (nfuser)); \ - if (!fram) { \ - retval = (-ENOMEM); \ - gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM, \ - NFS_MSG_NO_MEMORY, "Frame creation failed");\ - goto errlabel; \ - } \ - } while (0) \ +#define nfs_fop_handle_frame_create(fram, xla, nfuser, retval, errlabel) \ + do { \ + fram = nfs_create_frame(xla, (nfuser)); \ + if (!fram) { \ + retval = (-ENOMEM); \ + gf_msg(GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, \ + "Frame creation failed"); \ + goto errlabel; \ + } \ + } while (0) /* Look into the inode and parent inode of a loc and save enough state * for us to determine in the callback whether to funge the ino in the stat buf * with 1 for the parent. */ -#define nfs_fop_save_root_ino(locl, loc) \ - do { \ - if (((loc)->inode) && \ - __is_root_gfid ((loc)->inode->gfid)) \ - (locl)->rootinode = 1; \ - else if (((loc)->parent) && \ - __is_root_gfid ((loc)->parent->gfid)) \ - (locl)->rootparentinode = 1; \ - } while (0) +#define nfs_fop_save_root_ino(locl, loc) \ + do { \ + if (((loc)->inode) && __is_root_gfid((loc)->inode->gfid)) \ + (locl)->rootinode = 1; \ + else if (((loc)->parent) && __is_root_gfid((loc)->parent->gfid)) \ + (locl)->rootparentinode = 1; \ + } while (0) /* Do the same for an fd */ -#define nfs_fop_save_root_fd_ino(locl, fdesc) \ - do { \ - if (__is_root_gfid ((fdesc)->inode->gfid)) \ - (locl)->rootinode = 1; \ - } while (0) - +#define nfs_fop_save_root_fd_ino(locl, fdesc) \ + do { \ + if (__is_root_gfid((fdesc)->inode->gfid)) \ + (locl)->rootinode = 1; \ + } while (0) /* Use the state saved by the previous macro to funge the ino in the appropriate * structure. */ -#define nfs_fop_restore_root_ino(locl, fopret, preattr, postattr, prepar, postpar) \ - do { \ - if (fopret == -1) \ - break; \ - if ((locl)->rootinode) { \ - if ((preattr)) { \ - ((struct iatt *)(preattr))->ia_ino = 1; \ - ((struct iatt *)(preattr))->ia_dev = 0; \ - } \ - if ((postattr)) { \ - ((struct iatt *)(postattr))->ia_ino = 1; \ - ((struct iatt *)(postattr))->ia_dev = 0; \ - } \ - } else if ((locl)->rootparentinode) { \ - if ((prepar)) { \ - ((struct iatt *)(prepar))->ia_ino = 1; \ - ((struct iatt *)(prepar))->ia_dev = 0; \ - } \ - if ((postpar)) { \ - ((struct iatt *)(postpar))->ia_ino = 1; \ - ((struct iatt *)(postpar))->ia_dev = 0; \ - } \ - } \ - } while (0) \ +#define nfs_fop_restore_root_ino(locl, fopret, preattr, postattr, prepar, \ + postpar) \ + do { \ + if (fopret == -1) \ + break; \ + if ((locl)->rootinode) { \ + if ((preattr)) { \ + ((struct iatt *)(preattr))->ia_ino = 1; \ + ((struct iatt *)(preattr))->ia_dev = 0; \ + } \ + if ((postattr)) { \ + ((struct iatt *)(postattr))->ia_ino = 1; \ + ((struct iatt *)(postattr))->ia_dev = 0; \ + } \ + } else if ((locl)->rootparentinode) { \ + if ((prepar)) { \ + ((struct iatt *)(prepar))->ia_ino = 1; \ + ((struct iatt *)(prepar))->ia_dev = 0; \ + } \ + if ((postpar)) { \ + ((struct iatt *)(postpar))->ia_ino = 1; \ + ((struct iatt *)(postpar))->ia_dev = 0; \ + } \ + } \ + } while (0) /* If the newly created, inode's parent is root, we'll need to funge the ino * in the parent attr when we receive them in the callback. */ -#define nfs_fop_newloc_save_root_ino(locl, newloc) \ - do { \ - if (((newloc)->inode) && \ - __is_root_gfid ((newloc)->inode->gfid)) \ - (locl)->newrootinode = 1; \ - else if (((newloc)->parent) && \ - __is_root_gfid ((newloc)->parent->gfid)) \ - (locl)->newrootparentinode = 1; \ - } while (0) - -#define nfs_fop_newloc_restore_root_ino(locl, fopret, preattr, postattr, prepar, postpar) \ - do { \ - if (fopret == -1) \ - break; \ +#define nfs_fop_newloc_save_root_ino(locl, newloc) \ + do { \ + if (((newloc)->inode) && __is_root_gfid((newloc)->inode->gfid)) \ + (locl)->newrootinode = 1; \ + else if (((newloc)->parent) && __is_root_gfid((newloc)->parent->gfid)) \ + (locl)->newrootparentinode = 1; \ + } while (0) + +#define nfs_fop_newloc_restore_root_ino(locl, fopret, preattr, postattr, \ + prepar, postpar) \ + do { \ + if (fopret == -1) \ + break; \ \ - if ((locl)->newrootinode) { \ - if ((preattr)) \ - ((struct iatt *)(preattr))->ia_ino = 1; \ - if ((postattr)) \ - ((struct iatt *)(postattr))->ia_ino = 1; \ - } else if ((locl)->newrootparentinode) { \ - if ((prepar)) \ - ((struct iatt *)(prepar))->ia_ino = 1; \ - if ((postpar)) \ - ((struct iatt *)(postpar))->ia_ino = 1; \ - } \ - } while (0) \ + if ((locl)->newrootinode) { \ + if ((preattr)) \ + ((struct iatt *)(preattr))->ia_ino = 1; \ + if ((postattr)) \ + ((struct iatt *)(postattr))->ia_ino = 1; \ + } else if ((locl)->newrootparentinode) { \ + if ((prepar)) \ + ((struct iatt *)(prepar))->ia_ino = 1; \ + if ((postpar)) \ + ((struct iatt *)(postpar))->ia_ino = 1; \ + } \ + } while (0) dict_t * -nfs_gfid_dict (inode_t *inode) +nfs_gfid_dict(inode_t *inode) { - uuid_t newgfid = {0, }; - unsigned char *dyngfid = NULL; - dict_t *dictgfid = NULL; - int ret = -1; - uuid_t rootgfid = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}; - - dyngfid = GF_MALLOC (sizeof (uuid_t), gf_common_mt_char); - if (dyngfid == NULL) - return (NULL); - - gf_uuid_generate (newgfid); - - if (gf_uuid_compare (inode->gfid, rootgfid) == 0) - memcpy (dyngfid, rootgfid, sizeof (uuid_t)); - else - memcpy (dyngfid, newgfid, sizeof (uuid_t)); - - dictgfid = dict_new (); - if (!dictgfid) { - gf_msg (GF_NFS, GF_LOG_ERROR, errno, - NFS_MSG_GFID_DICT_CREATE_FAIL, - "Failed to create gfid dict"); - GF_FREE (dyngfid); - return (NULL); - } - - ret = dict_set_gfuuid (dictgfid, "gfid-req", dyngfid, false); - if (ret < 0) { - GF_FREE (dyngfid); - dict_unref (dictgfid); - return (NULL); - } - - return dictgfid; + uuid_t newgfid = { + 0, + }; + unsigned char *dyngfid = NULL; + dict_t *dictgfid = NULL; + int ret = -1; + uuid_t rootgfid = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}; + + dyngfid = GF_MALLOC(sizeof(uuid_t), gf_common_mt_char); + if (dyngfid == NULL) + return (NULL); + + gf_uuid_generate(newgfid); + + if (gf_uuid_compare(inode->gfid, rootgfid) == 0) + memcpy(dyngfid, rootgfid, sizeof(uuid_t)); + else + memcpy(dyngfid, newgfid, sizeof(uuid_t)); + + dictgfid = dict_new(); + if (!dictgfid) { + gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_GFID_DICT_CREATE_FAIL, + "Failed to create gfid dict"); + GF_FREE(dyngfid); + return (NULL); + } + + ret = dict_set_gfuuid(dictgfid, "gfid-req", dyngfid, false); + if (ret < 0) { + GF_FREE(dyngfid); + dict_unref(dictgfid); + return (NULL); + } + + return dictgfid; } -#define nfs_fop_gfid_setup(nflcl, inode, retval, erlbl) \ - do { \ - if (nflcl) { \ - (nflcl)->dictgfid = nfs_gfid_dict (inode); \ - \ - if (!((nflcl)->dictgfid)) { \ - retval = -EFAULT; \ - goto erlbl; \ - } \ - } \ - } while (0) \ +#define nfs_fop_gfid_setup(nflcl, inode, retval, erlbl) \ + do { \ + if (nflcl) { \ + (nflcl)->dictgfid = nfs_gfid_dict(inode); \ + \ + if (!((nflcl)->dictgfid)) { \ + retval = -EFAULT; \ + goto erlbl; \ + } \ + } \ + } while (0) /* Fops Layer Explained * The fops layer has three types of functions. They can all be identified by @@ -402,1300 +392,1237 @@ nfs_gfid_dict (inode_t *inode) */ int32_t -nfs_fop_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, dict_t *xattr, struct iatt *postparent) +nfs_fop_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, dict_t *xattr, struct iatt *postparent) { - struct nfs_fop_local *local = NULL; - fop_lookup_cbk_t progcbk; + struct nfs_fop_local *local = NULL; + fop_lookup_cbk_t progcbk; - if (op_ret == 0) { - nfs_fix_generation(this,inode); - } + if (op_ret == 0) { + nfs_fix_generation(this, inode); + } - nfl_to_prog_data (local, progcbk, frame); - nfs_fop_restore_root_ino (local, op_ret, buf, NULL, NULL, postparent); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, inode, buf, - xattr, postparent); + nfl_to_prog_data(local, progcbk, frame); + nfs_fop_restore_root_ino(local, op_ret, buf, NULL, NULL, postparent); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, inode, buf, xattr, + postparent); - nfs_stack_destroy (local, frame); - return 0; + nfs_stack_destroy(local, frame); + return 0; } - int -nfs_fop_lookup (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, - fop_lookup_cbk_t cbk, void *local) +nfs_fop_lookup(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, + fop_lookup_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; - if ((!xl) || (!loc) || (!nfu)) - return ret; + if ((!xl) || (!loc) || (!nfu)) + return ret; - gf_msg_trace (GF_NFS, 0, "Lookup: %s", loc->path); - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); - nfs_fop_save_root_ino (nfl, loc); - nfs_fop_gfid_setup (nfl, loc->inode, ret, err); + gf_msg_trace(GF_NFS, 0, "Lookup: %s", loc->path); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_save_root_ino(nfl, loc); + nfs_fop_gfid_setup(nfl, loc->inode, ret, err); - STACK_WIND_COOKIE (frame, nfs_fop_lookup_cbk, xl, xl, - xl->fops->lookup, loc, nfl->dictgfid); + STACK_WIND_COOKIE(frame, nfs_fop_lookup_cbk, xl, xl, xl->fops->lookup, loc, + nfl->dictgfid); - ret = 0; + ret = 0; err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } - return ret; + return ret; } int32_t -nfs_fop_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +nfs_fop_access_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_access_cbk_t progcbk = NULL; + struct nfs_fop_local *nfl = NULL; + fop_access_cbk_t progcbk = NULL; - nfl_to_prog_data (nfl, progcbk, frame); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, xdata); + nfl_to_prog_data(nfl, progcbk, frame); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, xdata); - nfs_stack_destroy (nfl, frame); - return 0; + nfs_stack_destroy(nfl, frame); + return 0; } int -nfs_fop_access (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, - int32_t accesstest, fop_access_cbk_t cbk, void *local) +nfs_fop_access(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, + int32_t accesstest, fop_access_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; - uint32_t accessbits = 0; - - if ((!xl) || (!loc) || (!nfu)) - return ret; - - gf_msg_trace (GF_NFS, 0, "Access: %s", loc->path); - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); - nfs_fop_save_root_ino (nfl, loc); - - accessbits = nfs3_request_to_accessbits (accesstest); - STACK_WIND_COOKIE (frame, nfs_fop_access_cbk, xl, xl, xl->fops->access, - loc, accessbits, NULL); - ret = 0; -err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; + uint32_t accessbits = 0; + if ((!xl) || (!loc) || (!nfu)) return ret; + + gf_msg_trace(GF_NFS, 0, "Access: %s", loc->path); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_save_root_ino(nfl, loc); + + accessbits = nfs3_request_to_accessbits(accesstest); + STACK_WIND_COOKIE(frame, nfs_fop_access_cbk, xl, xl, xl->fops->access, loc, + accessbits, NULL); + ret = 0; +err: + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } + + return ret; } int32_t -nfs_fop_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, - dict_t *xdata) +nfs_fop_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *buf, + dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_stat_cbk_t progcbk = NULL; + struct nfs_fop_local *nfl = NULL; + fop_stat_cbk_t progcbk = NULL; - nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, op_ret, buf, NULL, NULL, NULL); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, buf, xdata); + nfl_to_prog_data(nfl, progcbk, frame); + nfs_fop_restore_root_ino(nfl, op_ret, buf, NULL, NULL, NULL); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, buf, xdata); - nfs_stack_destroy (nfl, frame); - return 0; + nfs_stack_destroy(nfl, frame); + return 0; } - int -nfs_fop_stat (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, - fop_stat_cbk_t cbk, void *local) +nfs_fop_stat(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, + fop_stat_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; - if ((!xl) || (!loc) || (!nfu)) - return ret; + if ((!xl) || (!loc) || (!nfu)) + return ret; - gf_msg_trace (GF_NFS, 0, "Stat: %s", loc->path); - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); - nfs_fop_save_root_ino (nfl, loc); + gf_msg_trace(GF_NFS, 0, "Stat: %s", loc->path); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_save_root_ino(nfl, loc); - STACK_WIND_COOKIE (frame, nfs_fop_stat_cbk, xl, xl, xl->fops->stat, - loc, NULL); - ret = 0; + STACK_WIND_COOKIE(frame, nfs_fop_stat_cbk, xl, xl, xl->fops->stat, loc, + NULL); + ret = 0; err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } - return ret; + return ret; } - int32_t -nfs_fop_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, - dict_t *xdata) +nfs_fop_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *buf, + dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_fstat_cbk_t progcbk = NULL; + struct nfs_fop_local *nfl = NULL; + fop_fstat_cbk_t progcbk = NULL; - nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, op_ret, buf, NULL, NULL, NULL); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, buf, xdata); + nfl_to_prog_data(nfl, progcbk, frame); + nfs_fop_restore_root_ino(nfl, op_ret, buf, NULL, NULL, NULL); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, buf, xdata); - nfs_stack_destroy (nfl, frame); - return 0; + nfs_stack_destroy(nfl, frame); + return 0; } - int -nfs_fop_fstat (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, - fop_fstat_cbk_t cbk, void *local) +nfs_fop_fstat(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, + fop_fstat_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; - if ((!nfsx) || (!xl) || (!fd) || (!nfu)) - return ret; + if ((!nfsx) || (!xl) || (!fd) || (!nfu)) + return ret; - gf_msg_trace (GF_NFS, 0, "FStat"); - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); - nfs_fop_save_root_fd_ino (nfl, fd); + gf_msg_trace(GF_NFS, 0, "FStat"); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_save_root_fd_ino(nfl, fd); - STACK_WIND_COOKIE (frame, nfs_fop_fstat_cbk, xl, xl, xl->fops->fstat, - fd, NULL); + STACK_WIND_COOKIE(frame, nfs_fop_fstat_cbk, xl, xl, xl->fops->fstat, fd, + NULL); - ret = 0; + ret = 0; err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } - return ret; + return ret; } - int32_t -nfs_fop_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) +nfs_fop_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_opendir_cbk_t progcbk = NULL; - - nfl_to_prog_data (nfl, progcbk, frame); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, fd, xdata); - nfs_stack_destroy (nfl, frame); - return 0; + struct nfs_fop_local *nfl = NULL; + fop_opendir_cbk_t progcbk = NULL; + + nfl_to_prog_data(nfl, progcbk, frame); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, fd, xdata); + nfs_stack_destroy(nfl, frame); + return 0; } - int -nfs_fop_opendir (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - fd_t *dirfd, fop_opendir_cbk_t cbk, void *local) +nfs_fop_opendir(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + fd_t *dirfd, fop_opendir_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; - if ((!nfsx) || (!xl) || (!pathloc) || (!dirfd) || (!nfu)) - return ret; + if ((!nfsx) || (!xl) || (!pathloc) || (!dirfd) || (!nfu)) + return ret; - gf_msg_trace (GF_NFS, 0, "Opendir: %s", pathloc->path); - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); + gf_msg_trace(GF_NFS, 0, "Opendir: %s", pathloc->path); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); - STACK_WIND_COOKIE (frame, nfs_fop_opendir_cbk, xl, xl, - xl->fops->opendir, pathloc, dirfd, NULL); - ret = 0; + STACK_WIND_COOKIE(frame, nfs_fop_opendir_cbk, xl, xl, xl->fops->opendir, + pathloc, dirfd, NULL); + ret = 0; err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } - return ret; + return ret; } int -nfs_fop_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +nfs_fop_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_flush_cbk_t progcbk = NULL; + struct nfs_fop_local *nfl = NULL; + fop_flush_cbk_t progcbk = NULL; - nfl_to_prog_data (nfl, progcbk, frame); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, xdata); + nfl_to_prog_data(nfl, progcbk, frame); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, xdata); - nfs_stack_destroy (nfl, frame); - return 0; + nfs_stack_destroy(nfl, frame); + return 0; } - int -nfs_fop_flush (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, - fop_flush_cbk_t cbk, void *local) +nfs_fop_flush(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, + fop_flush_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; - if ((!nfsx) || (!xl) || (!fd) || (!nfu)) - return ret; + if ((!nfsx) || (!xl) || (!fd) || (!nfu)) + return ret; - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); - STACK_WIND_COOKIE (frame, nfs_fop_flush_cbk, xl, xl, xl->fops->flush, - fd, NULL); - ret = 0; + STACK_WIND_COOKIE(frame, nfs_fop_flush_cbk, xl, xl, xl->fops->flush, fd, + NULL); + ret = 0; err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } - return ret; + return ret; } - int32_t -nfs_fop_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, - dict_t *xdata) +nfs_fop_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, + dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_readdirp_cbk_t progcbk = NULL; + struct nfs_fop_local *nfl = NULL; + fop_readdirp_cbk_t progcbk = NULL; - nfl_to_prog_data (nfl, progcbk, frame); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, entries, xdata); + nfl_to_prog_data(nfl, progcbk, frame); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, entries, xdata); - nfs_stack_destroy (nfl, frame); + nfs_stack_destroy(nfl, frame); - return 0; + return 0; } - int -nfs_fop_readdirp (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *dirfd, - size_t bufsize, off_t offset, fop_readdirp_cbk_t cbk, - void *local) +nfs_fop_readdirp(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *dirfd, + size_t bufsize, off_t offset, fop_readdirp_cbk_t cbk, + void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; - if ((!nfsx) || (!xl) || (!dirfd) || (!nfu)) - return ret; + if ((!nfsx) || (!xl) || (!dirfd) || (!nfu)) + return ret; - gf_msg_trace (GF_NFS, 0, "readdir"); - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); + gf_msg_trace(GF_NFS, 0, "readdir"); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); - STACK_WIND_COOKIE (frame, nfs_fop_readdirp_cbk, xl, xl, - xl->fops->readdirp, dirfd, bufsize, offset, 0); + STACK_WIND_COOKIE(frame, nfs_fop_readdirp_cbk, xl, xl, xl->fops->readdirp, + dirfd, bufsize, offset, 0); - ret = 0; + ret = 0; err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } - return ret; + return ret; } - int32_t -nfs_fop_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct statvfs *buf, - dict_t *xdata) +nfs_fop_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct statvfs *buf, + dict_t *xdata) { + struct nfs_fop_local *nfl = NULL; + fop_statfs_cbk_t progcbk = NULL; - struct nfs_fop_local *nfl = NULL; - fop_statfs_cbk_t progcbk = NULL; - - nfl_to_prog_data (nfl, progcbk, frame); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, buf, xdata); + nfl_to_prog_data(nfl, progcbk, frame); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, buf, xdata); - nfs_stack_destroy (nfl, frame); - return 0; + nfs_stack_destroy(nfl, frame); + return 0; } - int -nfs_fop_statfs (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - fop_statfs_cbk_t cbk, void *local) +nfs_fop_statfs(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + fop_statfs_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return ret; + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) + return ret; - gf_msg_trace (GF_NFS, 0, "Statfs: %s", pathloc->path); - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); + gf_msg_trace(GF_NFS, 0, "Statfs: %s", pathloc->path); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); - STACK_WIND_COOKIE (frame, nfs_fop_statfs_cbk, xl, xl, - xl->fops->statfs, pathloc, NULL); - ret = 0; + STACK_WIND_COOKIE(frame, nfs_fop_statfs_cbk, xl, xl, xl->fops->statfs, + pathloc, NULL); + ret = 0; err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } - return ret; + return ret; } - int32_t -nfs_fop_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +nfs_fop_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_create_cbk_t progcbk = NULL; + struct nfs_fop_local *nfl = NULL; + fop_create_cbk_t progcbk = NULL; - if (op_ret == 0) { - nfs_fix_generation(this,inode); - } + if (op_ret == 0) { + nfs_fix_generation(this, inode); + } - nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, op_ret, buf, NULL, preparent, - postparent); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, fd, inode, buf, - preparent, postparent, NULL); + nfl_to_prog_data(nfl, progcbk, frame); + nfs_fop_restore_root_ino(nfl, op_ret, buf, NULL, preparent, postparent); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, fd, inode, buf, + preparent, postparent, NULL); - nfs_stack_destroy (nfl, frame); - return 0; + nfs_stack_destroy(nfl, frame); + return 0; } - int -nfs_fop_create (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - int flags, mode_t mode, fd_t *fd, fop_create_cbk_t cbk, - void *local) +nfs_fop_create(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + int flags, mode_t mode, fd_t *fd, fop_create_cbk_t cbk, + void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return ret; + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) + return ret; - gf_msg_trace (GF_NFS, 0, "Create: %s", pathloc->path); - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); - nfs_fop_save_root_ino (nfl, pathloc); - nfs_fop_gfid_setup (nfl, pathloc->inode, ret, err); + gf_msg_trace(GF_NFS, 0, "Create: %s", pathloc->path); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_save_root_ino(nfl, pathloc); + nfs_fop_gfid_setup(nfl, pathloc->inode, ret, err); - STACK_WIND_COOKIE (frame, nfs_fop_create_cbk, xl, xl, xl->fops->create, - pathloc, flags, mode, 0, fd, nfl->dictgfid); + STACK_WIND_COOKIE(frame, nfs_fop_create_cbk, xl, xl, xl->fops->create, + pathloc, flags, mode, 0, fd, nfl->dictgfid); - ret = 0; + ret = 0; err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } - return ret; + return ret; } - int32_t -nfs_fop_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *pre, - struct iatt *post, dict_t *xdata) +nfs_fop_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *pre, + struct iatt *post, dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_setattr_cbk_t progcbk = NULL; - - nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, op_ret, pre, post, NULL, NULL); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, pre, post, - xdata); - nfs_stack_destroy (nfl, frame); - return 0; + struct nfs_fop_local *nfl = NULL; + fop_setattr_cbk_t progcbk = NULL; + + nfl_to_prog_data(nfl, progcbk, frame); + nfs_fop_restore_root_ino(nfl, op_ret, pre, post, NULL, NULL); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, pre, post, xdata); + nfs_stack_destroy(nfl, frame); + return 0; } - - int -nfs_fop_setattr (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - struct iatt *buf, int32_t valid, fop_setattr_cbk_t cbk, - void *local) +nfs_fop_setattr(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + struct iatt *buf, int32_t valid, fop_setattr_cbk_t cbk, + void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return ret; + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) + return ret; - gf_msg_trace (GF_NFS, 0, "Setattr: %s", pathloc->path); - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); - nfs_fop_save_root_ino (nfl, pathloc); + gf_msg_trace(GF_NFS, 0, "Setattr: %s", pathloc->path); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_save_root_ino(nfl, pathloc); - STACK_WIND_COOKIE (frame, nfs_fop_setattr_cbk, xl, xl, - xl->fops->setattr, pathloc, buf, valid, NULL); - ret = 0; + STACK_WIND_COOKIE(frame, nfs_fop_setattr_cbk, xl, xl, xl->fops->setattr, + pathloc, buf, valid, NULL); + ret = 0; err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } - return ret; + return ret; } - int32_t -nfs_fop_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +nfs_fop_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_mkdir_cbk_t progcbk = NULL; - - if (op_ret == 0) { - nfs_fix_generation(this,inode); - } - - nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, op_ret, buf, NULL,preparent, postparent); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); - nfs_stack_destroy (nfl, frame); - return 0; + struct nfs_fop_local *nfl = NULL; + fop_mkdir_cbk_t progcbk = NULL; + + if (op_ret == 0) { + nfs_fix_generation(this, inode); + } + + nfl_to_prog_data(nfl, progcbk, frame); + nfs_fop_restore_root_ino(nfl, op_ret, buf, NULL, preparent, postparent); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); + nfs_stack_destroy(nfl, frame); + return 0; } - int -nfs_fop_mkdir (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - mode_t mode, fop_mkdir_cbk_t cbk, void *local) +nfs_fop_mkdir(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + mode_t mode, fop_mkdir_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; - - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return ret; - - gf_msg_trace (GF_NFS, 0, "Mkdir: %s", pathloc->path); - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); - nfs_fop_save_root_ino (nfl, pathloc); - nfs_fop_gfid_setup (nfl, pathloc->inode, ret, err); - - STACK_WIND_COOKIE (frame, nfs_fop_mkdir_cbk, xl, xl, xl->fops->mkdir, - pathloc, mode, 0, nfl->dictgfid); - ret = 0; -err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) return ret; -} + gf_msg_trace(GF_NFS, 0, "Mkdir: %s", pathloc->path); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_save_root_ino(nfl, pathloc); + nfs_fop_gfid_setup(nfl, pathloc->inode, ret, err); -int32_t -nfs_fop_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) -{ - struct nfs_fop_local *nfl = NULL; - fop_symlink_cbk_t progcbk = NULL; + STACK_WIND_COOKIE(frame, nfs_fop_mkdir_cbk, xl, xl, xl->fops->mkdir, + pathloc, mode, 0, nfl->dictgfid); + ret = 0; +err: + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } - if (op_ret == 0) { - nfs_fix_generation(this,inode); - } + return ret; +} - nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, op_ret,buf, NULL, preparent, postparent); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); - nfs_stack_destroy (nfl, frame); - return 0; +int32_t +nfs_fop_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) +{ + struct nfs_fop_local *nfl = NULL; + fop_symlink_cbk_t progcbk = NULL; + + if (op_ret == 0) { + nfs_fix_generation(this, inode); + } + + nfl_to_prog_data(nfl, progcbk, frame); + nfs_fop_restore_root_ino(nfl, op_ret, buf, NULL, preparent, postparent); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); + nfs_stack_destroy(nfl, frame); + return 0; } int -nfs_fop_symlink (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, char *target, - loc_t *pathloc, fop_symlink_cbk_t cbk, void *local) +nfs_fop_symlink(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, char *target, + loc_t *pathloc, fop_symlink_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; - - if ((!nfsx) || (!xl) || (!pathloc) || (!target) || (!nfu)) - return ret; - - gf_msg_trace (GF_NFS, 0, "Symlink: %s", pathloc->path); - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); - nfs_fop_save_root_ino (nfl, pathloc); - nfs_fop_gfid_setup (nfl, pathloc->inode, ret, err); - - STACK_WIND_COOKIE (frame, nfs_fop_symlink_cbk, xl, xl, - xl->fops->symlink, target, pathloc, - 0, nfl->dictgfid); - ret = 0; -err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; + if ((!nfsx) || (!xl) || (!pathloc) || (!target) || (!nfu)) return ret; -} + gf_msg_trace(GF_NFS, 0, "Symlink: %s", pathloc->path); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_save_root_ino(nfl, pathloc); + nfs_fop_gfid_setup(nfl, pathloc->inode, ret, err); + + STACK_WIND_COOKIE(frame, nfs_fop_symlink_cbk, xl, xl, xl->fops->symlink, + target, pathloc, 0, nfl->dictgfid); + ret = 0; +err: + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } + + return ret; +} int32_t -nfs_fop_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, const char *path, - struct iatt *buf, dict_t *xdata) +nfs_fop_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, const char *path, + struct iatt *buf, dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_readlink_cbk_t progcbk = NULL; - - nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, op_ret, buf, NULL, NULL, NULL); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, path, buf, - xdata); - nfs_stack_destroy (nfl, frame); - return 0; + struct nfs_fop_local *nfl = NULL; + fop_readlink_cbk_t progcbk = NULL; + + nfl_to_prog_data(nfl, progcbk, frame); + nfs_fop_restore_root_ino(nfl, op_ret, buf, NULL, NULL, NULL); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, path, buf, xdata); + nfs_stack_destroy(nfl, frame); + return 0; } - int -nfs_fop_readlink (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - size_t size, fop_readlink_cbk_t cbk, void *local) +nfs_fop_readlink(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + size_t size, fop_readlink_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return ret; + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) + return ret; - gf_msg_trace (GF_NFS, 0, "Readlink: %s", pathloc->path); - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); - nfs_fop_save_root_ino (nfl, pathloc); + gf_msg_trace(GF_NFS, 0, "Readlink: %s", pathloc->path); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_save_root_ino(nfl, pathloc); - STACK_WIND_COOKIE (frame, nfs_fop_readlink_cbk, xl, xl, - xl->fops->readlink, pathloc, size, NULL); - ret = 0; + STACK_WIND_COOKIE(frame, nfs_fop_readlink_cbk, xl, xl, xl->fops->readlink, + pathloc, size, NULL); + ret = 0; err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } - return ret; + return ret; } - int32_t -nfs_fop_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +nfs_fop_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_mknod_cbk_t progcbk = NULL; - - if (op_ret == 0) { - nfs_fix_generation(this,inode); - } - - nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, op_ret,buf, NULL, preparent, postparent); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); - nfs_stack_destroy (nfl, frame); - return 0; + struct nfs_fop_local *nfl = NULL; + fop_mknod_cbk_t progcbk = NULL; + + if (op_ret == 0) { + nfs_fix_generation(this, inode); + } + + nfl_to_prog_data(nfl, progcbk, frame); + nfs_fop_restore_root_ino(nfl, op_ret, buf, NULL, preparent, postparent); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); + nfs_stack_destroy(nfl, frame); + return 0; } - int -nfs_fop_mknod (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - mode_t mode, dev_t dev, fop_mknod_cbk_t cbk, void *local) +nfs_fop_mknod(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + mode_t mode, dev_t dev, fop_mknod_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; - - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return ret; - - gf_msg_trace (GF_NFS, 0, "Mknod: %s", pathloc->path); - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); - nfs_fop_save_root_ino (nfl, pathloc); - nfs_fop_gfid_setup (nfl, pathloc->inode, ret, err); - - STACK_WIND_COOKIE (frame, nfs_fop_mknod_cbk, xl, xl, xl->fops->mknod, - pathloc, mode, dev, 0, nfl->dictgfid); - ret = 0; -err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) return ret; + + gf_msg_trace(GF_NFS, 0, "Mknod: %s", pathloc->path); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_save_root_ino(nfl, pathloc); + nfs_fop_gfid_setup(nfl, pathloc->inode, ret, err); + + STACK_WIND_COOKIE(frame, nfs_fop_mknod_cbk, xl, xl, xl->fops->mknod, + pathloc, mode, dev, 0, nfl->dictgfid); + ret = 0; +err: + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } + + return ret; } int32_t -nfs_fop_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +nfs_fop_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - struct nfs_fop_local *nfl = frame->local; - fop_rmdir_cbk_t progcbk = NULL; - - nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, op_ret, NULL, NULL, preparent, - postparent); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, preparent, - postparent, NULL); - nfs_stack_destroy (nfl, frame); - return 0; + struct nfs_fop_local *nfl = frame->local; + fop_rmdir_cbk_t progcbk = NULL; + + nfl_to_prog_data(nfl, progcbk, frame); + nfs_fop_restore_root_ino(nfl, op_ret, NULL, NULL, preparent, postparent); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, preparent, postparent, + NULL); + nfs_stack_destroy(nfl, frame); + return 0; } - - int -nfs_fop_rmdir (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - fop_rmdir_cbk_t cbk, void *local) +nfs_fop_rmdir(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + fop_rmdir_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return ret; + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) + return ret; - gf_msg_trace (GF_NFS, 0, "Rmdir: %s", pathloc->path); - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); - nfs_fop_save_root_ino (nfl, pathloc); + gf_msg_trace(GF_NFS, 0, "Rmdir: %s", pathloc->path); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_save_root_ino(nfl, pathloc); - STACK_WIND_COOKIE (frame, nfs_fop_rmdir_cbk, xl, xl, xl->fops->rmdir, - pathloc, 0, NULL); - ret = 0; + STACK_WIND_COOKIE(frame, nfs_fop_rmdir_cbk, xl, xl, xl->fops->rmdir, + pathloc, 0, NULL); + ret = 0; err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } - - return ret; + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } + return ret; } - int32_t -nfs_fop_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +nfs_fop_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - struct nfs_fop_local *nfl = frame->local; - fop_unlink_cbk_t progcbk = NULL; - - nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, op_ret, NULL, NULL, preparent, - postparent); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, preparent, - postparent, xdata); - nfs_stack_destroy (nfl, frame); - return 0; + struct nfs_fop_local *nfl = frame->local; + fop_unlink_cbk_t progcbk = NULL; + + nfl_to_prog_data(nfl, progcbk, frame); + nfs_fop_restore_root_ino(nfl, op_ret, NULL, NULL, preparent, postparent); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, preparent, postparent, + xdata); + nfs_stack_destroy(nfl, frame); + return 0; } - int -nfs_fop_unlink (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - fop_unlink_cbk_t cbk, void *local) +nfs_fop_unlink(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + fop_unlink_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return ret; + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) + return ret; - gf_msg_trace (GF_NFS, 0, "Unlink: %s", pathloc->path); - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); - nfs_fop_save_root_ino (nfl, pathloc); + gf_msg_trace(GF_NFS, 0, "Unlink: %s", pathloc->path); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_save_root_ino(nfl, pathloc); - STACK_WIND_COOKIE (frame, nfs_fop_unlink_cbk, xl, xl, - xl->fops->unlink, pathloc, 0, NULL); - ret = 0; + STACK_WIND_COOKIE(frame, nfs_fop_unlink_cbk, xl, xl, xl->fops->unlink, + pathloc, 0, NULL); + ret = 0; err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } - - return ret; + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } + return ret; } - int32_t -nfs_fop_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +nfs_fop_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_link_cbk_t progcbk = NULL; + struct nfs_fop_local *nfl = NULL; + fop_link_cbk_t progcbk = NULL; - if (op_ret == 0) { - nfs_fix_generation(this,inode); - } + if (op_ret == 0) { + nfs_fix_generation(this, inode); + } - nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, op_ret, buf, NULL, preparent, - postparent); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); + nfl_to_prog_data(nfl, progcbk, frame); + nfs_fop_restore_root_ino(nfl, op_ret, buf, NULL, preparent, postparent); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); - nfs_stack_destroy (nfl, frame); - return 0; + nfs_stack_destroy(nfl, frame); + return 0; } - int -nfs_fop_link (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc, - loc_t *newloc, fop_link_cbk_t cbk, void *local) +nfs_fop_link(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc, + loc_t *newloc, fop_link_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; - - if ((!nfsx) || (!xl) || (!oldloc) || (!newloc) || (!nfu)) - return ret; - - gf_msg_trace (GF_NFS, 0, "Link: %s -> %s", newloc->path, - oldloc->path); - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); - nfs_fop_save_root_ino (nfl, newloc); - - STACK_WIND_COOKIE (frame, nfs_fop_link_cbk, xl, xl, xl->fops->link, - oldloc, newloc, NULL); - ret = 0; -err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; + if ((!nfsx) || (!xl) || (!oldloc) || (!newloc) || (!nfu)) return ret; -} + gf_msg_trace(GF_NFS, 0, "Link: %s -> %s", newloc->path, oldloc->path); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_save_root_ino(nfl, newloc); -int32_t -nfs_fop_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, - struct iatt *preoldparent, struct iatt *postoldparent, - struct iatt *prenewparent, struct iatt *postnewparent, - dict_t *xdata) -{ + STACK_WIND_COOKIE(frame, nfs_fop_link_cbk, xl, xl, xl->fops->link, oldloc, + newloc, NULL); + ret = 0; +err: + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } - struct nfs_fop_local *nfl = NULL; - fop_rename_cbk_t progcbk = NULL; - - nfl_to_prog_data (nfl, progcbk, frame); - /* The preattr arg needs to be NULL instead of @buf because it is - * possible that the new parent is not root whereas the source dir - * could have been. That is handled in the next macro. - */ - nfs_fop_restore_root_ino (nfl, op_ret, NULL, NULL, preoldparent, - postoldparent); - nfs_fop_newloc_restore_root_ino (nfl, op_ret, buf, NULL, prenewparent, - postnewparent); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, buf, - preoldparent, postoldparent, prenewparent, - postnewparent, xdata); - nfs_stack_destroy (nfl, frame); - return 0; + return ret; } +int32_t +nfs_fop_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *buf, + struct iatt *preoldparent, struct iatt *postoldparent, + struct iatt *prenewparent, struct iatt *postnewparent, + dict_t *xdata) +{ + struct nfs_fop_local *nfl = NULL; + fop_rename_cbk_t progcbk = NULL; + + nfl_to_prog_data(nfl, progcbk, frame); + /* The preattr arg needs to be NULL instead of @buf because it is + * possible that the new parent is not root whereas the source dir + * could have been. That is handled in the next macro. + */ + nfs_fop_restore_root_ino(nfl, op_ret, NULL, NULL, preoldparent, + postoldparent); + nfs_fop_newloc_restore_root_ino(nfl, op_ret, buf, NULL, prenewparent, + postnewparent); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, buf, preoldparent, + postoldparent, prenewparent, postnewparent, xdata); + nfs_stack_destroy(nfl, frame); + return 0; +} int -nfs_fop_rename (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc, - loc_t *newloc, fop_rename_cbk_t cbk, void *local) +nfs_fop_rename(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc, + loc_t *newloc, fop_rename_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; - - if ((!nfsx) || (!xl) || (!oldloc) || (!newloc) || (!nfu)) - return ret; - - gf_msg_trace (GF_NFS, 0, "Rename: %s -> %s", oldloc->path, - newloc->path); - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); - nfs_fop_save_root_ino (nfl, oldloc); - nfs_fop_newloc_save_root_ino (nfl, newloc); - - STACK_WIND_COOKIE (frame, nfs_fop_rename_cbk, xl, xl, - xl->fops->rename, oldloc, newloc, NULL); - ret = 0; -err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; + if ((!nfsx) || (!xl) || (!oldloc) || (!newloc) || (!nfu)) return ret; -} + gf_msg_trace(GF_NFS, 0, "Rename: %s -> %s", oldloc->path, newloc->path); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_save_root_ino(nfl, oldloc); + nfs_fop_newloc_save_root_ino(nfl, newloc); + + STACK_WIND_COOKIE(frame, nfs_fop_rename_cbk, xl, xl, xl->fops->rename, + oldloc, newloc, NULL); + ret = 0; +err: + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } + + return ret; +} int32_t -nfs_fop_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) +nfs_fop_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_open_cbk_t progcbk = NULL; + struct nfs_fop_local *nfl = NULL; + fop_open_cbk_t progcbk = NULL; - nfl_to_prog_data (nfl, progcbk, frame); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, fd, xdata); - nfs_stack_destroy (nfl, frame); + nfl_to_prog_data(nfl, progcbk, frame); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, fd, xdata); + nfs_stack_destroy(nfl, frame); - return 0; + return 0; } int -nfs_fop_open (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, - int32_t flags, fd_t *fd, fop_open_cbk_t cbk, - void *local) +nfs_fop_open(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, + int32_t flags, fd_t *fd, fop_open_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; - if ((!nfsx) || (!xl) || (!loc) || (!fd) || (!nfu)) - return ret; + if ((!nfsx) || (!xl) || (!loc) || (!fd) || (!nfu)) + return ret; - gf_msg_trace (GF_NFS, 0, "Open: %s", loc->path); - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); + gf_msg_trace(GF_NFS, 0, "Open: %s", loc->path); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); - STACK_WIND_COOKIE (frame, nfs_fop_open_cbk, xl, xl, xl->fops->open, - loc, flags, fd, NULL); - ret = 0; + STACK_WIND_COOKIE(frame, nfs_fop_open_cbk, xl, xl, xl->fops->open, loc, + flags, fd, NULL); + ret = 0; err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } - return ret; + return ret; } - int32_t -nfs_fop_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf, dict_t *xdata) +nfs_fop_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_writev_cbk_t progcbk = NULL; + struct nfs_fop_local *nfl = NULL; + fop_writev_cbk_t progcbk = NULL; - nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, op_ret, prebuf, postbuf, NULL, NULL); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, prebuf, - postbuf, xdata); + nfl_to_prog_data(nfl, progcbk, frame); + nfs_fop_restore_root_ino(nfl, op_ret, prebuf, postbuf, NULL, NULL); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, prebuf, postbuf, xdata); - nfs_stack_destroy (nfl, frame); + nfs_stack_destroy(nfl, frame); - return 0; + return 0; } - int -nfs_fop_write (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, - struct iobref *srciobref, struct iovec *vector, int32_t count, - off_t offset, fop_writev_cbk_t cbk, void *local) +nfs_fop_write(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, + struct iobref *srciobref, struct iovec *vector, int32_t count, + off_t offset, fop_writev_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; - int flags = 0; - nfs3_call_state_t *cs = local; - - if ((!nfsx) || (!xl) || (!fd) || (!vector) || (!nfu) || (!srciobref)) - return ret; - - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); - nfs_fop_save_root_fd_ino (nfl, fd); -/* - nfl->iobref = iobref_new (); - if (!nfl->iobref) { - gf_log (GF_NFS, GF_LOG_ERROR, "iobref creation failed"); - ret = -ENOMEM; - goto err; - } + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; + int flags = 0; + nfs3_call_state_t *cs = local; - iobref_add (nfl->iobref, srciob); -*/ + if ((!nfsx) || (!xl) || (!fd) || (!vector) || (!nfu) || (!srciobref)) + return ret; - switch (cs->writetype) { + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_save_root_fd_ino(nfl, fd); + /* + nfl->iobref = iobref_new (); + if (!nfl->iobref) { + gf_log (GF_NFS, GF_LOG_ERROR, "iobref creation failed"); + ret = -ENOMEM; + goto err; + } + + iobref_add (nfl->iobref, srciob); + */ + + switch (cs->writetype) { case UNSTABLE: - break; + break; case DATA_SYNC: - flags |= O_DSYNC; - break; + flags |= O_DSYNC; + break; case FILE_SYNC: - flags |= O_SYNC; - break; - } + flags |= O_SYNC; + break; + } - STACK_WIND_COOKIE (frame, nfs_fop_writev_cbk, xl, xl,xl->fops->writev, - fd, vector, count, offset, flags, srciobref, NULL); - ret = 0; + STACK_WIND_COOKIE(frame, nfs_fop_writev_cbk, xl, xl, xl->fops->writev, fd, + vector, count, offset, flags, srciobref, NULL); + ret = 0; err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } - return ret; + return ret; } - int32_t -nfs_fop_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf, dict_t *xdata) +nfs_fop_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_fsync_cbk_t progcbk = NULL; + struct nfs_fop_local *nfl = NULL; + fop_fsync_cbk_t progcbk = NULL; - nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, op_ret, prebuf, postbuf, NULL, NULL); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, prebuf, - postbuf, xdata); + nfl_to_prog_data(nfl, progcbk, frame); + nfs_fop_restore_root_ino(nfl, op_ret, prebuf, postbuf, NULL, NULL); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, prebuf, postbuf, xdata); - nfs_stack_destroy (nfl, frame); - return 0; + nfs_stack_destroy(nfl, frame); + return 0; } - - int -nfs_fop_fsync (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, - int32_t datasync, fop_fsync_cbk_t cbk, void *local) +nfs_fop_fsync(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, + int32_t datasync, fop_fsync_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; - if ((!nfsx) || (!xl) || (!fd)) - return ret; + if ((!nfsx) || (!xl) || (!fd)) + return ret; - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); - nfs_fop_save_root_fd_ino (nfl, fd); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_save_root_fd_ino(nfl, fd); - STACK_WIND_COOKIE (frame, nfs_fop_fsync_cbk, xl, xl, - xl->fops->fsync, fd, datasync, NULL); - ret = 0; + STACK_WIND_COOKIE(frame, nfs_fop_fsync_cbk, xl, xl, xl->fops->fsync, fd, + datasync, NULL); + ret = 0; err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } - return ret; + return ret; } - int32_t -nfs_fop_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iovec *vector, - int32_t count, struct iatt *stbuf, struct iobref *iobref, - dict_t *xdata) +nfs_fop_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iovec *vector, + int32_t count, struct iatt *stbuf, struct iobref *iobref, + dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_readv_cbk_t progcbk = NULL; + struct nfs_fop_local *nfl = NULL; + fop_readv_cbk_t progcbk = NULL; - nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, op_ret, stbuf, NULL, NULL, NULL); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, vector, count, - stbuf, iobref, xdata); + nfl_to_prog_data(nfl, progcbk, frame); + nfs_fop_restore_root_ino(nfl, op_ret, stbuf, NULL, NULL, NULL); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, vector, count, stbuf, + iobref, xdata); - nfs_stack_destroy (nfl, frame); - return 0; + nfs_stack_destroy(nfl, frame); + return 0; } - int -nfs_fop_read (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, - size_t size, off_t offset, fop_readv_cbk_t cbk, void *local) +nfs_fop_read(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, + size_t size, off_t offset, fop_readv_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; - if ((!xl) || (!fd) || (!nfu)) - return ret; + if ((!xl) || (!fd) || (!nfu)) + return ret; - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); - nfs_fop_save_root_fd_ino (nfl, fd); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_save_root_fd_ino(nfl, fd); - STACK_WIND_COOKIE (frame, nfs_fop_readv_cbk, xl, xl, xl->fops->readv, - fd, size, offset, 0, NULL); - ret = 0; + STACK_WIND_COOKIE(frame, nfs_fop_readv_cbk, xl, xl, xl->fops->readv, fd, + size, offset, 0, NULL); + ret = 0; err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } - return ret; + return ret; } int32_t -nfs_fop_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct gf_flock *flock, - dict_t *xdata) +nfs_fop_lk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct gf_flock *flock, + dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_lk_cbk_t progcbk = NULL; + struct nfs_fop_local *nfl = NULL; + fop_lk_cbk_t progcbk = NULL; - nfl_to_prog_data (nfl, progcbk, frame); + nfl_to_prog_data(nfl, progcbk, frame); - if (!op_ret) - fd_lk_insert_and_merge (nfl->fd, nfl->cmd, &nfl->flock); + if (!op_ret) + fd_lk_insert_and_merge(nfl->fd, nfl->cmd, &nfl->flock); - fd_unref (nfl->fd); + fd_unref(nfl->fd); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, flock, xdata); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, flock, xdata); - nfs_stack_destroy (nfl, frame); - return 0; + nfs_stack_destroy(nfl, frame); + return 0; } - int -nfs_fop_lk (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, - int cmd, struct gf_flock *flock, fop_lk_cbk_t cbk, void *local) +nfs_fop_lk(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, int cmd, + struct gf_flock *flock, fop_lk_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; - if ((!xl) || (!fd) || (!nfu)) - return ret; + if ((!xl) || (!fd) || (!nfu)) + return ret; - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); - nfl->cmd = cmd; - nfl->fd = fd_ref (fd); - nfl->flock = *flock; + nfl->cmd = cmd; + nfl->fd = fd_ref(fd); + nfl->flock = *flock; - STACK_WIND_COOKIE (frame, nfs_fop_lk_cbk, xl, xl, xl->fops->lk, - fd, cmd, flock, NULL); - ret = 0; + STACK_WIND_COOKIE(frame, nfs_fop_lk_cbk, xl, xl, xl->fops->lk, fd, cmd, + flock, NULL); + ret = 0; err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } - return ret; + return ret; } int32_t -nfs_fop_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict, - dict_t *xdata) +nfs_fop_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *dict, + dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_getxattr_cbk_t progcbk = NULL; + struct nfs_fop_local *nfl = NULL; + fop_getxattr_cbk_t progcbk = NULL; - nfl_to_prog_data (nfl, progcbk, frame); + nfl_to_prog_data(nfl, progcbk, frame); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, dict, xdata); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, dict, xdata); - nfs_stack_destroy (nfl, frame); - return 0; + nfs_stack_destroy(nfl, frame); + return 0; } - int -nfs_fop_getxattr (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, - char *name, dict_t *xdata, fop_getxattr_cbk_t cbk, void *local) +nfs_fop_getxattr(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, + char *name, dict_t *xdata, fop_getxattr_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; - if ((!xl) || (!loc) || (!nfu)) - return ret; + if ((!xl) || (!loc) || (!nfu)) + return ret; - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); - STACK_WIND_COOKIE (frame, nfs_fop_getxattr_cbk, xl, xl, xl->fops->getxattr, - loc, name, NULL); - ret = 0; + STACK_WIND_COOKIE(frame, nfs_fop_getxattr_cbk, xl, xl, xl->fops->getxattr, + loc, name, NULL); + ret = 0; err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } - return ret; + return ret; } - int32_t -nfs_fop_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +nfs_fop_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_setxattr_cbk_t progcbk = NULL; + struct nfs_fop_local *nfl = NULL; + fop_setxattr_cbk_t progcbk = NULL; - nfl_to_prog_data (nfl, progcbk, frame); + nfl_to_prog_data(nfl, progcbk, frame); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, xdata); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, xdata); - nfs_stack_destroy (nfl, frame); - return 0; + nfs_stack_destroy(nfl, frame); + return 0; } - int -nfs_fop_setxattr (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, - loc_t *loc, dict_t *dict, int32_t flags, dict_t *xdata, - fop_setxattr_cbk_t cbk, void *local) +nfs_fop_setxattr(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, + dict_t *dict, int32_t flags, dict_t *xdata, + fop_setxattr_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; - if ((!xl) || (!loc) || (!nfu)) - return ret; + if ((!xl) || (!loc) || (!nfu)) + return ret; - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); - STACK_WIND_COOKIE (frame, nfs_fop_setxattr_cbk, xl, xl, xl->fops->setxattr, - loc, dict, flags, xdata); - ret = 0; + STACK_WIND_COOKIE(frame, nfs_fop_setxattr_cbk, xl, xl, xl->fops->setxattr, + loc, dict, flags, xdata); + ret = 0; err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } - return ret; + return ret; } - int32_t -nfs_fop_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf, dict_t *xdata) +nfs_fop_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_truncate_cbk_t progcbk = NULL; + struct nfs_fop_local *nfl = NULL; + fop_truncate_cbk_t progcbk = NULL; - nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, op_ret, prebuf, postbuf, NULL, NULL); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, prebuf, - postbuf, xdata); + nfl_to_prog_data(nfl, progcbk, frame); + nfs_fop_restore_root_ino(nfl, op_ret, prebuf, postbuf, NULL, NULL); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, prebuf, postbuf, xdata); - nfs_stack_destroy (nfl, frame); - return 0; + nfs_stack_destroy(nfl, frame); + return 0; } - int -nfs_fop_truncate (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, - off_t offset, fop_truncate_cbk_t cbk, void *local) +nfs_fop_truncate(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, + off_t offset, fop_truncate_cbk_t cbk, void *local) { - call_frame_t *frame = NULL; - int ret = -EFAULT; - struct nfs_fop_local *nfl = NULL; + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; - if ((!nfsx) || (!xl) || (!loc) || (!nfu)) - return ret; + if ((!nfsx) || (!xl) || (!loc) || (!nfu)) + return ret; - nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); - nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); - nfs_fop_save_root_ino (nfl, loc); + nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_save_root_ino(nfl, loc); - STACK_WIND_COOKIE (frame, nfs_fop_truncate_cbk, xl, xl, - xl->fops->truncate, loc, offset, NULL); + STACK_WIND_COOKIE(frame, nfs_fop_truncate_cbk, xl, xl, xl->fops->truncate, + loc, offset, NULL); - ret = 0; + ret = 0; err: - if (ret < 0) { - if (frame) - nfs_stack_destroy (nfl, frame); - } + if (ret < 0) { + if (frame) + nfs_stack_destroy(nfl, frame); + } - return ret; + return ret; } diff --git a/xlators/nfs/server/src/nfs-generics.c b/xlators/nfs/server/src/nfs-generics.c index 7e10ea8978..feadb4cfb3 100644 --- a/xlators/nfs/server/src/nfs-generics.c +++ b/xlators/nfs/server/src/nfs-generics.c @@ -8,7 +8,6 @@ cases as published by the Free Software Foundation. */ - #include "string.h" #include "nfs.h" @@ -17,323 +16,297 @@ #include "nfs-generics.h" #include "xlator.h" - int -nfs_fstat (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, - fop_stat_cbk_t cbk, void *local) +nfs_fstat(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, + fop_stat_cbk_t cbk, void *local) { - int ret = -EFAULT; - - if ((!nfsx) || (!xl) || (!fd) || (!nfu)) - return ret; + int ret = -EFAULT; - ret = nfs_fop_fstat (nfsx, xl, nfu, fd, cbk, local); + if ((!nfsx) || (!xl) || (!fd) || (!nfu)) return ret; + + ret = nfs_fop_fstat(nfsx, xl, nfu, fd, cbk, local); + return ret; } int -nfs_access (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - int32_t accesstest, fop_access_cbk_t cbk, void *local) +nfs_access(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + int32_t accesstest, fop_access_cbk_t cbk, void *local) { - int ret = -EFAULT; + int ret = -EFAULT; - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return ret; + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) + return ret; - ret = nfs_fop_access (nfsx, xl, nfu, pathloc, accesstest, cbk, local); + ret = nfs_fop_access(nfsx, xl, nfu, pathloc, accesstest, cbk, local); - return ret; + return ret; } int -nfs_stat (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - fop_stat_cbk_t cbk, void *local) +nfs_stat(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + fop_stat_cbk_t cbk, void *local) { - int ret = -EFAULT; + int ret = -EFAULT; - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return ret; + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) + return ret; - ret = nfs_fop_stat (nfsx, xl, nfu, pathloc, cbk, local); + ret = nfs_fop_stat(nfsx, xl, nfu, pathloc, cbk, local); - return ret; + return ret; } - int -nfs_readdirp (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *dirfd, - size_t bufsize, off_t offset, fop_readdir_cbk_t cbk, void *local) +nfs_readdirp(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *dirfd, + size_t bufsize, off_t offset, fop_readdir_cbk_t cbk, void *local) { - if ((!nfsx) || (!xl) || (!dirfd) || (!nfu)) - return -EFAULT; + if ((!nfsx) || (!xl) || (!dirfd) || (!nfu)) + return -EFAULT; - return nfs_fop_readdirp (nfsx, xl, nfu, dirfd, bufsize, offset, cbk, - local); + return nfs_fop_readdirp(nfsx, xl, nfu, dirfd, bufsize, offset, cbk, local); } - int -nfs_lookup (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - fop_lookup_cbk_t cbk, void *local) +nfs_lookup(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + fop_lookup_cbk_t cbk, void *local) { - int ret = -EFAULT; + int ret = -EFAULT; - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return ret; - - ret = nfs_fop_lookup (nfsx, xl, nfu, pathloc, cbk, local); + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) return ret; + + ret = nfs_fop_lookup(nfsx, xl, nfu, pathloc, cbk, local); + return ret; } int -nfs_create (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - int flags, mode_t mode, fop_create_cbk_t cbk, void *local) +nfs_create(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + int flags, mode_t mode, fop_create_cbk_t cbk, void *local) { - int ret = -EFAULT; - - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return ret; + int ret = -EFAULT; - ret = nfs_inode_create (nfsx, xl, nfu, pathloc, flags, mode, cbk,local); + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) return ret; -} + ret = nfs_inode_create(nfsx, xl, nfu, pathloc, flags, mode, cbk, local); + return ret; +} int -nfs_flush (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, - fop_flush_cbk_t cbk, void *local) +nfs_flush(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, + fop_flush_cbk_t cbk, void *local) { - return nfs_fop_flush (nfsx, xl, nfu, fd, cbk, local); + return nfs_fop_flush(nfsx, xl, nfu, fd, cbk, local); } - - int -nfs_mkdir (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - mode_t mode, fop_mkdir_cbk_t cbk, void *local) +nfs_mkdir(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + mode_t mode, fop_mkdir_cbk_t cbk, void *local) { - int ret = -EFAULT; + int ret = -EFAULT; - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return ret; - - ret = nfs_inode_mkdir (nfsx, xl, nfu, pathloc, mode, cbk, local); + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) return ret; -} - + ret = nfs_inode_mkdir(nfsx, xl, nfu, pathloc, mode, cbk, local); + return ret; +} int -nfs_truncate (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - off_t offset, fop_truncate_cbk_t cbk, void *local) +nfs_truncate(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + off_t offset, fop_truncate_cbk_t cbk, void *local) { - int ret = -EFAULT; + int ret = -EFAULT; - if ((!xl) || (!pathloc) || (!nfu)) - return ret; - - ret = nfs_fop_truncate (nfsx, xl, nfu, pathloc, offset, cbk, local); + if ((!xl) || (!pathloc) || (!nfu)) return ret; + + ret = nfs_fop_truncate(nfsx, xl, nfu, pathloc, offset, cbk, local); + return ret; } int -nfs_read (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, size_t size, - off_t offset, fop_readv_cbk_t cbk, void *local) +nfs_read(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, size_t size, + off_t offset, fop_readv_cbk_t cbk, void *local) { - return nfs_fop_read (nfsx, xl, nfu, fd, size, offset, cbk, local); + return nfs_fop_read(nfsx, xl, nfu, fd, size, offset, cbk, local); } int -nfs_lk (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, - int cmd, struct gf_flock *flock, fop_lk_cbk_t cbk, void *local) +nfs_lk(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, int cmd, + struct gf_flock *flock, fop_lk_cbk_t cbk, void *local) { - return nfs_fop_lk ( nfsx, xl, nfu, fd, cmd, flock, cbk, local); + return nfs_fop_lk(nfsx, xl, nfu, fd, cmd, flock, cbk, local); } int -nfs_getxattr (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, - char *name, dict_t *xdata, fop_getxattr_cbk_t cbk, void *local) +nfs_getxattr(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, + char *name, dict_t *xdata, fop_getxattr_cbk_t cbk, void *local) { - return nfs_fop_getxattr (nfsx, xl, nfu, loc, name, xdata, cbk, local); + return nfs_fop_getxattr(nfsx, xl, nfu, loc, name, xdata, cbk, local); } int -nfs_setxattr (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, - loc_t *loc, dict_t *dict, int32_t flags, dict_t *xdata, - fop_setxattr_cbk_t cbk, void *local) +nfs_setxattr(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, + dict_t *dict, int32_t flags, dict_t *xdata, fop_setxattr_cbk_t cbk, + void *local) { - return nfs_fop_setxattr (nfsx, xl, nfu, loc, dict, flags, xdata, cbk, - local); + return nfs_fop_setxattr(nfsx, xl, nfu, loc, dict, flags, xdata, cbk, local); } int -nfs_fsync (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, - int32_t datasync, fop_fsync_cbk_t cbk, void *local) +nfs_fsync(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, + int32_t datasync, fop_fsync_cbk_t cbk, void *local) { - return nfs_fop_fsync (nfsx, xl, nfu, fd, datasync, cbk, local); + return nfs_fop_fsync(nfsx, xl, nfu, fd, datasync, cbk, local); } - int -nfs_write (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, - struct iobref *srciobref, struct iovec *vector, int32_t count, - off_t offset, fop_writev_cbk_t cbk, void *local) +nfs_write(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, + struct iobref *srciobref, struct iovec *vector, int32_t count, + off_t offset, fop_writev_cbk_t cbk, void *local) { - return nfs_fop_write (nfsx, xl, nfu, fd, srciobref, vector, count, - offset, cbk, local); + return nfs_fop_write(nfsx, xl, nfu, fd, srciobref, vector, count, offset, + cbk, local); } - int -nfs_open (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - int32_t flags, fop_open_cbk_t cbk, void *local) +nfs_open(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + int32_t flags, fop_open_cbk_t cbk, void *local) { - int ret = -EFAULT; - - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return ret; + int ret = -EFAULT; - ret = nfs_inode_open (nfsx, xl, nfu, pathloc, flags, cbk, - local); + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) return ret; -} + ret = nfs_inode_open(nfsx, xl, nfu, pathloc, flags, cbk, local); + return ret; +} int -nfs_rename (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc, - loc_t *newloc, fop_rename_cbk_t cbk, void *local) +nfs_rename(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc, + loc_t *newloc, fop_rename_cbk_t cbk, void *local) { - int ret = -EFAULT; - - if ((!nfsx) || (!xl) || (!oldloc) || (!newloc) || (!nfu)) - return ret; + int ret = -EFAULT; - ret = nfs_inode_rename (nfsx, xl, nfu, oldloc, newloc, cbk, local); + if ((!nfsx) || (!xl) || (!oldloc) || (!newloc) || (!nfu)) return ret; -} + ret = nfs_inode_rename(nfsx, xl, nfu, oldloc, newloc, cbk, local); + return ret; +} int -nfs_link (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc, - loc_t *newloc, fop_link_cbk_t cbk, void *local) +nfs_link(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc, + loc_t *newloc, fop_link_cbk_t cbk, void *local) { - int ret = -EFAULT; + int ret = -EFAULT; - if ((!nfsx) || (!xl) || (!oldloc) || (!newloc) || (!nfu)) - return ret; - - ret = nfs_inode_link (nfsx, xl, nfu, oldloc, newloc, cbk, local); + if ((!nfsx) || (!xl) || (!oldloc) || (!newloc) || (!nfu)) return ret; -} + ret = nfs_inode_link(nfsx, xl, nfu, oldloc, newloc, cbk, local); + return ret; +} int -nfs_unlink (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - fop_unlink_cbk_t cbk, void *local) +nfs_unlink(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + fop_unlink_cbk_t cbk, void *local) { - int ret = -EFAULT; - - if ((!xl) || (!pathloc) || (!nfu)) - return ret; + int ret = -EFAULT; - ret = nfs_inode_unlink (nfsx, xl, nfu, pathloc, cbk, local); + if ((!xl) || (!pathloc) || (!nfu)) return ret; -} + ret = nfs_inode_unlink(nfsx, xl, nfu, pathloc, cbk, local); + return ret; +} int -nfs_rmdir (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *path, - fop_rmdir_cbk_t cbk, void *local) +nfs_rmdir(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *path, + fop_rmdir_cbk_t cbk, void *local) { - int ret = -EFAULT; + int ret = -EFAULT; - if ((!nfsx) || (!xl) || (!path) || (!nfu)) - return ret; - - ret = nfs_inode_rmdir (nfsx, xl, nfu, path, cbk, local); + if ((!nfsx) || (!xl) || (!path) || (!nfu)) return ret; -} + ret = nfs_inode_rmdir(nfsx, xl, nfu, path, cbk, local); + return ret; +} int -nfs_mknod (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - mode_t mode, dev_t dev, fop_mknod_cbk_t cbk, void *local) +nfs_mknod(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + mode_t mode, dev_t dev, fop_mknod_cbk_t cbk, void *local) { - int ret = -EFAULT; - - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return ret; + int ret = -EFAULT; - ret = nfs_inode_mknod (nfsx, xl, nfu, pathloc, mode, dev, cbk, local); + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) return ret; -} + ret = nfs_inode_mknod(nfsx, xl, nfu, pathloc, mode, dev, cbk, local); + return ret; +} int -nfs_readlink (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *linkloc, - fop_readlink_cbk_t cbk, void *local) +nfs_readlink(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *linkloc, + fop_readlink_cbk_t cbk, void *local) { - int ret = -EFAULT; - - if ((!nfsx) || (!xl) || (!linkloc) || (!nfu)) - return ret; + int ret = -EFAULT; - ret = nfs_fop_readlink (nfsx, xl, nfu, linkloc, NFS_PATH_MAX, cbk, - local); + if ((!nfsx) || (!xl) || (!linkloc) || (!nfu)) return ret; -} + ret = nfs_fop_readlink(nfsx, xl, nfu, linkloc, NFS_PATH_MAX, cbk, local); + return ret; +} int -nfs_symlink (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, char *target, - loc_t *linkloc, fop_symlink_cbk_t cbk, void *local) +nfs_symlink(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, char *target, + loc_t *linkloc, fop_symlink_cbk_t cbk, void *local) { - int ret = -EFAULT; + int ret = -EFAULT; - if ((!nfsx) || (!xl) || (!linkloc) || (!target) || (!nfu)) - return ret; - - ret = nfs_inode_symlink (nfsx, xl, nfu, target, linkloc, cbk, local); + if ((!nfsx) || (!xl) || (!linkloc) || (!target) || (!nfu)) return ret; -} - + ret = nfs_inode_symlink(nfsx, xl, nfu, target, linkloc, cbk, local); + return ret; +} int -nfs_setattr (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - struct iatt *buf, int32_t valid, fop_setattr_cbk_t cbk, - void *local) +nfs_setattr(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + struct iatt *buf, int32_t valid, fop_setattr_cbk_t cbk, void *local) { - int ret = -EFAULT; - - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return ret; + int ret = -EFAULT; - ret = nfs_fop_setattr (nfsx, xl, nfu, pathloc, buf, valid, cbk, local); + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) return ret; -} + ret = nfs_fop_setattr(nfsx, xl, nfu, pathloc, buf, valid, cbk, local); + return ret; +} int -nfs_statfs (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - fop_statfs_cbk_t cbk, void *local) +nfs_statfs(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + fop_statfs_cbk_t cbk, void *local) { - int ret = -EFAULT; + int ret = -EFAULT; - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return ret; - - ret = nfs_fop_statfs (nfsx, xl, nfu, pathloc, cbk, local); + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) return ret; + + ret = nfs_fop_statfs(nfsx, xl, nfu, pathloc, cbk, local); + return ret; } int -nfs_opendir (xlator_t *nfsx, xlator_t *fopxl, nfs_user_t *nfu, loc_t *pathloc, - fop_opendir_cbk_t cbk, void *local) +nfs_opendir(xlator_t *nfsx, xlator_t *fopxl, nfs_user_t *nfu, loc_t *pathloc, + fop_opendir_cbk_t cbk, void *local) { - if ((!nfsx) || (!fopxl) || (!pathloc) || (!nfu)) - return -EFAULT; + if ((!nfsx) || (!fopxl) || (!pathloc) || (!nfu)) + return -EFAULT; - return nfs_inode_opendir (nfsx, fopxl, nfu, pathloc, cbk, local); + return nfs_inode_opendir(nfsx, fopxl, nfu, pathloc, cbk, local); } - diff --git a/xlators/nfs/server/src/nfs-inodes.c b/xlators/nfs/server/src/nfs-inodes.c index 91703c70a1..9999e884ff 100644 --- a/xlators/nfs/server/src/nfs-inodes.c +++ b/xlators/nfs/server/src/nfs-inodes.c @@ -18,588 +18,562 @@ #include <libgen.h> -#define inodes_nfl_to_prog_data(nflocal, pcbk, fram) \ - do { \ - nflocal = fram->local; \ - fram->local = nflocal->proglocal; \ - *VOID(&pcbk) = nflocal->progcbk; \ - nfs_fop_local_wipe (nflocal->nfsx, nflocal); \ - } while (0) \ +#define inodes_nfl_to_prog_data(nflocal, pcbk, fram) \ + do { \ + nflocal = fram->local; \ + fram->local = nflocal->proglocal; \ + *VOID(&pcbk) = nflocal->progcbk; \ + nfs_fop_local_wipe(nflocal->nfsx, nflocal); \ + } while (0) void -nfl_inodes_init (struct nfs_fop_local *nfl, inode_t *inode, inode_t *parent, - inode_t *newparent, const char *name, const char *newname) +nfl_inodes_init(struct nfs_fop_local *nfl, inode_t *inode, inode_t *parent, + inode_t *newparent, const char *name, const char *newname) { - if (!nfl) - return; + if (!nfl) + return; - if (inode) - nfl->inode = inode_ref (inode); + if (inode) + nfl->inode = inode_ref(inode); - if (parent) - nfl->parent = inode_ref (parent); + if (parent) + nfl->parent = inode_ref(parent); - if (newparent) - nfl->newparent = inode_ref (newparent); + if (newparent) + nfl->newparent = inode_ref(newparent); - if (name) - snprintf (nfl->path, NFS_NAME_MAX, "%s", name); + if (name) + snprintf(nfl->path, NFS_NAME_MAX, "%s", name); - if (newname) - snprintf (nfl->newpath, NFS_NAME_MAX, "%s", newname); - return; + if (newname) + snprintf(nfl->newpath, NFS_NAME_MAX, "%s", newname); + return; } - int32_t -nfs_inode_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode - , struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +nfs_inode_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - struct nfs_fop_local *nfl = frame->local; - fop_create_cbk_t progcbk = NULL; - inode_t *linked_inode = NULL; + struct nfs_fop_local *nfl = frame->local; + fop_create_cbk_t progcbk = NULL; + inode_t *linked_inode = NULL; - if (op_ret == -1) - goto do_not_link; + if (op_ret == -1) + goto do_not_link; - linked_inode = inode_link (inode, nfl->parent, nfl->path, buf); + linked_inode = inode_link(inode, nfl->parent, nfl->path, buf); do_not_link: - /* NFS does not need it, upper layers should not expect the pointer to - * be a valid fd. - */ - fd_unref (fd); - - inodes_nfl_to_prog_data (nfl, progcbk, frame); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, fd, inode, buf, - preparent, postparent, xdata); - - if (linked_inode) { - inode_lookup (linked_inode); - inode_unref (linked_inode); - } - - return 0; + /* NFS does not need it, upper layers should not expect the pointer to + * be a valid fd. + */ + fd_unref(fd); + + inodes_nfl_to_prog_data(nfl, progcbk, frame); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, fd, inode, buf, + preparent, postparent, xdata); + + if (linked_inode) { + inode_lookup(linked_inode); + inode_unref(linked_inode); + } + + return 0; } - int -nfs_inode_create (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, - loc_t *pathloc, int flags, int mode, fop_create_cbk_t cbk, - void *local) +nfs_inode_create(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + int flags, int mode, fop_create_cbk_t cbk, void *local) { - struct nfs_fop_local *nfl = NULL; - int ret = -EFAULT; - fd_t *newfd = NULL; - - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return ret; - - nfs_fop_handle_local_init (NULL, nfsx, nfl, cbk, local, ret, err); - - newfd = fd_create (pathloc->inode, 0); - if (!newfd) { - gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to create new fd"); - ret = -ENOMEM; - goto wipe_nfl; - } - - /* The parent and base name will be needed to link the new inode - * into the inode table. - */ - nfl_inodes_init (nfl, pathloc->inode, pathloc->parent, NULL, - pathloc->name, NULL); - ret = nfs_fop_create (nfsx, xl, nfu, pathloc, flags, mode, newfd, - nfs_inode_create_cbk, nfl); + struct nfs_fop_local *nfl = NULL; + int ret = -EFAULT; + fd_t *newfd = NULL; + + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) + return ret; + + nfs_fop_handle_local_init(NULL, nfsx, nfl, cbk, local, ret, err); + + newfd = fd_create(pathloc->inode, 0); + if (!newfd) { + gf_msg(GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to create new fd"); + ret = -ENOMEM; + goto wipe_nfl; + } + + /* The parent and base name will be needed to link the new inode + * into the inode table. + */ + nfl_inodes_init(nfl, pathloc->inode, pathloc->parent, NULL, pathloc->name, + NULL); + ret = nfs_fop_create(nfsx, xl, nfu, pathloc, flags, mode, newfd, + nfs_inode_create_cbk, nfl); wipe_nfl: - if (ret < 0) - nfs_fop_local_wipe (xl, nfl); + if (ret < 0) + nfs_fop_local_wipe(xl, nfl); err: - return ret; + return ret; } - int32_t -nfs_inode_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +nfs_inode_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - struct nfs_fop_local *nfl = frame->local; - fop_mkdir_cbk_t progcbk = NULL; - inode_t *linked_inode = NULL; + struct nfs_fop_local *nfl = frame->local; + fop_mkdir_cbk_t progcbk = NULL; + inode_t *linked_inode = NULL; - if (op_ret == -1) - goto do_not_link; + if (op_ret == -1) + goto do_not_link; - linked_inode = inode_link (inode, nfl->parent, nfl->path, buf); + linked_inode = inode_link(inode, nfl->parent, nfl->path, buf); do_not_link: - inodes_nfl_to_prog_data (nfl, progcbk, frame); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); + inodes_nfl_to_prog_data(nfl, progcbk, frame); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); - if (linked_inode) { - inode_lookup (linked_inode); - inode_unref (linked_inode); - } + if (linked_inode) { + inode_lookup(linked_inode); + inode_unref(linked_inode); + } - return 0; + return 0; } - int -nfs_inode_mkdir (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - int mode, fop_mkdir_cbk_t cbk, void *local) +nfs_inode_mkdir(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + int mode, fop_mkdir_cbk_t cbk, void *local) { - struct nfs_fop_local *nfl = NULL; - int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; + int ret = -EFAULT; - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return ret; + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) + return ret; - nfs_fop_handle_local_init (NULL, nfsx, nfl, cbk, local, ret, err); - nfl_inodes_init (nfl, pathloc->inode, pathloc->parent, NULL, - pathloc->name, NULL); - ret = nfs_fop_mkdir (nfsx, xl, nfu, pathloc, mode, nfs_inode_mkdir_cbk, - nfl); - if (ret < 0) - nfs_fop_local_wipe (nfsx, nfl); + nfs_fop_handle_local_init(NULL, nfsx, nfl, cbk, local, ret, err); + nfl_inodes_init(nfl, pathloc->inode, pathloc->parent, NULL, pathloc->name, + NULL); + ret = nfs_fop_mkdir(nfsx, xl, nfu, pathloc, mode, nfs_inode_mkdir_cbk, nfl); + if (ret < 0) + nfs_fop_local_wipe(nfsx, nfl); err: - return ret; + return ret; } - int32_t -nfs_inode_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) +nfs_inode_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) { - - struct nfs_fop_local *nfl = NULL; - fop_open_cbk_t progcbk = NULL; - - if ((op_ret == -1) && (fd)) - fd_unref (fd); - /* Not needed here since the fd is cached in higher layers and the bind - * must happen atomically when the fd gets added to the fd LRU. - */ -/* else - fd_bind (fd); -*/ - inodes_nfl_to_prog_data (nfl, progcbk, frame); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, fd, xdata); - return 0; + struct nfs_fop_local *nfl = NULL; + fop_open_cbk_t progcbk = NULL; + + if ((op_ret == -1) && (fd)) + fd_unref(fd); + /* Not needed here since the fd is cached in higher layers and the bind + * must happen atomically when the fd gets added to the fd LRU. + */ + /* else + fd_bind (fd); + */ + inodes_nfl_to_prog_data(nfl, progcbk, frame); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, fd, xdata); + return 0; } - int -nfs_inode_open (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, - int32_t flags, fop_open_cbk_t cbk, void *local) +nfs_inode_open(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, + int32_t flags, fop_open_cbk_t cbk, void *local) { - struct nfs_fop_local *nfl = NULL; - fd_t *newfd = NULL; - int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; + fd_t *newfd = NULL; + int ret = -EFAULT; - if ((!nfsx) || (!xl) || (!loc) || (!nfu)) - return ret; + if ((!nfsx) || (!xl) || (!loc) || (!nfu)) + return ret; - newfd = fd_create (loc->inode, 0); - if (!newfd) { - gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to create fd"); - ret = -ENOMEM; - goto err; - } + newfd = fd_create(loc->inode, 0); + if (!newfd) { + gf_msg(GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to create fd"); + ret = -ENOMEM; + goto err; + } - nfs_fop_handle_local_init (NULL, nfsx, nfl, cbk, local, ret, fd_err); - ret = nfs_fop_open (nfsx, xl, nfu, loc, flags, newfd, - nfs_inode_open_cbk, nfl); + nfs_fop_handle_local_init(NULL, nfsx, nfl, cbk, local, ret, fd_err); + ret = nfs_fop_open(nfsx, xl, nfu, loc, flags, newfd, nfs_inode_open_cbk, + nfl); - if (ret < 0) - nfs_fop_local_wipe (xl, nfl); + if (ret < 0) + nfs_fop_local_wipe(xl, nfl); fd_err: - if (ret < 0) - if (newfd) - fd_unref (newfd); + if (ret < 0) + if (newfd) + fd_unref(newfd); err: - return ret; + return ret; } - - int32_t -nfs_inode_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, - struct iatt *preoldparent, struct iatt *postoldparent, - struct iatt *prenewparent, struct iatt *postnewparent, - dict_t *xdata) +nfs_inode_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *buf, + struct iatt *preoldparent, struct iatt *postoldparent, + struct iatt *prenewparent, struct iatt *postnewparent, + dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_rename_cbk_t progcbk = NULL; + struct nfs_fop_local *nfl = NULL; + fop_rename_cbk_t progcbk = NULL; - nfl = frame->local; - if (op_ret == -1) - goto do_not_link; + nfl = frame->local; + if (op_ret == -1) + goto do_not_link; - inode_rename (this->itable, nfl->parent, nfl->path, nfl->newparent, - nfl->newpath, nfl->inode, buf); + inode_rename(this->itable, nfl->parent, nfl->path, nfl->newparent, + nfl->newpath, nfl->inode, buf); do_not_link: - inodes_nfl_to_prog_data (nfl, progcbk, frame); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, buf, - preoldparent, postoldparent, prenewparent, - postnewparent, xdata); - return 0; + inodes_nfl_to_prog_data(nfl, progcbk, frame); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, buf, preoldparent, + postoldparent, prenewparent, postnewparent, xdata); + return 0; } - int -nfs_inode_rename (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc, - loc_t *newloc, fop_rename_cbk_t cbk, void *local) +nfs_inode_rename(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc, + loc_t *newloc, fop_rename_cbk_t cbk, void *local) { - struct nfs_fop_local *nfl = NULL; - int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; + int ret = -EFAULT; - if ((!nfsx) || (!xl) || (!oldloc) || (!newloc)) - return ret; + if ((!nfsx) || (!xl) || (!oldloc) || (!newloc)) + return ret; - nfs_fop_handle_local_init (NULL, nfsx, nfl, cbk, local, ret, err); - nfl_inodes_init (nfl, oldloc->inode, oldloc->parent, newloc->parent, - oldloc->name, newloc->name); - ret = nfs_fop_rename (nfsx,xl, nfu, oldloc, newloc, nfs_inode_rename_cbk - , nfl); + nfs_fop_handle_local_init(NULL, nfsx, nfl, cbk, local, ret, err); + nfl_inodes_init(nfl, oldloc->inode, oldloc->parent, newloc->parent, + oldloc->name, newloc->name); + ret = nfs_fop_rename(nfsx, xl, nfu, oldloc, newloc, nfs_inode_rename_cbk, + nfl); err: - if (ret < 0) - nfs_fop_local_wipe (xl, nfl); + if (ret < 0) + nfs_fop_local_wipe(xl, nfl); - return ret; + return ret; } - int32_t -nfs_inode_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +nfs_inode_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_link_cbk_t progcbk = NULL; - inode_t *linked_inode = NULL; + struct nfs_fop_local *nfl = NULL; + fop_link_cbk_t progcbk = NULL; + inode_t *linked_inode = NULL; - if (op_ret == -1) - goto do_not_link; + if (op_ret == -1) + goto do_not_link; - nfl = frame->local; - linked_inode = inode_link (inode, nfl->newparent, nfl->path, buf); + nfl = frame->local; + linked_inode = inode_link(inode, nfl->newparent, nfl->path, buf); do_not_link: - inodes_nfl_to_prog_data (nfl, progcbk, frame); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); + inodes_nfl_to_prog_data(nfl, progcbk, frame); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); - if (linked_inode) { - inode_lookup (linked_inode); - inode_unref (linked_inode); - } + if (linked_inode) { + inode_lookup(linked_inode); + inode_unref(linked_inode); + } - return 0; + return 0; } - int -nfs_inode_link (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc, - loc_t *newloc, fop_link_cbk_t cbk, void *local) +nfs_inode_link(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc, + loc_t *newloc, fop_link_cbk_t cbk, void *local) { - struct nfs_fop_local *nfl = NULL; - int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; + int ret = -EFAULT; - if ((!nfsx) || (!xl) || (!oldloc) || (!newloc) || (!nfu)) - return -EFAULT; + if ((!nfsx) || (!xl) || (!oldloc) || (!newloc) || (!nfu)) + return -EFAULT; - nfs_fop_handle_local_init (NULL, nfsx, nfl, cbk, local, ret, err); - nfl_inodes_init (nfl, NULL, NULL, newloc->parent, newloc->name, NULL); - ret = nfs_fop_link (nfsx, xl, nfu, oldloc, newloc, nfs_inode_link_cbk, - nfl); + nfs_fop_handle_local_init(NULL, nfsx, nfl, cbk, local, ret, err); + nfl_inodes_init(nfl, NULL, NULL, newloc->parent, newloc->name, NULL); + ret = nfs_fop_link(nfsx, xl, nfu, oldloc, newloc, nfs_inode_link_cbk, nfl); err: - if (ret < 0) - nfs_fop_local_wipe (xl, nfl); + if (ret < 0) + nfs_fop_local_wipe(xl, nfl); - return ret; + return ret; } - int32_t -nfs_inode_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +nfs_inode_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_unlink_cbk_t progcbk = NULL; + struct nfs_fop_local *nfl = NULL; + fop_unlink_cbk_t progcbk = NULL; - nfl = frame->local; + nfl = frame->local; - if (op_ret == -1) - goto do_not_unlink; + if (op_ret == -1) + goto do_not_unlink; - inode_unlink (nfl->inode, nfl->parent, nfl->path); - inode_forget (nfl->inode, 0); + inode_unlink(nfl->inode, nfl->parent, nfl->path); + inode_forget(nfl->inode, 0); do_not_unlink: - inodes_nfl_to_prog_data (nfl, progcbk, frame); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, preparent, - postparent, xdata); - return 0; + inodes_nfl_to_prog_data(nfl, progcbk, frame); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, preparent, postparent, + xdata); + return 0; } - int -nfs_inode_unlink (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - fop_unlink_cbk_t cbk, void *local) +nfs_inode_unlink(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + fop_unlink_cbk_t cbk, void *local) { - struct nfs_fop_local *nfl = NULL; - int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; + int ret = -EFAULT; - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return -EFAULT; + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) + return -EFAULT; - nfs_fop_handle_local_init (NULL, nfsx, nfl, cbk, local, ret, err); - nfl_inodes_init (nfl, pathloc->inode, pathloc->parent, NULL, - pathloc->name, NULL); - ret = nfs_fop_unlink (nfsx, xl, nfu, pathloc, nfs_inode_unlink_cbk,nfl); + nfs_fop_handle_local_init(NULL, nfsx, nfl, cbk, local, ret, err); + nfl_inodes_init(nfl, pathloc->inode, pathloc->parent, NULL, pathloc->name, + NULL); + ret = nfs_fop_unlink(nfsx, xl, nfu, pathloc, nfs_inode_unlink_cbk, nfl); err: - if (ret < 0) - nfs_fop_local_wipe (xl, nfl); + if (ret < 0) + nfs_fop_local_wipe(xl, nfl); - return ret; + return ret; } - int32_t -nfs_inode_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +nfs_inode_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_rmdir_cbk_t progcbk = NULL; + struct nfs_fop_local *nfl = NULL; + fop_rmdir_cbk_t progcbk = NULL; - nfl = frame->local; + nfl = frame->local; - if (op_ret == -1) - goto do_not_unlink; + if (op_ret == -1) + goto do_not_unlink; - inode_unlink (nfl->inode, nfl->parent, nfl->path); - inode_forget (nfl->inode, 0); + inode_unlink(nfl->inode, nfl->parent, nfl->path); + inode_forget(nfl->inode, 0); do_not_unlink: - inodes_nfl_to_prog_data (nfl, progcbk, frame); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, preparent, - postparent, xdata); + inodes_nfl_to_prog_data(nfl, progcbk, frame); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, preparent, postparent, + xdata); - return 0; + return 0; } - int -nfs_inode_rmdir (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - fop_rmdir_cbk_t cbk, void *local) +nfs_inode_rmdir(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + fop_rmdir_cbk_t cbk, void *local) { - struct nfs_fop_local *nfl = NULL; - int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; + int ret = -EFAULT; - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return ret; + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) + return ret; - nfs_fop_handle_local_init (NULL, nfsx, nfl, cbk, local, ret, err); - nfl_inodes_init (nfl, pathloc->inode, pathloc->parent, NULL, - pathloc->name, NULL); + nfs_fop_handle_local_init(NULL, nfsx, nfl, cbk, local, ret, err); + nfl_inodes_init(nfl, pathloc->inode, pathloc->parent, NULL, pathloc->name, + NULL); - ret = nfs_fop_rmdir (nfsx, xl, nfu, pathloc, nfs_inode_rmdir_cbk, nfl); + ret = nfs_fop_rmdir(nfsx, xl, nfu, pathloc, nfs_inode_rmdir_cbk, nfl); err: - if (ret < 0) - nfs_fop_local_wipe (xl, nfl); - return ret; + if (ret < 0) + nfs_fop_local_wipe(xl, nfl); + return ret; } - int32_t -nfs_inode_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +nfs_inode_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_mknod_cbk_t progcbk = NULL; - inode_t *linked_inode = NULL; + struct nfs_fop_local *nfl = NULL; + fop_mknod_cbk_t progcbk = NULL; + inode_t *linked_inode = NULL; - nfl = frame->local; + nfl = frame->local; - if (op_ret == -1) - goto do_not_link; + if (op_ret == -1) + goto do_not_link; - linked_inode = inode_link (inode, nfl->parent, nfl->path, buf); + linked_inode = inode_link(inode, nfl->parent, nfl->path, buf); do_not_link: - inodes_nfl_to_prog_data (nfl, progcbk, frame); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); + inodes_nfl_to_prog_data(nfl, progcbk, frame); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); - if (linked_inode) { - inode_lookup (linked_inode); - inode_unref (linked_inode); - } + if (linked_inode) { + inode_lookup(linked_inode); + inode_unref(linked_inode); + } - return 0; + return 0; } - int -nfs_inode_mknod (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, - mode_t mode, dev_t dev, fop_mknod_cbk_t cbk, void *local) +nfs_inode_mknod(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, + mode_t mode, dev_t dev, fop_mknod_cbk_t cbk, void *local) { - struct nfs_fop_local *nfl = NULL; - int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; + int ret = -EFAULT; - if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) - return ret; + if ((!nfsx) || (!xl) || (!pathloc) || (!nfu)) + return ret; - nfs_fop_handle_local_init (NULL, nfsx, nfl, cbk, local, ret, err); - nfl_inodes_init (nfl, pathloc->inode, pathloc->parent, NULL, - pathloc->name, NULL); + nfs_fop_handle_local_init(NULL, nfsx, nfl, cbk, local, ret, err); + nfl_inodes_init(nfl, pathloc->inode, pathloc->parent, NULL, pathloc->name, + NULL); - ret = nfs_fop_mknod (nfsx, xl, nfu, pathloc, mode, dev, - nfs_inode_mknod_cbk, nfl); + ret = nfs_fop_mknod(nfsx, xl, nfu, pathloc, mode, dev, nfs_inode_mknod_cbk, + nfl); err: - if (ret < 0) - nfs_fop_local_wipe (xl, nfl); + if (ret < 0) + nfs_fop_local_wipe(xl, nfl); - return ret; + return ret; } - int32_t -nfs_inode_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +nfs_inode_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - struct nfs_fop_local *nfl = NULL; - fop_symlink_cbk_t progcbk = NULL; - inode_t *linked_inode = NULL; + struct nfs_fop_local *nfl = NULL; + fop_symlink_cbk_t progcbk = NULL; + inode_t *linked_inode = NULL; - nfl = frame->local; - if (op_ret == -1) - goto do_not_link; + nfl = frame->local; + if (op_ret == -1) + goto do_not_link; - linked_inode = inode_link (inode, nfl->parent, nfl->path, buf); + linked_inode = inode_link(inode, nfl->parent, nfl->path, buf); do_not_link: - inodes_nfl_to_prog_data (nfl, progcbk, frame); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); + inodes_nfl_to_prog_data(nfl, progcbk, frame); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); - if (linked_inode) { - inode_lookup (linked_inode); - inode_unref (linked_inode); - } + if (linked_inode) { + inode_lookup(linked_inode); + inode_unref(linked_inode); + } - return 0; + return 0; } - int -nfs_inode_symlink (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, char *target, - loc_t *pathloc, fop_symlink_cbk_t cbk, void *local) +nfs_inode_symlink(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, char *target, + loc_t *pathloc, fop_symlink_cbk_t cbk, void *local) { - struct nfs_fop_local *nfl = NULL; - int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; + int ret = -EFAULT; - if ((!nfsx) || (!xl) || (!target) || (!pathloc) || (!nfu)) - return ret; + if ((!nfsx) || (!xl) || (!target) || (!pathloc) || (!nfu)) + return ret; - nfs_fop_handle_local_init (NULL, nfsx, nfl, cbk, local, ret, err); - nfl_inodes_init (nfl, pathloc->inode, pathloc->parent, NULL, - pathloc->name, NULL); - ret = nfs_fop_symlink (nfsx, xl, nfu, target, pathloc, - nfs_inode_symlink_cbk, nfl); + nfs_fop_handle_local_init(NULL, nfsx, nfl, cbk, local, ret, err); + nfl_inodes_init(nfl, pathloc->inode, pathloc->parent, NULL, pathloc->name, + NULL); + ret = nfs_fop_symlink(nfsx, xl, nfu, target, pathloc, nfs_inode_symlink_cbk, + nfl); err: - if (ret < 0) - nfs_fop_local_wipe (xl, nfl); + if (ret < 0) + nfs_fop_local_wipe(xl, nfl); - return ret; + return ret; } int32_t -nfs_inode_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) +nfs_inode_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) { + struct nfs_fop_local *nfl = NULL; + fop_open_cbk_t progcbk = NULL; - struct nfs_fop_local *nfl = NULL; - fop_open_cbk_t progcbk = NULL; + if (op_ret != -1) + fd_bind(fd); - if (op_ret != -1) - fd_bind (fd); + inodes_nfl_to_prog_data(nfl, progcbk, frame); - inodes_nfl_to_prog_data (nfl, progcbk, frame); + if (progcbk) + progcbk(frame, cookie, this, op_ret, op_errno, fd, xdata); - if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, fd, xdata); - - return 0; + return 0; } - int -nfs_inode_opendir (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, - fop_opendir_cbk_t cbk, void *local) +nfs_inode_opendir(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, + fop_opendir_cbk_t cbk, void *local) { - struct nfs_fop_local *nfl = NULL; - fd_t *newfd = NULL; - int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; + fd_t *newfd = NULL; + int ret = -EFAULT; - if ((!nfsx) || (!xl) || (!loc) || (!nfu)) - return ret; + if ((!nfsx) || (!xl) || (!loc) || (!nfu)) + return ret; - newfd = fd_create (loc->inode, 0); - if (!newfd) { - gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to create fd"); - ret = -ENOMEM; - goto err; - } + newfd = fd_create(loc->inode, 0); + if (!newfd) { + gf_msg(GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to create fd"); + ret = -ENOMEM; + goto err; + } - nfs_fop_handle_local_init (NULL, nfsx, nfl, cbk, local, ret, err); - ret = nfs_fop_opendir (nfsx, xl, nfu, loc, newfd, - nfs_inode_opendir_cbk, nfl); + nfs_fop_handle_local_init(NULL, nfsx, nfl, cbk, local, ret, err); + ret = nfs_fop_opendir(nfsx, xl, nfu, loc, newfd, nfs_inode_opendir_cbk, + nfl); err: - if (ret < 0) { - if (newfd) - fd_unref (newfd); - nfs_fop_local_wipe (xl, nfl); - } + if (ret < 0) { + if (newfd) + fd_unref(newfd); + nfs_fop_local_wipe(xl, nfl); + } - return ret; + return ret; } diff --git a/xlators/nfs/server/src/nfs.c b/xlators/nfs/server/src/nfs.c index 7f741695fb..a20fab3ef7 100644 --- a/xlators/nfs/server/src/nfs.c +++ b/xlators/nfs/server/src/nfs.c @@ -12,7 +12,6 @@ * Every other protocol version gets initialized from here. */ - #include "defaults.h" #include "rpcsvc.h" #include "dict.h" @@ -33,1449 +32,1393 @@ #include "rpcsvc.h" #include "nfs-messages.h" -#define OPT_SERVER_AUX_GIDS "nfs.server-aux-gids" -#define OPT_SERVER_GID_CACHE_TIMEOUT "nfs.server.aux-gid-timeout" -#define OPT_SERVER_RPC_STATD "nfs.rpc-statd" -#define OPT_SERVER_RPC_STATD_PIDFILE "nfs.rpc-statd-pidfile" +#define OPT_SERVER_AUX_GIDS "nfs.server-aux-gids" +#define OPT_SERVER_GID_CACHE_TIMEOUT "nfs.server.aux-gid-timeout" +#define OPT_SERVER_RPC_STATD "nfs.rpc-statd" +#define OPT_SERVER_RPC_STATD_PIDFILE "nfs.rpc-statd-pidfile" #define OPT_SERVER_RPC_STATD_NOTIFY_PIDFILE "nfs.rpc-statd-notify-pidfile" -#define NFS_DATADIR GLUSTERD_DEFAULT_WORKDIR "/nfs" +#define NFS_DATADIR GLUSTERD_DEFAULT_WORKDIR "/nfs" /* Forward declaration */ -static int nfs_add_initer (struct list_head *list, nfs_version_initer_t init, - gf_boolean_t required); +static int +nfs_add_initer(struct list_head *list, nfs_version_initer_t init, + gf_boolean_t required); static int -nfs_init_version (xlator_t *this, nfs_version_initer_t init, - gf_boolean_t required) +nfs_init_version(xlator_t *this, nfs_version_initer_t init, + gf_boolean_t required) { - int ret = -1; - struct nfs_initer_list *version = NULL; - struct nfs_initer_list *tmp = NULL; - rpcsvc_program_t *prog = NULL; - struct list_head *versions = NULL; - struct nfs_state *nfs = NULL; - gf_boolean_t found = _gf_false; - - if ((!this) || (!this->private) || (!init)) - return (-1); - - nfs = (struct nfs_state *)this->private; - - ret = nfs_add_initer (&nfs->versions, init, required); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PROT_INIT_ADD_FAIL, - "Failed to add protocol initializer"); - goto err; - } - - versions = &nfs->versions; - list_for_each_entry_safe (version, tmp, versions, list) { - prog = version->program; - if (version->init == init) { - prog = init(this); - if (!prog) { - ret = -1; - goto err; - } - version->program = prog; - found = _gf_true; - break; - } - } - - /* program not added */ - if (!found) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PGM_NOT_FOUND, - "Program: %s NOT found", prog->progname); - goto err; - } - - /* Check if nfs.port is configured */ - if (nfs->override_portnum) - prog->progport = nfs->override_portnum; - - gf_msg_debug (GF_NFS, 0, "Starting program: %s", prog->progname); - - ret = rpcsvc_program_register (nfs->rpcsvc, prog, _gf_false); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PGM_INIT_FAIL, - "Program: %s init failed", prog->progname); - goto err; - } - - /* Registration with portmapper is disabled, Nothing to do */ - if (!nfs->register_portmap) - goto err; + int ret = -1; + struct nfs_initer_list *version = NULL; + struct nfs_initer_list *tmp = NULL; + rpcsvc_program_t *prog = NULL; + struct list_head *versions = NULL; + struct nfs_state *nfs = NULL; + gf_boolean_t found = _gf_false; + + if ((!this) || (!this->private) || (!init)) + return (-1); - ret = rpcsvc_program_register_portmap (prog, prog->progport); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PGM_REG_FAIL, - "Program %s registration failed", prog->progname); + nfs = (struct nfs_state *)this->private; + + ret = nfs_add_initer(&nfs->versions, init, required); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PROT_INIT_ADD_FAIL, + "Failed to add protocol initializer"); + goto err; + } + + versions = &nfs->versions; + list_for_each_entry_safe(version, tmp, versions, list) + { + prog = version->program; + if (version->init == init) { + prog = init(this); + if (!prog) { + ret = -1; goto err; - } - ret = 0; /* All well */ + } + version->program = prog; + found = _gf_true; + break; + } + } + + /* program not added */ + if (!found) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PGM_NOT_FOUND, + "Program: %s NOT found", prog->progname); + goto err; + } + + /* Check if nfs.port is configured */ + if (nfs->override_portnum) + prog->progport = nfs->override_portnum; + + gf_msg_debug(GF_NFS, 0, "Starting program: %s", prog->progname); + + ret = rpcsvc_program_register(nfs->rpcsvc, prog, _gf_false); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PGM_INIT_FAIL, + "Program: %s init failed", prog->progname); + goto err; + } + + /* Registration with portmapper is disabled, Nothing to do */ + if (!nfs->register_portmap) + goto err; + + ret = rpcsvc_program_register_portmap(prog, prog->progport); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PGM_REG_FAIL, + "Program %s registration failed", prog->progname); + goto err; + } + ret = 0; /* All well */ err: - return ret; + return ret; } static int -nfs_deinit_version (struct nfs_state *nfs, nfs_version_initer_t init) +nfs_deinit_version(struct nfs_state *nfs, nfs_version_initer_t init) { - int ret = -1; - struct nfs_initer_list *version = NULL; - struct nfs_initer_list *tmp = NULL; - rpcsvc_program_t *prog = NULL; - struct list_head *versions = NULL; + int ret = -1; + struct nfs_initer_list *version = NULL; + struct nfs_initer_list *tmp = NULL; + rpcsvc_program_t *prog = NULL; + struct list_head *versions = NULL; - if ((!nfs) || (!init)) - return (-1); + if ((!nfs) || (!init)) + return (-1); - versions = &nfs->versions; - list_for_each_entry_safe (version, tmp, versions, list) { - prog = version->program; - if (version->init == init) { - prog = version->program; - ret = rpcsvc_program_unregister (nfs->rpcsvc, prog); - if (ret != 0) - return (-1); - list_del (&version->list); - GF_FREE (version); - return (0); - } + versions = &nfs->versions; + list_for_each_entry_safe(version, tmp, versions, list) + { + prog = version->program; + if (version->init == init) { + prog = version->program; + ret = rpcsvc_program_unregister(nfs->rpcsvc, prog); + if (ret != 0) + return (-1); + list_del(&version->list); + GF_FREE(version); + return (0); } + } - return (-1); + return (-1); } static int -nfs_reconfigure_acl3 (xlator_t *this) +nfs_reconfigure_acl3(xlator_t *this) { - struct nfs_state *nfs = NULL; + struct nfs_state *nfs = NULL; - if ((!this) || (!this->private)) - return (-1); + if ((!this) || (!this->private)) + return (-1); - nfs = (struct nfs_state *)this->private; + nfs = (struct nfs_state *)this->private; - /* ACL is enabled */ - if (nfs->enable_acl) - return nfs_init_version (this, acl3svc_init, _gf_false); + /* ACL is enabled */ + if (nfs->enable_acl) + return nfs_init_version(this, acl3svc_init, _gf_false); - /* ACL is disabled */ - return nfs_deinit_version (nfs, acl3svc_init); + /* ACL is disabled */ + return nfs_deinit_version(nfs, acl3svc_init); } static int -nfs_reconfigure_nlm4 (xlator_t *this) +nfs_reconfigure_nlm4(xlator_t *this) { - struct nfs_state *nfs = NULL; + struct nfs_state *nfs = NULL; - if ((!this) || (!this->private)) - return (-1); + if ((!this) || (!this->private)) + return (-1); - nfs = (struct nfs_state *)this->private; + nfs = (struct nfs_state *)this->private; - /* NLM is enabled */ - if (nfs->enable_nlm) - return nfs_init_version (this, nlm4svc_init, _gf_false); + /* NLM is enabled */ + if (nfs->enable_nlm) + return nfs_init_version(this, nlm4svc_init, _gf_false); - /* NLM is disabled */ - return nfs_deinit_version (nfs, nlm4svc_init); + /* NLM is disabled */ + return nfs_deinit_version(nfs, nlm4svc_init); } static int -nfs_program_register_portmap_all (struct nfs_state *nfs) +nfs_program_register_portmap_all(struct nfs_state *nfs) { - struct list_head *versions = NULL; - struct nfs_initer_list *version = NULL; - struct nfs_initer_list *tmp = NULL; - rpcsvc_program_t *prog = NULL; + struct list_head *versions = NULL; + struct nfs_initer_list *version = NULL; + struct nfs_initer_list *tmp = NULL; + rpcsvc_program_t *prog = NULL; - if (nfs == NULL) - return (-1); + if (nfs == NULL) + return (-1); - versions = &nfs->versions; - list_for_each_entry_safe (version, tmp, versions, list) { - prog = version->program; - if (prog == NULL) - continue; - if (nfs->override_portnum) - prog->progport = nfs->override_portnum; - (void) rpcsvc_program_register_portmap (prog, prog->progport); + versions = &nfs->versions; + list_for_each_entry_safe(version, tmp, versions, list) + { + prog = version->program; + if (prog == NULL) + continue; + if (nfs->override_portnum) + prog->progport = nfs->override_portnum; + (void)rpcsvc_program_register_portmap(prog, prog->progport); #ifdef IPV6_DEFAULT - (void) rpcsvc_program_register_rpcbind6 (prog, prog->progport); + (void)rpcsvc_program_register_rpcbind6(prog, prog->progport); #endif + } - } - - return (0); + return (0); } static int -nfs_program_unregister_portmap_all (struct nfs_state *nfs) +nfs_program_unregister_portmap_all(struct nfs_state *nfs) { - struct list_head *versions = NULL; - struct nfs_initer_list *version = NULL; - struct nfs_initer_list *tmp = NULL; - rpcsvc_program_t *prog = NULL; + struct list_head *versions = NULL; + struct nfs_initer_list *version = NULL; + struct nfs_initer_list *tmp = NULL; + rpcsvc_program_t *prog = NULL; - if (nfs == NULL) - return (-1); + if (nfs == NULL) + return (-1); - versions = &nfs->versions; - list_for_each_entry_safe (version, tmp, versions, list) { - prog = version->program; - if (prog == NULL) - continue; - (void) rpcsvc_program_unregister_portmap (prog); + versions = &nfs->versions; + list_for_each_entry_safe(version, tmp, versions, list) + { + prog = version->program; + if (prog == NULL) + continue; + (void)rpcsvc_program_unregister_portmap(prog); #ifdef IPV6_DEFAULT - (void) rpcsvc_program_unregister_rpcbind6 (prog); + (void)rpcsvc_program_unregister_rpcbind6(prog); #endif - } + } - return (0); + return (0); } /* Every NFS version must call this function with the init function * for its particular version. */ static int -nfs_add_initer (struct list_head *list, nfs_version_initer_t init, - gf_boolean_t required) +nfs_add_initer(struct list_head *list, nfs_version_initer_t init, + gf_boolean_t required) { - struct nfs_initer_list *new = NULL; - if ((!list) || (!init)) - return -1; - - new = GF_CALLOC (1, sizeof (*new), gf_nfs_mt_nfs_initer_list); - if (!new) { - gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Memory allocation failed"); - return -1; - } - - new->init = init; - new->required = required; - list_add_tail (&new->list, list); - return 0; + struct nfs_initer_list *new = NULL; + if ((!list) || (!init)) + return -1; + + new = GF_CALLOC(1, sizeof(*new), gf_nfs_mt_nfs_initer_list); + if (!new) { + gf_msg(GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); + return -1; + } + + new->init = init; + new->required = required; + list_add_tail(&new->list, list); + return 0; } - int -nfs_deinit_versions (struct list_head *versions, xlator_t *this) +nfs_deinit_versions(struct list_head *versions, xlator_t *this) { - struct nfs_initer_list *version = NULL; - struct nfs_initer_list *tmp = NULL; - struct nfs_state *nfs = NULL; - - if ((!versions) || (!this)) - return -1; - - nfs = (struct nfs_state *)this->private; - list_for_each_entry_safe (version, tmp, versions, list) { - /* TODO: Add version specific destructor. - * if (!version->deinit) - goto err; - - version->deinit (this); - */ - if (version->program) - rpcsvc_program_unregister (nfs->rpcsvc, - (version->program)); - - list_del (&version->list); - GF_FREE (version); - } + struct nfs_initer_list *version = NULL; + struct nfs_initer_list *tmp = NULL; + struct nfs_state *nfs = NULL; + + if ((!versions) || (!this)) + return -1; + + nfs = (struct nfs_state *)this->private; + list_for_each_entry_safe(version, tmp, versions, list) + { + /* TODO: Add version specific destructor. + * if (!version->deinit) + goto err; - return 0; + version->deinit (this); + */ + if (version->program) + rpcsvc_program_unregister(nfs->rpcsvc, (version->program)); + + list_del(&version->list); + GF_FREE(version); + } + + return 0; } int -nfs_init_versions (struct nfs_state *nfs, xlator_t *this) +nfs_init_versions(struct nfs_state *nfs, xlator_t *this) { - struct nfs_initer_list *version = NULL; - struct nfs_initer_list *tmp = NULL; - rpcsvc_program_t *prog = NULL; - int ret = -1; - struct list_head *versions = NULL; - - if ((!nfs) || (!this)) - return -1; - - gf_msg_debug (GF_NFS, 0, "Initing protocol versions"); - versions = &nfs->versions; - list_for_each_entry_safe (version, tmp, versions, list) { - if (!version->init) { - ret = -1; - goto err; - } - - prog = version->init (this); - if (!prog) { - ret = -1; - goto err; - } - - version->program = prog; - if (nfs->override_portnum) - prog->progport = nfs->override_portnum; - gf_msg_debug (GF_NFS, 0, "Starting program: %s", - prog->progname); - - ret = rpcsvc_program_register (nfs->rpcsvc, prog, _gf_false); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, - NFS_MSG_PGM_INIT_FAIL, - "Program: %s init failed", prog->progname); - goto err; - } - if (nfs->register_portmap) { - ret = rpcsvc_program_register_portmap (prog, - prog->progport); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, - NFS_MSG_PGM_REG_FAIL, - "%s program %s registration failed", - version->required ? - "Required" : "Optional", - prog->progname); - - /* fatal error if the program is required */ - if (version->required) - goto err; - } + struct nfs_initer_list *version = NULL; + struct nfs_initer_list *tmp = NULL; + rpcsvc_program_t *prog = NULL; + int ret = -1; + struct list_head *versions = NULL; + + if ((!nfs) || (!this)) + return -1; + + gf_msg_debug(GF_NFS, 0, "Initing protocol versions"); + versions = &nfs->versions; + list_for_each_entry_safe(version, tmp, versions, list) + { + if (!version->init) { + ret = -1; + goto err; + } + + prog = version->init(this); + if (!prog) { + ret = -1; + goto err; + } + + version->program = prog; + if (nfs->override_portnum) + prog->progport = nfs->override_portnum; + gf_msg_debug(GF_NFS, 0, "Starting program: %s", prog->progname); + + ret = rpcsvc_program_register(nfs->rpcsvc, prog, _gf_false); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PGM_INIT_FAIL, + "Program: %s init failed", prog->progname); + goto err; + } + if (nfs->register_portmap) { + ret = rpcsvc_program_register_portmap(prog, prog->progport); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PGM_REG_FAIL, + "%s program %s registration failed", + version->required ? "Required" : "Optional", + prog->progname); + + /* fatal error if the program is required */ + if (version->required) + goto err; + } #ifdef IPV6_DEFAULT - ret = rpcsvc_program_register_rpcbind6 (prog, - prog->progport); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, - NFS_MSG_PGM_REG_FAIL, - "Program (ipv6) %s registration failed", - prog->progname); - goto err; - } + ret = rpcsvc_program_register_rpcbind6(prog, prog->progport); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PGM_REG_FAIL, + "Program (ipv6) %s registration failed", prog->progname); + goto err; + } #endif - } - } + } - ret = 0; + ret = 0; err: - return ret; + return ret; } - int -nfs_add_all_initiators (struct nfs_state *nfs) +nfs_add_all_initiators(struct nfs_state *nfs) { - int ret = 0; - - /* Add the initializers for all versions. */ - ret = nfs_add_initer (&nfs->versions, mnt3svc_init, _gf_true); + int ret = 0; + + /* Add the initializers for all versions. */ + ret = nfs_add_initer(&nfs->versions, mnt3svc_init, _gf_true); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PROT_INIT_ADD_FAIL, + "Failed to add MOUNT3 protocol initializer"); + goto ret; + } + + ret = nfs_add_initer(&nfs->versions, mnt1svc_init, _gf_true); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PROT_INIT_ADD_FAIL, + "Failed to add MOUNT1 protocol initializer"); + goto ret; + } + + ret = nfs_add_initer(&nfs->versions, nfs3svc_init, _gf_true); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PROT_INIT_ADD_FAIL, + "Failed to add NFS3 protocol initializer"); + goto ret; + } + + if (nfs->enable_nlm == _gf_true) { + ret = nfs_add_initer(&nfs->versions, nlm4svc_init, _gf_false); if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PROT_INIT_ADD_FAIL, - "Failed to add MOUNT3 protocol initializer"); - goto ret; + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PROT_INIT_ADD_FAIL, + "Failed to add protocol initializer"); + goto ret; } + } - ret = nfs_add_initer (&nfs->versions, mnt1svc_init, _gf_true); + if (nfs->enable_acl == _gf_true) { + ret = nfs_add_initer(&nfs->versions, acl3svc_init, _gf_false); if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PROT_INIT_ADD_FAIL, - "Failed to add MOUNT1 protocol initializer"); - goto ret; - } - - ret = nfs_add_initer (&nfs->versions, nfs3svc_init, _gf_true); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PROT_INIT_ADD_FAIL, - "Failed to add NFS3 protocol initializer"); - goto ret; - } - - if (nfs->enable_nlm == _gf_true) { - ret = nfs_add_initer (&nfs->versions, nlm4svc_init, _gf_false); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, - NFS_MSG_PROT_INIT_ADD_FAIL, - "Failed to add protocol initializer"); - goto ret; - } - } - - if (nfs->enable_acl == _gf_true) { - ret = nfs_add_initer (&nfs->versions, acl3svc_init, _gf_false); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, - NFS_MSG_PROT_INIT_ADD_FAIL, - "Failed to add ACL protocol initializer"); - goto ret; - } + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PROT_INIT_ADD_FAIL, + "Failed to add ACL protocol initializer"); + goto ret; } + } - ret = 0; + ret = 0; ret: - return ret; + return ret; } - int -nfs_subvolume_started (struct nfs_state *nfs, xlator_t *xl) +nfs_subvolume_started(struct nfs_state *nfs, xlator_t *xl) { - int x = 0; - int started = 0; - - if ((!nfs) || (!xl)) - return 1; - - LOCK (&nfs->svinitlock); - { - for (;x < nfs->allsubvols; ++x) { - if (nfs->initedxl[x] == xl) { - started = 1; - goto unlock; - } - } + int x = 0; + int started = 0; + + if ((!nfs) || (!xl)) + return 1; + + LOCK(&nfs->svinitlock); + { + for (; x < nfs->allsubvols; ++x) { + if (nfs->initedxl[x] == xl) { + started = 1; + goto unlock; + } } + } unlock: - UNLOCK (&nfs->svinitlock); + UNLOCK(&nfs->svinitlock); - return started; + return started; } - int -nfs_subvolume_set_started (struct nfs_state *nfs, xlator_t *xl) +nfs_subvolume_set_started(struct nfs_state *nfs, xlator_t *xl) { - int x = 0; - - if ((!nfs) || (!xl)) - return 1; - - LOCK (&nfs->svinitlock); - { - for (;x < nfs->allsubvols; ++x) { - if (nfs->initedxl[x] == xl) { - gf_msg_debug (GF_NFS, 0, - "Volume already started %s", - xl->name); - break; - } - - if (nfs->initedxl[x] == NULL) { - nfs->initedxl[x] = xl; - ++nfs->upsubvols; - gf_msg_debug (GF_NFS, 0, "Starting up: %s " - ", vols started till now: %d", xl->name, - nfs->upsubvols); - goto unlock; - } - } - } + int x = 0; + + if ((!nfs) || (!xl)) + return 1; + + LOCK(&nfs->svinitlock); + { + for (; x < nfs->allsubvols; ++x) { + if (nfs->initedxl[x] == xl) { + gf_msg_debug(GF_NFS, 0, "Volume already started %s", xl->name); + break; + } + + if (nfs->initedxl[x] == NULL) { + nfs->initedxl[x] = xl; + ++nfs->upsubvols; + gf_msg_debug(GF_NFS, 0, + "Starting up: %s " + ", vols started till now: %d", + xl->name, nfs->upsubvols); + goto unlock; + } + } + } unlock: - UNLOCK (&nfs->svinitlock); + UNLOCK(&nfs->svinitlock); - return 0; + return 0; } - int32_t -nfs_start_subvol_lookup_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, int32_t op_errno, - inode_t *inode, struct iatt *buf, dict_t *xattr, - struct iatt *postparent) +nfs_start_subvol_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, dict_t *xattr, + struct iatt *postparent) { - if (op_ret == -1) { - gf_msg (GF_NFS, GF_LOG_CRITICAL, op_errno, - NFS_MSG_LOOKUP_ROOT_FAIL, - "Failed to lookup root: %s", - strerror (op_errno)); - goto err; - } - - nfs_subvolume_set_started (this->private, ((xlator_t *)cookie)); - gf_msg_trace (GF_NFS, 0, "Started %s", ((xlator_t *)cookie)->name); + if (op_ret == -1) { + gf_msg(GF_NFS, GF_LOG_CRITICAL, op_errno, NFS_MSG_LOOKUP_ROOT_FAIL, + "Failed to lookup root: %s", strerror(op_errno)); + goto err; + } + + nfs_subvolume_set_started(this->private, ((xlator_t *)cookie)); + gf_msg_trace(GF_NFS, 0, "Started %s", ((xlator_t *)cookie)->name); err: - return 0; + return 0; } - int -nfs_startup_subvolume (xlator_t *nfsx, xlator_t *xl) +nfs_startup_subvolume(xlator_t *nfsx, xlator_t *xl) { - int ret = -1; - loc_t rootloc = {0, }; - nfs_user_t nfu = {0, }; - - if ((!nfsx) || (!xl)) - return -1; - - if (nfs_subvolume_started (nfsx->private, xl)) { - gf_msg_trace (GF_NFS, 0, "Subvolume already started: %s", - xl->name); - ret = 0; - goto err; - } - - ret = nfs_root_loc_fill (xl->itable, &rootloc); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_CRITICAL, 0, - NFS_MSG_ROOT_LOC_INIT_FAIL, - "Failed to init root loc"); - goto err; - } - - nfs_user_root_create (&nfu); - ret = nfs_fop_lookup (nfsx, xl, &nfu, &rootloc, - nfs_start_subvol_lookup_cbk, - (void *)nfsx->private); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_CRITICAL, -ret, - NFS_MSG_LOOKUP_ROOT_FAIL, - "Failed to lookup root: %s", strerror (-ret)); - goto err; - } - - nfs_loc_wipe (&rootloc); + int ret = -1; + loc_t rootloc = { + 0, + }; + nfs_user_t nfu = { + 0, + }; + + if ((!nfsx) || (!xl)) + return -1; + + if (nfs_subvolume_started(nfsx->private, xl)) { + gf_msg_trace(GF_NFS, 0, "Subvolume already started: %s", xl->name); + ret = 0; + goto err; + } + + ret = nfs_root_loc_fill(xl->itable, &rootloc); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_CRITICAL, 0, NFS_MSG_ROOT_LOC_INIT_FAIL, + "Failed to init root loc"); + goto err; + } + + nfs_user_root_create(&nfu); + ret = nfs_fop_lookup(nfsx, xl, &nfu, &rootloc, nfs_start_subvol_lookup_cbk, + (void *)nfsx->private); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_CRITICAL, -ret, NFS_MSG_LOOKUP_ROOT_FAIL, + "Failed to lookup root: %s", strerror(-ret)); + goto err; + } + + nfs_loc_wipe(&rootloc); err: - return ret; + return ret; } int -nfs_startup_subvolumes (xlator_t *nfsx) +nfs_startup_subvolumes(xlator_t *nfsx) { - int ret = -1; - xlator_list_t *cl = NULL; - struct nfs_state *nfs = NULL; - - if (!nfsx) - return -1; - - nfs = nfsx->private; - cl = nfs->subvols; - while (cl) { - gf_msg_debug (GF_NFS, 0, "Starting subvolume: %s", - cl->xlator->name); - ret = nfs_startup_subvolume (nfsx, cl->xlator); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_CRITICAL, 0, - NFS_MSG_STARTUP_FAIL, - "Failed to start-up xlator: %s", - cl->xlator->name); - goto err; - } - cl = cl->next; + int ret = -1; + xlator_list_t *cl = NULL; + struct nfs_state *nfs = NULL; + + if (!nfsx) + return -1; + + nfs = nfsx->private; + cl = nfs->subvols; + while (cl) { + gf_msg_debug(GF_NFS, 0, "Starting subvolume: %s", cl->xlator->name); + ret = nfs_startup_subvolume(nfsx, cl->xlator); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_CRITICAL, 0, NFS_MSG_STARTUP_FAIL, + "Failed to start-up xlator: %s", cl->xlator->name); + goto err; } + cl = cl->next; + } - ret = 0; + ret = 0; err: - return ret; + return ret; } - int -nfs_init_subvolume (struct nfs_state *nfs, xlator_t *xl) +nfs_init_subvolume(struct nfs_state *nfs, xlator_t *xl) { - unsigned int lrusize = 0; - int ret = -1; - - if ((!nfs) || (!xl)) - return -1; - - lrusize = nfs->memfactor * GF_NFS_INODE_LRU_MULT; - xl->itable = inode_table_new (lrusize, xl); - if (!xl->itable) { - gf_msg (GF_NFS, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to allocate inode table"); - goto err; - } - ret = 0; + unsigned int lrusize = 0; + int ret = -1; + + if ((!nfs) || (!xl)) + return -1; + + lrusize = nfs->memfactor * GF_NFS_INODE_LRU_MULT; + xl->itable = inode_table_new(lrusize, xl); + if (!xl->itable) { + gf_msg(GF_NFS, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to allocate inode table"); + goto err; + } + ret = 0; err: - return ret; + return ret; } int -nfs_init_subvolumes (struct nfs_state *nfs, xlator_list_t *cl) +nfs_init_subvolumes(struct nfs_state *nfs, xlator_list_t *cl) { - int ret = -1; - unsigned int lrusize = 0; - int svcount = 0; - - if ((!nfs) || (!cl)) - return -1; - - lrusize = nfs->memfactor * GF_NFS_INODE_LRU_MULT; - nfs->subvols = cl; - gf_msg_trace (GF_NFS, 0, "inode table lru: %d", lrusize); - - while (cl) { - gf_msg_debug (GF_NFS, 0, "Initing subvolume: %s", - cl->xlator->name); - ret = nfs_init_subvolume (nfs, cl->xlator); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_CRITICAL, 0, - NFS_MSG_XLATOR_INIT_FAIL, "Failed to init " - "xlator: %s", cl->xlator->name); - goto err; - } - ++svcount; - cl = cl->next; - } + int ret = -1; + unsigned int lrusize = 0; + int svcount = 0; - LOCK_INIT (&nfs->svinitlock); - nfs->initedxl = GF_CALLOC (svcount, sizeof (xlator_t *), - gf_nfs_mt_xlator_t ); - if (!nfs->initedxl) { - gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to allocated inited xls"); - ret = -1; - goto err; - } + if ((!nfs) || (!cl)) + return -1; - gf_msg_trace (GF_NFS, 0, "Inited volumes: %d", svcount); - nfs->allsubvols = svcount; - ret = 0; + lrusize = nfs->memfactor * GF_NFS_INODE_LRU_MULT; + nfs->subvols = cl; + gf_msg_trace(GF_NFS, 0, "inode table lru: %d", lrusize); + + while (cl) { + gf_msg_debug(GF_NFS, 0, "Initing subvolume: %s", cl->xlator->name); + ret = nfs_init_subvolume(nfs, cl->xlator); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_CRITICAL, 0, NFS_MSG_XLATOR_INIT_FAIL, + "Failed to init " + "xlator: %s", + cl->xlator->name); + goto err; + } + ++svcount; + cl = cl->next; + } + + LOCK_INIT(&nfs->svinitlock); + nfs->initedxl = GF_CALLOC(svcount, sizeof(xlator_t *), gf_nfs_mt_xlator_t); + if (!nfs->initedxl) { + gf_msg(GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to allocated inited xls"); + ret = -1; + goto err; + } + + gf_msg_trace(GF_NFS, 0, "Inited volumes: %d", svcount); + nfs->allsubvols = svcount; + ret = 0; err: - return ret; + return ret; } - int -nfs_user_root_create (nfs_user_t *newnfu) +nfs_user_root_create(nfs_user_t *newnfu) { - if (!newnfu) - return -1; + if (!newnfu) + return -1; - newnfu->uid = 0; - newnfu->gids[0] = 0; - newnfu->ngrps = 1; + newnfu->uid = 0; + newnfu->gids[0] = 0; + newnfu->ngrps = 1; - return 0; + return 0; } - int -nfs_user_create (nfs_user_t *newnfu, uid_t uid, gid_t gid, - rpc_transport_t *trans, gid_t *auxgids, int auxcount) +nfs_user_create(nfs_user_t *newnfu, uid_t uid, gid_t gid, + rpc_transport_t *trans, gid_t *auxgids, int auxcount) { - int x = 1; - int y = 0; - - /* We test for GF_REQUEST_MAXGROUPS instead of NFS_FOP_NGROUPS because - * the latter accounts for the @gid being in @auxgids, which is not the - * case here. - */ - if ((!newnfu) || (auxcount > GF_REQUEST_MAXGROUPS)) - return -1; - - newnfu->uid = uid; - newnfu->gids[0] = gid; - newnfu->ngrps = 1; - if (trans) { - memcpy (&newnfu->identifier, trans->peerinfo.identifier, - UNIX_PATH_MAX); - } - - gf_msg_trace (GF_NFS, 0, "uid: %d, gid %d, gids: %d", uid, gid, - auxcount); - - if (!auxgids) - return 0; + int x = 1; + int y = 0; + + /* We test for GF_REQUEST_MAXGROUPS instead of NFS_FOP_NGROUPS because + * the latter accounts for the @gid being in @auxgids, which is not the + * case here. + */ + if ((!newnfu) || (auxcount > GF_REQUEST_MAXGROUPS)) + return -1; + + newnfu->uid = uid; + newnfu->gids[0] = gid; + newnfu->ngrps = 1; + if (trans) { + memcpy(&newnfu->identifier, trans->peerinfo.identifier, UNIX_PATH_MAX); + } + + gf_msg_trace(GF_NFS, 0, "uid: %d, gid %d, gids: %d", uid, gid, auxcount); + + if (!auxgids) + return 0; - for (; y < auxcount; ++x,++y) { - newnfu->gids[x] = auxgids[y]; - ++newnfu->ngrps; - gf_msg_trace (GF_NFS, 0, "gid: %d", auxgids[y]); - } + for (; y < auxcount; ++x, ++y) { + newnfu->gids[x] = auxgids[y]; + ++newnfu->ngrps; + gf_msg_trace(GF_NFS, 0, "gid: %d", auxgids[y]); + } - return 0; + return 0; } - void -nfs_request_user_init (nfs_user_t *nfu, rpcsvc_request_t *req) +nfs_request_user_init(nfs_user_t *nfu, rpcsvc_request_t *req) { - gid_t *gidarr = NULL; - int gids = 0; + gid_t *gidarr = NULL; + int gids = 0; - if ((!req) || (!nfu)) - return; + if ((!req) || (!nfu)) + return; - gidarr = rpcsvc_auth_unix_auxgids (req, &gids); - nfs_user_create (nfu, rpcsvc_request_uid (req), - rpcsvc_request_gid (req), - rpcsvc_request_transport (req), - gidarr, gids); + gidarr = rpcsvc_auth_unix_auxgids(req, &gids); + nfs_user_create(nfu, rpcsvc_request_uid(req), rpcsvc_request_gid(req), + rpcsvc_request_transport(req), gidarr, gids); - return; + return; } void -nfs_request_primary_user_init (nfs_user_t *nfu, rpcsvc_request_t *req, - uid_t uid, gid_t gid) +nfs_request_primary_user_init(nfs_user_t *nfu, rpcsvc_request_t *req, uid_t uid, + gid_t gid) { - gid_t *gidarr = NULL; - int gids = 0; + gid_t *gidarr = NULL; + int gids = 0; - if ((!req) || (!nfu)) - return; + if ((!req) || (!nfu)) + return; - gidarr = rpcsvc_auth_unix_auxgids (req, &gids); - nfs_user_create (nfu, uid, gid, rpcsvc_request_transport (req), - gidarr, gids); + gidarr = rpcsvc_auth_unix_auxgids(req, &gids); + nfs_user_create(nfu, uid, gid, rpcsvc_request_transport(req), gidarr, gids); - return; + return; } - int32_t -mem_acct_init (xlator_t *this) +mem_acct_init(xlator_t *this) { - int ret = -1; - - if (!this) - return ret; + int ret = -1; - ret = xlator_mem_acct_init (this, gf_nfs_mt_end + 1); + if (!this) + return ret; - if (ret != 0) { - gf_msg (this->name, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Memory accounting init failed"); - return ret; - } + ret = xlator_mem_acct_init(this, gf_nfs_mt_end + 1); + if (ret != 0) { + gf_msg(this->name, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory accounting init failed"); return ret; -} + } + return ret; +} struct nfs_state * -nfs_init_state (xlator_t *this) +nfs_init_state(xlator_t *this) { - struct nfs_state *nfs = NULL; - int i = 0, ret = -1; - unsigned int fopspoolsize = 0; - char *optstr = NULL; - gf_boolean_t boolt = _gf_false; - struct stat stbuf = {0,}; - - if (!this) - return NULL; - - if (!this->children) { - gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_NFS_MAN_DISABLE, - "NFS is manually disabled: Exiting"); - /* Nothing for nfs process to do, exit cleanly */ - kill (getpid (), SIGTERM); - } - - nfs = GF_CALLOC (1, sizeof (*nfs), gf_nfs_mt_nfs_state); - if (!nfs) { - gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "memory allocation failed"); - return NULL; + struct nfs_state *nfs = NULL; + int i = 0, ret = -1; + unsigned int fopspoolsize = 0; + char *optstr = NULL; + gf_boolean_t boolt = _gf_false; + struct stat stbuf = { + 0, + }; + + if (!this) + return NULL; + + if (!this->children) { + gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_NFS_MAN_DISABLE, + "NFS is manually disabled: Exiting"); + /* Nothing for nfs process to do, exit cleanly */ + kill(getpid(), SIGTERM); + } + + nfs = GF_CALLOC(1, sizeof(*nfs), gf_nfs_mt_nfs_state); + if (!nfs) { + gf_msg(GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "memory allocation failed"); + return NULL; + } + + nfs->memfactor = GF_NFS_DEFAULT_MEMFACTOR; + if (dict_get(this->options, "nfs.mem-factor")) { + ret = dict_get_str(this->options, "nfs.mem-factor", &optstr); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_DICT_GET_FAILED, + "Failed to parse dict"); + goto free_rpcsvc; } - nfs->memfactor = GF_NFS_DEFAULT_MEMFACTOR; - if (dict_get (this->options, "nfs.mem-factor")) { - ret = dict_get_str (this->options, "nfs.mem-factor", - &optstr); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, -ret, - NFS_MSG_DICT_GET_FAILED, - "Failed to parse dict"); - goto free_rpcsvc; - } - - ret = gf_string2uint (optstr, &nfs->memfactor); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL, - "Failed to parse uint string"); - goto free_rpcsvc; - } + ret = gf_string2uint(optstr, &nfs->memfactor); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL, + "Failed to parse uint string"); + goto free_rpcsvc; + } + } + + fopspoolsize = nfs->memfactor * GF_NFS_CONCURRENT_OPS_MULT; + /* FIXME: Really saddens me to see this as xlator wide. */ + nfs->foppool = mem_pool_new(struct nfs_fop_local, fopspoolsize); + if (!nfs->foppool) { + gf_msg(GF_NFS, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to allocate fops local pool"); + goto free_rpcsvc; + } + + nfs->dynamicvolumes = GF_NFS_DVM_OFF; + if (dict_get(this->options, "nfs.dynamic-volumes")) { + ret = dict_get_str(this->options, "nfs.dynamic-volumes", &optstr); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_DICT_GET_FAILED, + "Failed to parse dict"); + goto free_foppool; } - fopspoolsize = nfs->memfactor * GF_NFS_CONCURRENT_OPS_MULT; - /* FIXME: Really saddens me to see this as xlator wide. */ - nfs->foppool = mem_pool_new (struct nfs_fop_local, fopspoolsize); - if (!nfs->foppool) { - gf_msg (GF_NFS, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to allocate fops local pool"); - goto free_rpcsvc; + ret = gf_string2boolean(optstr, &boolt); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL, + "Failed to parse bool string"); + goto free_foppool; + } + + if (boolt == _gf_true) + nfs->dynamicvolumes = GF_NFS_DVM_ON; + } + + nfs->enable_nlm = _gf_true; + ret = dict_get_str_boolean(this->options, "nfs.nlm", _gf_true); + if (ret == _gf_false) { + gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_NLM_MAN_DISABLE, + "NLM is manually disabled"); + nfs->enable_nlm = _gf_false; + } + + nfs->enable_acl = _gf_true; + ret = dict_get_str_boolean(this->options, "nfs.acl", _gf_true); + if (ret == _gf_false) { + gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_ACL_MAN_DISABLE, + "ACL is manually disabled"); + nfs->enable_acl = _gf_false; + } + + nfs->enable_ino32 = 0; + if (dict_get(this->options, "nfs.enable-ino32")) { + ret = dict_get_str(this->options, "nfs.enable-ino32", &optstr); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, + "Failed to parse dict"); + goto free_foppool; } - nfs->dynamicvolumes = GF_NFS_DVM_OFF; - if (dict_get (this->options, "nfs.dynamic-volumes")) { - ret = dict_get_str (this->options, "nfs.dynamic-volumes", - &optstr); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, -ret, - NFS_MSG_DICT_GET_FAILED, - "Failed to parse dict"); - goto free_foppool; - } - - ret = gf_string2boolean (optstr, &boolt); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL, - "Failed to parse bool string"); - goto free_foppool; - } - - if (boolt == _gf_true) - nfs->dynamicvolumes = GF_NFS_DVM_ON; + ret = gf_string2boolean(optstr, &boolt); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL, + "Failed to parse bool string"); + goto free_foppool; } - nfs->enable_nlm = _gf_true; - ret = dict_get_str_boolean (this->options, "nfs.nlm", _gf_true); - if (ret == _gf_false) { - gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_NLM_MAN_DISABLE, - "NLM is manually disabled"); - nfs->enable_nlm = _gf_false; - } + if (boolt == _gf_true) + nfs->enable_ino32 = 1; + } - nfs->enable_acl = _gf_true; - ret = dict_get_str_boolean (this->options, "nfs.acl", _gf_true); - if (ret == _gf_false) { - gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_ACL_MAN_DISABLE, - "ACL is manually disabled"); - nfs->enable_acl = _gf_false; + if (dict_get(this->options, "nfs.port")) { + ret = dict_get_str(this->options, "nfs.port", &optstr); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, + "Failed to parse dict"); + goto free_foppool; } - nfs->enable_ino32 = 0; - if (dict_get (this->options, "nfs.enable-ino32")) { - ret = dict_get_str (this->options, "nfs.enable-ino32", - &optstr); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, - "Failed to parse dict"); - goto free_foppool; - } - - ret = gf_string2boolean (optstr, &boolt); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL, - "Failed to parse bool string"); - goto free_foppool; - } - - if (boolt == _gf_true) - nfs->enable_ino32 = 1; + ret = gf_string2uint(optstr, &nfs->override_portnum); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL, + "Failed to parse uint string"); + goto free_foppool; } + } - if (dict_get (this->options, "nfs.port")) { - ret = dict_get_str (this->options, "nfs.port", - &optstr); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, - "Failed to parse dict"); - goto free_foppool; - } - - ret = gf_string2uint (optstr, &nfs->override_portnum); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL, - "Failed to parse uint string"); - goto free_foppool; - } + if (dict_get(this->options, "transport.socket.bind-address")) { + ret = dict_get_str(this->options, "transport.socket.bind-address", + &optstr); + if (ret < 0) { + gf_log(GF_NFS, GF_LOG_ERROR, + "Failed to parse " + "transport.socket.bind-address string"); + } else { + this->instance_name = gf_strdup(optstr); + for (i = 0; i < strlen(this->instance_name); i++) { + if (this->instance_name[i] == '.' || + this->instance_name[i] == ':') + this->instance_name[i] = '_'; + } } + } - if (dict_get (this->options, "transport.socket.bind-address")) { - ret = dict_get_str (this->options, - "transport.socket.bind-address", - &optstr); - if (ret < 0) { - gf_log (GF_NFS, GF_LOG_ERROR, "Failed to parse " - "transport.socket.bind-address string"); - } else { - this->instance_name = gf_strdup (optstr); - for (i = 0; i < strlen (this->instance_name); i++) { - if (this->instance_name[i] == '.' || - this->instance_name[i] == ':') - this->instance_name[i] = '_'; - } - } + if (dict_get(this->options, "transport.socket.listen-port") == NULL) { + if (nfs->override_portnum) + ret = gf_asprintf(&optstr, "%d", nfs->override_portnum); + else + ret = gf_asprintf(&optstr, "%d", GF_NFS3_PORT); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "failed mem-allocation"); + goto free_foppool; } - - if (dict_get(this->options, "transport.socket.listen-port") == NULL) { - if (nfs->override_portnum) - ret = gf_asprintf (&optstr, "%d", - nfs->override_portnum); - else - ret = gf_asprintf (&optstr, "%d", GF_NFS3_PORT); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "failed mem-allocation"); - goto free_foppool; - } - ret = dict_set_dynstr (this->options, - "transport.socket.listen-port", optstr); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, - NFS_MSG_DICT_SET_FAILED, - "dict_set_dynstr error"); - goto free_foppool; - } + ret = dict_set_dynstr(this->options, "transport.socket.listen-port", + optstr); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_DICT_SET_FAILED, + "dict_set_dynstr error"); + goto free_foppool; } + } #ifdef IPV6_DEFAULT - ret = dict_set_str (this->options, "transport.address-family", - "inet6"); - if (ret == -1) { - gf_log (GF_NFS, GF_LOG_ERROR, "dict_set_str error"); - goto free_foppool; - } + ret = dict_set_str(this->options, "transport.address-family", "inet6"); + if (ret == -1) { + gf_log(GF_NFS, GF_LOG_ERROR, "dict_set_str error"); + goto free_foppool; + } #endif - /* Right only socket support exists between nfs client and - * gluster nfs, so we can set default value as socket - */ - ret = dict_set_str (this->options, "transport-type", "socket"); + /* Right only socket support exists between nfs client and + * gluster nfs, so we can set default value as socket + */ + ret = dict_set_str(this->options, "transport-type", "socket"); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); + goto free_foppool; + } + + nfs->mount_udp = 0; + if (dict_get(this->options, "nfs.mount-udp")) { + ret = dict_get_str(this->options, "nfs.mount-udp", &optstr); if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_DICT_SET_FAILED, - "dict_set_str error"); - goto free_foppool; + gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, + "Failed to parse dict"); + goto free_foppool; } - nfs->mount_udp = 0; - if (dict_get(this->options, "nfs.mount-udp")) { - ret = dict_get_str (this->options, "nfs.mount-udp", &optstr); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, - "Failed to parse dict"); - goto free_foppool; - } - - ret = gf_string2boolean (optstr, &boolt); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL, - "Failed to parse bool " - "string"); - goto free_foppool; - } - - if (boolt == _gf_true) - nfs->mount_udp = 1; + ret = gf_string2boolean(optstr, &boolt); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL, + "Failed to parse bool " + "string"); + goto free_foppool; } - nfs->exports_auth = GF_NFS_DEFAULT_EXPORT_AUTH; - if (dict_get(this->options, "nfs.exports-auth-enable")) { - ret = dict_get_str (this->options, "nfs.exports-auth-enable", - &optstr); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, - "Failed to parse dict"); - goto free_foppool; - } - - ret = gf_string2boolean (optstr, &boolt); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL, - "Failed to parse bool string"); - goto free_foppool; - } - - if (boolt == _gf_true) - nfs->exports_auth = 1; - } + if (boolt == _gf_true) + nfs->mount_udp = 1; + } - nfs->auth_refresh_time_secs = GF_NFS_DEFAULT_AUTH_REFRESH_INTERVAL_SEC; - if (dict_get (this->options, "nfs.auth-refresh-interval-sec")) { - ret = dict_get_str (this->options, - "nfs.auth-refresh-interval-sec", &optstr); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, - "Failed to parse dict"); - goto free_foppool; - } - - ret = gf_string2uint (optstr, &nfs->auth_refresh_time_secs); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL, - "Failed to parse uint string"); - goto free_foppool; - } + nfs->exports_auth = GF_NFS_DEFAULT_EXPORT_AUTH; + if (dict_get(this->options, "nfs.exports-auth-enable")) { + ret = dict_get_str(this->options, "nfs.exports-auth-enable", &optstr); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, + "Failed to parse dict"); + goto free_foppool; } - nfs->auth_cache_ttl_sec = GF_NFS_DEFAULT_AUTH_CACHE_TTL_SEC; - if (dict_get (this->options, "nfs.auth-cache-ttl-sec")) { - ret = dict_get_str (this->options, - "nfs.auth-cache-ttl-sec", &optstr); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, - "Failed to parse dict"); - goto free_foppool; - } - - ret = gf_string2uint (optstr, &nfs->auth_cache_ttl_sec); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL, - "Failed to parse uint string"); - goto free_foppool; - } + ret = gf_string2boolean(optstr, &boolt); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL, + "Failed to parse bool string"); + goto free_foppool; } - /* TODO: Make this a configurable option in case we don't want to read - * exports/netgroup files off disk when they change. */ - nfs->refresh_auth = 1; - - nfs->rmtab = gf_strdup (NFS_DATADIR "/rmtab"); - if (dict_get(this->options, "nfs.mount-rmtab")) { - ret = dict_get_str (this->options, "nfs.mount-rmtab", &nfs->rmtab); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, - "Failed to parse dict"); - goto free_foppool; - } - - /* check if writing the rmtab is disabled*/ - if (nfs->rmtab && strcmp ("/-", nfs->rmtab) == 0) { - GF_FREE (nfs->rmtab); - nfs->rmtab = NULL; - } - } + if (boolt == _gf_true) + nfs->exports_auth = 1; + } - /* support both options rpc-auth.ports.insecure and - * rpc-auth-allow-insecure for backward compatibility - */ - nfs->allow_insecure = 1; - if (dict_get(this->options, "rpc-auth.ports.insecure")) { - ret = dict_get_str (this->options, "rpc-auth.ports.insecure", - &optstr); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, - "Failed to parse dict"); - goto free_foppool; - } - - ret = gf_string2boolean (optstr, &boolt); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL, - "Failed to parse bool " - "string"); - goto free_foppool; - } - - if (boolt == _gf_false) - nfs->allow_insecure = 0; + nfs->auth_refresh_time_secs = GF_NFS_DEFAULT_AUTH_REFRESH_INTERVAL_SEC; + if (dict_get(this->options, "nfs.auth-refresh-interval-sec")) { + ret = dict_get_str(this->options, "nfs.auth-refresh-interval-sec", + &optstr); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, + "Failed to parse dict"); + goto free_foppool; } - if (dict_get(this->options, "rpc-auth-allow-insecure")) { - ret = dict_get_str (this->options, "rpc-auth-allow-insecure", - &optstr); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, - "Failed to parse dict"); - goto free_foppool; - } - - ret = gf_string2boolean (optstr, &boolt); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL, - "Failed to parse bool string"); - goto free_foppool; - } - - if (boolt == _gf_false) - nfs->allow_insecure = 0; + ret = gf_string2uint(optstr, &nfs->auth_refresh_time_secs); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL, + "Failed to parse uint string"); + goto free_foppool; } + } - if (nfs->allow_insecure) { - /* blindly set both the options */ - ret = dict_set_str (this->options, - "rpc-auth-allow-insecure", "on"); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, - NFS_MSG_DICT_SET_FAILED, "dict_set_str error"); - goto free_foppool; - } - ret = dict_set_str (this->options, - "rpc-auth.ports.insecure", "on"); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, - NFS_MSG_DICT_SET_FAILED, "dict_set_str error"); - goto free_foppool; - } + nfs->auth_cache_ttl_sec = GF_NFS_DEFAULT_AUTH_CACHE_TTL_SEC; + if (dict_get(this->options, "nfs.auth-cache-ttl-sec")) { + ret = dict_get_str(this->options, "nfs.auth-cache-ttl-sec", &optstr); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, + "Failed to parse dict"); + goto free_foppool; } - GF_OPTION_INIT ("nfs.rdirplus", nfs->rdirplus, bool, free_foppool); - - GF_OPTION_INIT (OPT_SERVER_RPC_STATD, nfs->rpc_statd, path, free_foppool); - - GF_OPTION_INIT (OPT_SERVER_RPC_STATD_PIDFILE, nfs->rpc_statd_pid_file, path, free_foppool); + ret = gf_string2uint(optstr, &nfs->auth_cache_ttl_sec); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL, + "Failed to parse uint string"); + goto free_foppool; + } + } - GF_OPTION_INIT (OPT_SERVER_AUX_GIDS, nfs->server_aux_gids, - bool, free_foppool); - GF_OPTION_INIT (OPT_SERVER_GID_CACHE_TIMEOUT, - nfs->server_aux_gids_max_age, - uint32, free_foppool); + /* TODO: Make this a configurable option in case we don't want to read + * exports/netgroup files off disk when they change. */ + nfs->refresh_auth = 1; - if (gid_cache_init(&nfs->gid_cache, nfs->server_aux_gids_max_age) < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, - NFS_MSG_INIT_GRP_CACHE_FAIL, - "Failed to initialize group cache."); - goto free_foppool; + nfs->rmtab = gf_strdup(NFS_DATADIR "/rmtab"); + if (dict_get(this->options, "nfs.mount-rmtab")) { + ret = dict_get_str(this->options, "nfs.mount-rmtab", &nfs->rmtab); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, + "Failed to parse dict"); + goto free_foppool; } - ret = sys_access (nfs->rpc_statd, X_OK); - if (ret) { - gf_msg (GF_NFS, GF_LOG_WARNING, EPERM, NFS_MSG_NO_PERM, - "%s not enough permissions to access. Disabling NLM", - nfs->rpc_statd); - nfs->enable_nlm = _gf_false; + /* check if writing the rmtab is disabled*/ + if (nfs->rmtab && strcmp("/-", nfs->rmtab) == 0) { + GF_FREE(nfs->rmtab); + nfs->rmtab = NULL; + } + } + + /* support both options rpc-auth.ports.insecure and + * rpc-auth-allow-insecure for backward compatibility + */ + nfs->allow_insecure = 1; + if (dict_get(this->options, "rpc-auth.ports.insecure")) { + ret = dict_get_str(this->options, "rpc-auth.ports.insecure", &optstr); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, + "Failed to parse dict"); + goto free_foppool; } - ret = sys_stat (nfs->rpc_statd, &stbuf); - if (ret || !S_ISREG (stbuf.st_mode)) { - gf_msg (GF_NFS, GF_LOG_WARNING, 0, NFS_MSG_REG_FILE_ERROR, - "%s not a regular file. Disabling NLM", nfs->rpc_statd); - nfs->enable_nlm = _gf_false; + ret = gf_string2boolean(optstr, &boolt); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL, + "Failed to parse bool " + "string"); + goto free_foppool; } - nfs->rpcsvc = rpcsvc_init (this, this->ctx, - this->options, fopspoolsize); - if (!nfs->rpcsvc) { - ret = -1; - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RPC_INIT_FAIL, - "RPC service init failed"); - goto free_foppool; - } + if (boolt == _gf_false) + nfs->allow_insecure = 0; + } - ret = rpcsvc_set_throttle_on (nfs->rpcsvc); - if (ret) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_ENABLE_THROTTLE_FAIL, - "Enabling throttle failed"); - goto free_foppool; + if (dict_get(this->options, "rpc-auth-allow-insecure")) { + ret = dict_get_str(this->options, "rpc-auth-allow-insecure", &optstr); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL, + "Failed to parse dict"); + goto free_foppool; } - ret = rpcsvc_set_outstanding_rpc_limit (nfs->rpcsvc, - this->options, - RPCSVC_DEF_NFS_OUTSTANDING_RPC_LIMIT); + ret = gf_string2boolean(optstr, &boolt); if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RPC_CONFIG_FAIL, - "Failed to configure outstanding-rpc-limit"); - goto free_foppool; + gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL, + "Failed to parse bool string"); + goto free_foppool; } - nfs->register_portmap = rpcsvc_register_portmap_enabled (nfs->rpcsvc); + if (boolt == _gf_false) + nfs->allow_insecure = 0; + } - GF_OPTION_INIT ("nfs.event-threads", - nfs->event_threads, uint32, free_foppool); - event_reconfigure_threads (this->ctx->event_pool, nfs->event_threads); - - this->private = (void *)nfs; - INIT_LIST_HEAD (&nfs->versions); - nfs->generation = 1965; - - ret = 0; + if (nfs->allow_insecure) { + /* blindly set both the options */ + ret = dict_set_str(this->options, "rpc-auth-allow-insecure", "on"); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); + goto free_foppool; + } + ret = dict_set_str(this->options, "rpc-auth.ports.insecure", "on"); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); + goto free_foppool; + } + } + + GF_OPTION_INIT("nfs.rdirplus", nfs->rdirplus, bool, free_foppool); + + GF_OPTION_INIT(OPT_SERVER_RPC_STATD, nfs->rpc_statd, path, free_foppool); + + GF_OPTION_INIT(OPT_SERVER_RPC_STATD_PIDFILE, nfs->rpc_statd_pid_file, path, + free_foppool); + + GF_OPTION_INIT(OPT_SERVER_AUX_GIDS, nfs->server_aux_gids, bool, + free_foppool); + GF_OPTION_INIT(OPT_SERVER_GID_CACHE_TIMEOUT, nfs->server_aux_gids_max_age, + uint32, free_foppool); + + if (gid_cache_init(&nfs->gid_cache, nfs->server_aux_gids_max_age) < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_INIT_GRP_CACHE_FAIL, + "Failed to initialize group cache."); + goto free_foppool; + } + + ret = sys_access(nfs->rpc_statd, X_OK); + if (ret) { + gf_msg(GF_NFS, GF_LOG_WARNING, EPERM, NFS_MSG_NO_PERM, + "%s not enough permissions to access. Disabling NLM", + nfs->rpc_statd); + nfs->enable_nlm = _gf_false; + } + + ret = sys_stat(nfs->rpc_statd, &stbuf); + if (ret || !S_ISREG(stbuf.st_mode)) { + gf_msg(GF_NFS, GF_LOG_WARNING, 0, NFS_MSG_REG_FILE_ERROR, + "%s not a regular file. Disabling NLM", nfs->rpc_statd); + nfs->enable_nlm = _gf_false; + } + + nfs->rpcsvc = rpcsvc_init(this, this->ctx, this->options, fopspoolsize); + if (!nfs->rpcsvc) { + ret = -1; + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RPC_INIT_FAIL, + "RPC service init failed"); + goto free_foppool; + } + + ret = rpcsvc_set_throttle_on(nfs->rpcsvc); + if (ret) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_ENABLE_THROTTLE_FAIL, + "Enabling throttle failed"); + goto free_foppool; + } + + ret = rpcsvc_set_outstanding_rpc_limit( + nfs->rpcsvc, this->options, RPCSVC_DEF_NFS_OUTSTANDING_RPC_LIMIT); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RPC_CONFIG_FAIL, + "Failed to configure outstanding-rpc-limit"); + goto free_foppool; + } + + nfs->register_portmap = rpcsvc_register_portmap_enabled(nfs->rpcsvc); + + GF_OPTION_INIT("nfs.event-threads", nfs->event_threads, uint32, + free_foppool); + event_reconfigure_threads(this->ctx->event_pool, nfs->event_threads); + + this->private = (void *)nfs; + INIT_LIST_HEAD(&nfs->versions); + nfs->generation = 1965; + + ret = 0; free_foppool: - if (ret < 0) - mem_pool_destroy (nfs->foppool); + if (ret < 0) + mem_pool_destroy(nfs->foppool); free_rpcsvc: - /* - * rpcsvc_deinit */ - if (ret < 0) { - GF_FREE (nfs); - nfs = NULL; - } - - return nfs; + /* + * rpcsvc_deinit */ + if (ret < 0) { + GF_FREE(nfs); + nfs = NULL; + } + + return nfs; } int -nfs_drc_init (xlator_t *this) +nfs_drc_init(xlator_t *this) { - int ret = -1; - rpcsvc_t *svc = NULL; + int ret = -1; + rpcsvc_t *svc = NULL; - GF_VALIDATE_OR_GOTO (GF_NFS, this, out); - GF_VALIDATE_OR_GOTO (GF_NFS, this->private, out); + GF_VALIDATE_OR_GOTO(GF_NFS, this, out); + GF_VALIDATE_OR_GOTO(GF_NFS, this->private, out); - svc = ((struct nfs_state *)(this->private))->rpcsvc; - if (!svc) - goto out; + svc = ((struct nfs_state *)(this->private))->rpcsvc; + if (!svc) + goto out; - ret = rpcsvc_drc_init (svc, this->options); + ret = rpcsvc_drc_init(svc, this->options); - out: - return ret; +out: + return ret; } int -nfs_reconfigure_state (xlator_t *this, dict_t *options) +nfs_reconfigure_state(xlator_t *this, dict_t *options) { - int ret = 0; - int keyindx = 0; - char *rmtab = NULL; - char *rpc_statd = NULL; - gf_boolean_t optbool; - uint32_t optuint32; - struct nfs_state *nfs = NULL; - char *blacklist_keys[] = { - "nfs.port", - "nfs.transport-type", - "nfs.mem-factor", - NULL}; - - GF_VALIDATE_OR_GOTO (GF_NFS, this, out); - GF_VALIDATE_OR_GOTO (GF_NFS, this->private, out); - GF_VALIDATE_OR_GOTO (GF_NFS, options, out); - - nfs = (struct nfs_state *)this->private; - - /* Black listed options can't be reconfigured, they need - * NFS to be restarted. There are two cases 1. SET 2. UNSET. - * 1. SET */ - while (blacklist_keys[keyindx]) { - if (dict_get (options, blacklist_keys[keyindx])) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, - NFS_MSG_RECONFIG_FAIL, - "Reconfiguring %s needs NFS restart", - blacklist_keys[keyindx]); - goto out; - } - keyindx ++; - } - - /* UNSET for nfs.mem-factor */ - if ((!dict_get (options, "nfs.mem-factor")) && - (nfs->memfactor != GF_NFS_DEFAULT_MEMFACTOR)) { - gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_FAIL, - "Reconfiguring nfs.mem-factor needs NFS restart"); - goto out; - } - - /* UNSET for nfs.port */ - if ((!dict_get (options, "nfs.port")) && - (nfs->override_portnum)) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL, - "Reconfiguring nfs.port needs NFS restart"); - goto out; - } - - /* reconfig nfs.rpc-statd... */ - rpc_statd = GF_RPC_STATD_PROG; - if (dict_get (options, OPT_SERVER_RPC_STATD_PIDFILE)) { - ret = dict_get_str (options, "nfs.rpc-statd", &rpc_statd); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, - "Failed to read reconfigured option: " - "nfs.rpc-statd"); - goto out; - } - } - - if (strcmp(nfs->rpc_statd, rpc_statd) != 0) { - gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_FAIL, - "Reconfiguring nfs.rpc-statd needs NFS restart"); - goto out; - } - - /* reconfig nfs.mount-rmtab */ - rmtab = NFS_DATADIR "/rmtab"; - if (dict_get (options, "nfs.mount-rmtab")) { - ret = dict_get_str (options, "nfs.mount-rmtab", &rmtab); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, - "Failed to read reconfigured option:" - " nfs.mount-rmtab"); - goto out; - } - gf_path_strip_trailing_slashes (rmtab); - } - /* check if writing the rmtab is disabled*/ - if (strcmp ("/-", rmtab) == 0) { - GF_FREE (nfs->rmtab); - nfs->rmtab = NULL; - gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_WRITE_FAIL, - "Disabled writing of nfs.mount-rmtab"); - } else if (!nfs->rmtab || strcmp (nfs->rmtab, rmtab) != 0) { - mount_rewrite_rmtab (nfs->mstate, rmtab); - gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_PATH, - "Reconfigured nfs.mount-rmtab path: %s", nfs->rmtab); - } - - GF_OPTION_RECONF (OPT_SERVER_AUX_GIDS, optbool, - options, bool, out); - if (nfs->server_aux_gids != optbool) { - nfs->server_aux_gids = optbool; - gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_VALUE, - "Reconfigured %s with value %d", OPT_SERVER_AUX_GIDS, - optbool); - } - - GF_OPTION_RECONF (OPT_SERVER_GID_CACHE_TIMEOUT, optuint32, - options, uint32, out); - if (nfs->server_aux_gids_max_age != optuint32) { - nfs->server_aux_gids_max_age = optuint32; - gid_cache_reconf (&nfs->gid_cache, optuint32); - gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_VALUE, - "Reconfigured %s with value %d", - OPT_SERVER_GID_CACHE_TIMEOUT, optuint32); - } - - GF_OPTION_RECONF ("nfs.rdirplus", optbool, - options, bool, out); - if (nfs->rdirplus != optbool) { - nfs->rdirplus = optbool; - gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_VALUE, - "Reconfigured nfs.rdirplus with value %d", optbool); - } - - /* reconfig nfs.dynamic-volumes */ - ret = dict_get_str_boolean (options, "nfs.dynamic-volumes", - GF_NFS_DVM_OFF); - switch (ret) { + int ret = 0; + int keyindx = 0; + char *rmtab = NULL; + char *rpc_statd = NULL; + gf_boolean_t optbool; + uint32_t optuint32; + struct nfs_state *nfs = NULL; + char *blacklist_keys[] = {"nfs.port", "nfs.transport-type", + "nfs.mem-factor", NULL}; + + GF_VALIDATE_OR_GOTO(GF_NFS, this, out); + GF_VALIDATE_OR_GOTO(GF_NFS, this->private, out); + GF_VALIDATE_OR_GOTO(GF_NFS, options, out); + + nfs = (struct nfs_state *)this->private; + + /* Black listed options can't be reconfigured, they need + * NFS to be restarted. There are two cases 1. SET 2. UNSET. + * 1. SET */ + while (blacklist_keys[keyindx]) { + if (dict_get(options, blacklist_keys[keyindx])) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL, + "Reconfiguring %s needs NFS restart", + blacklist_keys[keyindx]); + goto out; + } + keyindx++; + } + + /* UNSET for nfs.mem-factor */ + if ((!dict_get(options, "nfs.mem-factor")) && + (nfs->memfactor != GF_NFS_DEFAULT_MEMFACTOR)) { + gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_FAIL, + "Reconfiguring nfs.mem-factor needs NFS restart"); + goto out; + } + + /* UNSET for nfs.port */ + if ((!dict_get(options, "nfs.port")) && (nfs->override_portnum)) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL, + "Reconfiguring nfs.port needs NFS restart"); + goto out; + } + + /* reconfig nfs.rpc-statd... */ + rpc_statd = GF_RPC_STATD_PROG; + if (dict_get(options, OPT_SERVER_RPC_STATD_PIDFILE)) { + ret = dict_get_str(options, "nfs.rpc-statd", &rpc_statd); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, + "Failed to read reconfigured option: " + "nfs.rpc-statd"); + goto out; + } + } + + if (strcmp(nfs->rpc_statd, rpc_statd) != 0) { + gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_FAIL, + "Reconfiguring nfs.rpc-statd needs NFS restart"); + goto out; + } + + /* reconfig nfs.mount-rmtab */ + rmtab = NFS_DATADIR "/rmtab"; + if (dict_get(options, "nfs.mount-rmtab")) { + ret = dict_get_str(options, "nfs.mount-rmtab", &rmtab); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, + "Failed to read reconfigured option:" + " nfs.mount-rmtab"); + goto out; + } + gf_path_strip_trailing_slashes(rmtab); + } + /* check if writing the rmtab is disabled*/ + if (strcmp("/-", rmtab) == 0) { + GF_FREE(nfs->rmtab); + nfs->rmtab = NULL; + gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_WRITE_FAIL, + "Disabled writing of nfs.mount-rmtab"); + } else if (!nfs->rmtab || strcmp(nfs->rmtab, rmtab) != 0) { + mount_rewrite_rmtab(nfs->mstate, rmtab); + gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_PATH, + "Reconfigured nfs.mount-rmtab path: %s", nfs->rmtab); + } + + GF_OPTION_RECONF(OPT_SERVER_AUX_GIDS, optbool, options, bool, out); + if (nfs->server_aux_gids != optbool) { + nfs->server_aux_gids = optbool; + gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_VALUE, + "Reconfigured %s with value %d", OPT_SERVER_AUX_GIDS, optbool); + } + + GF_OPTION_RECONF(OPT_SERVER_GID_CACHE_TIMEOUT, optuint32, options, uint32, + out); + if (nfs->server_aux_gids_max_age != optuint32) { + nfs->server_aux_gids_max_age = optuint32; + gid_cache_reconf(&nfs->gid_cache, optuint32); + gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_VALUE, + "Reconfigured %s with value %d", OPT_SERVER_GID_CACHE_TIMEOUT, + optuint32); + } + + GF_OPTION_RECONF("nfs.rdirplus", optbool, options, bool, out); + if (nfs->rdirplus != optbool) { + nfs->rdirplus = optbool; + gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_VALUE, + "Reconfigured nfs.rdirplus with value %d", optbool); + } + + /* reconfig nfs.dynamic-volumes */ + ret = dict_get_str_boolean(options, "nfs.dynamic-volumes", GF_NFS_DVM_OFF); + switch (ret) { case GF_NFS_DVM_ON: case GF_NFS_DVM_OFF: - optbool = ret; - break; + optbool = ret; + break; default: - optbool = GF_NFS_DVM_OFF; - break; - } - if (nfs->dynamicvolumes != optbool) { - nfs->dynamicvolumes = optbool; - gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_VOL, - "Reconfigured nfs.dynamic-volumes with value %d", - optbool); - } - - optbool = _gf_false; - if (dict_get (options, "nfs.enable-ino32")) { - ret = dict_get_str_boolean (options, "nfs.enable-ino32", - _gf_false); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, - "Failed to read reconfigured option: " - "nfs.enable-ino32"); - goto out; - } - optbool = ret; - } - if (nfs->enable_ino32 != optbool) { - nfs->enable_ino32 = optbool; - gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_ENABLE, - "Reconfigured nfs.enable-ino32 with value %d", optbool); - } - - /* nfs.nlm is enabled by default */ - ret = dict_get_str_boolean (options, "nfs.nlm", _gf_true); + optbool = GF_NFS_DVM_OFF; + break; + } + if (nfs->dynamicvolumes != optbool) { + nfs->dynamicvolumes = optbool; + gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_VOL, + "Reconfigured nfs.dynamic-volumes with value %d", optbool); + } + + optbool = _gf_false; + if (dict_get(options, "nfs.enable-ino32")) { + ret = dict_get_str_boolean(options, "nfs.enable-ino32", _gf_false); if (ret < 0) { - optbool = _gf_true; - } else { - optbool = ret; - } - if (nfs->enable_nlm != optbool) { - gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_NLM_INFO, "NLM is" - " manually %s", (optbool ? "enabled":"disabled")); - nfs->enable_nlm = optbool; - nfs_reconfigure_nlm4 (this); - } - - /* nfs.acl is enabled by default */ - ret = dict_get_str_boolean (options, "nfs.acl", _gf_true); - if (ret < 0) { - optbool = _gf_true; - } else { - optbool = ret; - } - if (nfs->enable_acl != optbool) { - gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_ACL_INFO, "ACL is " - "manually %s", (optbool ? "enabled":"disabled")); - nfs->enable_acl = optbool; - nfs_reconfigure_acl3 (this); - } - - GF_OPTION_RECONF ("nfs.event-threads", - nfs->event_threads, options, uint32, out); - event_reconfigure_threads (this->ctx->event_pool, nfs->event_threads); - - - ret = 0; + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, + "Failed to read reconfigured option: " + "nfs.enable-ino32"); + goto out; + } + optbool = ret; + } + if (nfs->enable_ino32 != optbool) { + nfs->enable_ino32 = optbool; + gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_ENABLE, + "Reconfigured nfs.enable-ino32 with value %d", optbool); + } + + /* nfs.nlm is enabled by default */ + ret = dict_get_str_boolean(options, "nfs.nlm", _gf_true); + if (ret < 0) { + optbool = _gf_true; + } else { + optbool = ret; + } + if (nfs->enable_nlm != optbool) { + gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_NLM_INFO, + "NLM is" + " manually %s", + (optbool ? "enabled" : "disabled")); + nfs->enable_nlm = optbool; + nfs_reconfigure_nlm4(this); + } + + /* nfs.acl is enabled by default */ + ret = dict_get_str_boolean(options, "nfs.acl", _gf_true); + if (ret < 0) { + optbool = _gf_true; + } else { + optbool = ret; + } + if (nfs->enable_acl != optbool) { + gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_ACL_INFO, + "ACL is " + "manually %s", + (optbool ? "enabled" : "disabled")); + nfs->enable_acl = optbool; + nfs_reconfigure_acl3(this); + } + + GF_OPTION_RECONF("nfs.event-threads", nfs->event_threads, options, uint32, + out); + event_reconfigure_threads(this->ctx->event_pool, nfs->event_threads); + + ret = 0; out: - return ret; + return ret; } - /* * reconfigure() for NFS server xlator. */ int -reconfigure (xlator_t *this, dict_t *options) +reconfigure(xlator_t *this, dict_t *options) { - int ret = 0; - struct nfs_state *nfs = NULL; - gf_boolean_t regpmap = _gf_true; - - if ((!this) || (!this->private) || (!options)) - return (-1); + int ret = 0; + struct nfs_state *nfs = NULL; + gf_boolean_t regpmap = _gf_true; - nfs = (struct nfs_state *)this->private; + if ((!this) || (!this->private) || (!options)) + return (-1); - /* Reconfigure nfs options */ - ret = nfs_reconfigure_state(this, options); - if (ret) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL, - "nfs reconfigure state failed"); - return (-1); - } + nfs = (struct nfs_state *)this->private; - /* Reconfigure nfs3 options */ - ret = nfs3_reconfigure_state(this, options); - if (ret) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL, - "nfs3 reconfigure state failed"); - return (-1); - } + /* Reconfigure nfs options */ + ret = nfs_reconfigure_state(this, options); + if (ret) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL, + "nfs reconfigure state failed"); + return (-1); + } - /* Reconfigure mount options */ - ret = mount_reconfigure_state(this, options); - if (ret) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL, - "mount reconfigure state failed"); - return (-1); - } + /* Reconfigure nfs3 options */ + ret = nfs3_reconfigure_state(this, options); + if (ret) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL, + "nfs3 reconfigure state failed"); + return (-1); + } - /* Reconfigure rpc layer */ - ret = rpcsvc_reconfigure_options (nfs->rpcsvc, options); - if (ret) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL, - "rpcsvc reconfigure options failed"); - return (-1); - } + /* Reconfigure mount options */ + ret = mount_reconfigure_state(this, options); + if (ret) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL, + "mount reconfigure state failed"); + return (-1); + } - /* Reconfigure rpc.outstanding-rpc-limit */ - ret = rpcsvc_set_outstanding_rpc_limit (nfs->rpcsvc, - options, - RPCSVC_DEF_NFS_OUTSTANDING_RPC_LIMIT); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL, - "Failed to reconfigure outstanding-rpc-limit"); - return (-1); - } + /* Reconfigure rpc layer */ + ret = rpcsvc_reconfigure_options(nfs->rpcsvc, options); + if (ret) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL, + "rpcsvc reconfigure options failed"); + return (-1); + } + + /* Reconfigure rpc.outstanding-rpc-limit */ + ret = rpcsvc_set_outstanding_rpc_limit( + nfs->rpcsvc, options, RPCSVC_DEF_NFS_OUTSTANDING_RPC_LIMIT); + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL, + "Failed to reconfigure outstanding-rpc-limit"); + return (-1); + } - regpmap = rpcsvc_register_portmap_enabled(nfs->rpcsvc); - if (nfs->register_portmap != regpmap) { - nfs->register_portmap = regpmap; - if (regpmap) { - (void) nfs_program_register_portmap_all (nfs); - } else { - (void) nfs_program_unregister_portmap_all (nfs); - } + regpmap = rpcsvc_register_portmap_enabled(nfs->rpcsvc); + if (nfs->register_portmap != regpmap) { + nfs->register_portmap = regpmap; + if (regpmap) { + (void)nfs_program_register_portmap_all(nfs); + } else { + (void)nfs_program_unregister_portmap_all(nfs); } + } - /* Reconfigure drc */ - ret = rpcsvc_drc_reconfigure (nfs->rpcsvc, options); - if (ret) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL, - "rpcsvc DRC reconfigure failed"); - return (-1); - } + /* Reconfigure drc */ + ret = rpcsvc_drc_reconfigure(nfs->rpcsvc, options); + if (ret) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL, + "rpcsvc DRC reconfigure failed"); + return (-1); + } - return (0); + return (0); } /* Main init() routine for NFS server xlator. It inits NFS v3 protocol @@ -1496,650 +1439,604 @@ reconfigure (xlator_t *this, dict_t *options) * -1 (FAILURE) if any of them FAILS. */ int -init (xlator_t *this) { - - struct nfs_state *nfs = NULL; - int ret = -1; +init(xlator_t *this) +{ + struct nfs_state *nfs = NULL; + int ret = -1; - if (!this) - return (-1); + if (!this) + return (-1); - nfs = nfs_init_state (this); - if (!nfs) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_OPT_INIT_FAIL, - "Failed to init nfs option"); - return (-1); - } + nfs = nfs_init_state(this); + if (!nfs) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_OPT_INIT_FAIL, + "Failed to init nfs option"); + return (-1); + } - ret = nfs_add_all_initiators (nfs); - if (ret) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_INIT_FAIL, - "Failed to add initiators"); - return (-1); - } + ret = nfs_add_all_initiators(nfs); + if (ret) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_INIT_FAIL, + "Failed to add initiators"); + return (-1); + } - ret = nfs_init_subvolumes (nfs, this->children); - if (ret) { - gf_msg (GF_NFS, GF_LOG_CRITICAL, 0, NFS_MSG_INIT_FAIL, - "Failed to init NFS exports"); - return (-1); - } + ret = nfs_init_subvolumes(nfs, this->children); + if (ret) { + gf_msg(GF_NFS, GF_LOG_CRITICAL, 0, NFS_MSG_INIT_FAIL, + "Failed to init NFS exports"); + return (-1); + } - ret = mount_init_state (this); - if (ret) { - gf_msg (GF_NFS, GF_LOG_CRITICAL, 0, NFS_MSG_INIT_FAIL, - "Failed to init Mount state"); - return (-1); - } + ret = mount_init_state(this); + if (ret) { + gf_msg(GF_NFS, GF_LOG_CRITICAL, 0, NFS_MSG_INIT_FAIL, + "Failed to init Mount state"); + return (-1); + } - ret = nlm4_init_state (this); - if (ret) { - gf_msg (GF_NFS, GF_LOG_CRITICAL, 0, NFS_MSG_INIT_FAIL, - "Failed to init NLM state"); - return (-1); - } + ret = nlm4_init_state(this); + if (ret) { + gf_msg(GF_NFS, GF_LOG_CRITICAL, 0, NFS_MSG_INIT_FAIL, + "Failed to init NLM state"); + return (-1); + } - ret = nfs_init_versions (nfs, this); - if (ret) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_INIT_FAIL, - "Failed to initialize protocols"); - return (-1); - } + ret = nfs_init_versions(nfs, this); + if (ret) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_INIT_FAIL, + "Failed to initialize protocols"); + return (-1); + } - ret = nfs_drc_init (this); - if (ret) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_INIT_FAIL, - "Failed to initialize DRC"); - return (-1); - } + ret = nfs_drc_init(this); + if (ret) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_INIT_FAIL, + "Failed to initialize DRC"); + return (-1); + } - gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_STARTED, - "NFS service started"); - return (0); /* SUCCESS */ + gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_STARTED, "NFS service started"); + return (0); /* SUCCESS */ } - int -notify (xlator_t *this, int32_t event, void *data, ...) +notify(xlator_t *this, int32_t event, void *data, ...) { - xlator_t *subvol = NULL; - struct nfs_state *priv = NULL; + xlator_t *subvol = NULL; + struct nfs_state *priv = NULL; - subvol = (xlator_t *)data; + subvol = (xlator_t *)data; - gf_msg_trace (GF_NFS, 0, "Notification received: %d", - event); + gf_msg_trace(GF_NFS, 0, "Notification received: %d", event); - switch (event) { + switch (event) { case GF_EVENT_CHILD_UP: - nfs_startup_subvolume (this, subvol); - break; + nfs_startup_subvolume(this, subvol); + break; case GF_EVENT_SOME_DESCENDENT_DOWN: case GF_EVENT_SOME_DESCENDENT_UP: - priv = this->private; - ++(priv->generation); - break; + priv = this->private; + ++(priv->generation); + break; case GF_EVENT_PARENT_UP: - default_notify (this, GF_EVENT_PARENT_UP, data); - break; - } + default_notify(this, GF_EVENT_PARENT_UP, data); + break; + } - return 0; + return 0; } - int -fini (xlator_t *this) +fini(xlator_t *this) { - - struct nfs_state *nfs = NULL; - - mnt3svc_deinit (this); - nfs = (struct nfs_state *)this->private; - gf_msg_debug (GF_NFS, 0, "NFS service going down"); - nfs_deinit_versions (&nfs->versions, this); - GF_FREE (this->instance_name); - return 0; + struct nfs_state *nfs = NULL; + + mnt3svc_deinit(this); + nfs = (struct nfs_state *)this->private; + gf_msg_debug(GF_NFS, 0, "NFS service going down"); + nfs_deinit_versions(&nfs->versions, this); + GF_FREE(this->instance_name); + return 0; } int32_t -nfs_forget (xlator_t *this, inode_t *inode) +nfs_forget(xlator_t *this, inode_t *inode) { - uint64_t ctx = 0; - struct nfs_inode_ctx *ictx = NULL; + uint64_t ctx = 0; + struct nfs_inode_ctx *ictx = NULL; - if (inode_ctx_del (inode, this, &ctx)) - return -1; + if (inode_ctx_del(inode, this, &ctx)) + return -1; - ictx = (struct nfs_inode_ctx *)ctx; - GF_FREE (ictx); + ictx = (struct nfs_inode_ctx *)ctx; + GF_FREE(ictx); - return 0; + return 0; } gf_boolean_t -_nfs_export_is_for_vol (char *exname, char *volname) +_nfs_export_is_for_vol(char *exname, char *volname) { - gf_boolean_t ret = _gf_false; - char *tmp = NULL; + gf_boolean_t ret = _gf_false; + char *tmp = NULL; - tmp = exname; - if (tmp[0] == '/') - tmp++; + tmp = exname; + if (tmp[0] == '/') + tmp++; - if (!strcmp (tmp, volname)) - ret = _gf_true; + if (!strcmp(tmp, volname)) + ret = _gf_true; - return ret; + return ret; } int -nfs_priv_to_dict (xlator_t *this, dict_t *dict, char *brickname) +nfs_priv_to_dict(xlator_t *this, dict_t *dict, char *brickname) { - int ret = -1; - struct nfs_state *priv = NULL; - struct mountentry *mentry = NULL; - char *volname = NULL; - char key[1024] = {0,}; - int count = 0; - - GF_VALIDATE_OR_GOTO (THIS->name, this, out); - GF_VALIDATE_OR_GOTO (THIS->name, dict, out); - - priv = this->private; - GF_ASSERT (priv); + int ret = -1; + struct nfs_state *priv = NULL; + struct mountentry *mentry = NULL; + char *volname = NULL; + char key[1024] = { + 0, + }; + int count = 0; + + GF_VALIDATE_OR_GOTO(THIS->name, this, out); + GF_VALIDATE_OR_GOTO(THIS->name, dict, out); + + priv = this->private; + GF_ASSERT(priv); + + ret = dict_get_str(dict, "volname", &volname); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, -ret, NFS_MSG_VOL_NOT_FOUND, + "Could not get volname"); + goto out; + } + + list_for_each_entry(mentry, &priv->mstate->mountlist, mlist) + { + if (!_nfs_export_is_for_vol(mentry->exname, volname)) + continue; + + snprintf(key, sizeof(key), "client%d.hostname", count); + ret = dict_set_str(dict, key, mentry->hostname); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, NFS_MSG_WRITE_FAIL, + "Error writing hostname to dict"); + goto out; + } - ret = dict_get_str (dict, "volname", &volname); + /* No connection data available yet in nfs server. + * Hence, setting to 0 to prevent cli failing + */ + snprintf(key, sizeof(key), "client%d.bytesread", count); + ret = dict_set_uint64(dict, key, 0); if (ret) { - gf_msg (this->name, GF_LOG_ERROR, -ret, NFS_MSG_VOL_NOT_FOUND, - "Could not get volname"); - goto out; + gf_msg(this->name, GF_LOG_ERROR, 0, NFS_MSG_WRITE_FAIL, + "Error writing bytes read to dict"); + goto out; } - list_for_each_entry (mentry, &priv->mstate->mountlist, mlist) { - if (!_nfs_export_is_for_vol (mentry->exname, volname)) - continue; - - snprintf (key, sizeof (key), "client%d.hostname", count); - ret = dict_set_str (dict, key, mentry->hostname); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, - NFS_MSG_WRITE_FAIL, - "Error writing hostname to dict"); - goto out; - } - - /* No connection data available yet in nfs server. - * Hence, setting to 0 to prevent cli failing - */ - snprintf (key, sizeof (key), "client%d.bytesread", count); - ret = dict_set_uint64 (dict, key, 0); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, - NFS_MSG_WRITE_FAIL, - "Error writing bytes read to dict"); - goto out; - } - - snprintf (key, sizeof (key), "client%d.byteswrite", count); - ret = dict_set_uint64 (dict, key, 0); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, - NFS_MSG_WRITE_FAIL, - "Error writing bytes write to dict"); - goto out; - } - - count++; + snprintf(key, sizeof(key), "client%d.byteswrite", count); + ret = dict_set_uint64(dict, key, 0); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, NFS_MSG_WRITE_FAIL, + "Error writing bytes write to dict"); + goto out; } - ret = dict_set_int32 (dict, "clientcount", count); - if (ret) - gf_msg (this->name, GF_LOG_ERROR, 0, NFS_MSG_WRITE_FAIL, - "Error writing client count to dict"); + count++; + } + + ret = dict_set_int32(dict, "clientcount", count); + if (ret) + gf_msg(this->name, GF_LOG_ERROR, 0, NFS_MSG_WRITE_FAIL, + "Error writing client count to dict"); out: - gf_msg_debug (THIS->name, 0, "Returning %d", ret); - return ret; + gf_msg_debug(THIS->name, 0, "Returning %d", ret); + return ret; } extern int32_t -nlm_priv (xlator_t *this); +nlm_priv(xlator_t *this); int32_t -nfs_priv (xlator_t *this) +nfs_priv(xlator_t *this) { - int32_t ret = -1; - - /* DRC needs the global drc structure, xl is of no use to it. */ - ret = rpcsvc_drc_priv (((struct nfs_state *)(this->private))->rpcsvc->drc); - if (ret) { - gf_msg_debug (this->name, 0, "Statedump of DRC failed"); - goto out; - } - - ret = nlm_priv (this); - if (ret) { - gf_msg_debug (this->name, 0, "Statedump of NLM failed"); - goto out; - } - out: - return ret; + int32_t ret = -1; + + /* DRC needs the global drc structure, xl is of no use to it. */ + ret = rpcsvc_drc_priv(((struct nfs_state *)(this->private))->rpcsvc->drc); + if (ret) { + gf_msg_debug(this->name, 0, "Statedump of DRC failed"); + goto out; + } + + ret = nlm_priv(this); + if (ret) { + gf_msg_debug(this->name, 0, "Statedump of NLM failed"); + goto out; + } +out: + return ret; } - struct xlator_cbks cbks = { - .forget = nfs_forget, + .forget = nfs_forget, }; struct xlator_fops fops; struct xlator_dumpops dumpops = { - .priv = nfs_priv, - .priv_to_dict = nfs_priv_to_dict, + .priv = nfs_priv, + .priv_to_dict = nfs_priv_to_dict, }; /* TODO: If needed, per-volume options below can be extended to be export * specific also because after export-dir is introduced, a volume is not * necessarily an export whereas different subdirectories within that volume * can be and may need these options to be specified separately. -*/ + */ struct volume_options options[] = { - { .key = {"nfs3.read-size"}, - .type = GF_OPTION_TYPE_SIZET, - .min = GF_NFS3_RTMIN, - .max = GF_NFS3_RTMAX, - .default_value = TOSTRING(GF_NFS3_RTPREF), - .description = "Size in which the client should issue read requests " - "to the Gluster NFSv3 server. Must be a multiple of " - "4KB (4096). Min and Max supported values are 4KB " - "(4096) and 1MB (1048576) respectively. If the " - "specified value is within the supported range but " - "not a multiple of 4096, it is rounded up to the " - "nearest multiple of 4096." - }, - { .key = {"nfs3.write-size"}, - .type = GF_OPTION_TYPE_SIZET, - .min = GF_NFS3_WTMIN, - .max = GF_NFS3_WTMAX, - .default_value = TOSTRING(GF_NFS3_WTPREF), - .description = "Size in which the client should issue write requests " - "to the Gluster NFSv3 server. Must be a multiple of " - "1KB (1024). Min and Max supported values are " - "4KB (4096) and 1MB(1048576) respectively. If the " - "specified value is within the supported range but " - "not a multiple of 4096, it is rounded up to the " - "nearest multiple of 4096." - }, - { .key = {"nfs3.readdir-size"}, - .type = GF_OPTION_TYPE_SIZET, - .min = GF_NFS3_DTMIN, - .max = GF_NFS3_DTMAX, - .default_value = TOSTRING(GF_NFS3_DTPREF), - .description = "Size in which the client should issue directory " - "reading requests to the Gluster NFSv3 server. Must " - "be a multiple of 1KB (1024). Min and Max supported " - "values are 4KB (4096) and 1MB (1048576) respectively." - "If the specified value is within the supported range " - "but not a multiple of 4096, it is rounded up to the " - "nearest multiple of 4096." - }, - { .key = {"nfs3.*.volume-access"}, - .type = GF_OPTION_TYPE_STR, - .value = {"read-only", "read-write"}, - .default_value = "read-write", - .description = "Type of access desired for this subvolume: " - " read-only, read-write(default)" - }, - { .key = {"nfs3.*.trusted-write"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "off", - .description = "On an UNSTABLE write from client, return STABLE flag" - " to force client to not send a COMMIT request. In " - "some environments, combined with a replicated " - "GlusterFS setup, this option can improve write " - "performance. This flag allows user to trust Gluster" - " replication logic to sync data to the disks and " - "recover when required. COMMIT requests if received " - "will be handled in a default manner by fsyncing." - " STABLE writes are still handled in a sync manner. " - "Off by default." - - }, - { .key = {"nfs3.*.trusted-sync"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "off", - .description = "All writes and COMMIT requests are treated as async." - " This implies that no write requests are guaranteed" - " to be on server disks when the write reply is " - "received at the NFS client. Trusted sync includes " - " trusted-write behaviour. Off by default." - - }, - { .key = {"nfs3.*.export-dir"}, - .type = GF_OPTION_TYPE_PATH, - .default_value = "", - .description = "By default, all subvolumes of nfs are exported as " - "individual exports. There are cases where a " - "subdirectory or subdirectories in the volume need to " - "be exported separately. This option can also be used " - "in conjunction with nfs3.export-volumes option to " - "restrict exports only to the subdirectories specified" - " through this option. Must be an absolute path. Along" - " with path allowed list of IPs/hostname can be " - "associated with each subdirectory. If provided " - "connection will allowed only from these IPs. By " - "default connections from all IPs are allowed. " - "Format: <dir>[(hostspec[|hostspec|...])][,...]. Where" - " hostspec can be an IP address, hostname or an IP " - "range in CIDR notation. " - "e.g. /foo(192.168.1.0/24|host1|10.1.1.8),/host2." - " NOTE: Care must be taken while configuring this " - "option as invalid entries and/or unreachable DNS " - "servers can introduce unwanted delay in all the mount" - " calls." - }, - { .key = {"nfs3.export-dirs"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "on", - .description = "By default, all subvolumes of nfs are exported as " - "individual exports. There are cases where a " - "subdirectory or subdirectories in the volume need to " - "be exported separately. Enabling this option allows " - "any directory on a volumes to be exported separately." - "Directory exports are enabled by default." - }, - { .key = {"nfs3.export-volumes"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "on", - .description = "Enable or disable exporting whole volumes, instead " - "if used in conjunction with nfs3.export-dir, can " - "allow setting up only subdirectories as exports. On " - "by default." - }, - { .key = {"rpc-auth.auth-unix"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "on", - .description = "Disable or enable the AUTH_UNIX authentication type." - "Must always be enabled for better interoperability. " - "However, can be disabled if needed. Enabled by " - "default" - }, - { .key = {"rpc-auth.auth-null"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "on", - .description = "Disable or enable the AUTH_NULL authentication type." - "Must always be enabled. This option is here only to" - " avoid unrecognized option warnings" - }, - { .key = {"rpc-auth.auth-unix.*"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "on", - .description = "Disable or enable the AUTH_UNIX authentication type " - "for a particular exported volume overriding defaults" - " and general setting for AUTH_UNIX scheme. Must " - "always be enabled for better interoperability. " - "However, can be disabled if needed. Enabled by " - "default." - }, - { .key = {"rpc-auth.auth-unix.*.allow"}, - .type = GF_OPTION_TYPE_STR, - .default_value = "on", - .description = "Disable or enable the AUTH_UNIX authentication type " - "for a particular exported volume overriding defaults" - " and general setting for AUTH_UNIX scheme. Must " - "always be enabled for better interoperability. " - "However, can be disabled if needed. Enabled by " - "default." - }, - { .key = {"rpc-auth.auth-null.*"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "on", - .description = "Disable or enable the AUTH_NULL authentication type " - "for a particular exported volume overriding defaults" - " and general setting for AUTH_NULL. Must always be " - "enabled. This option is here only to avoid " - "unrecognized option warnings." - }, - { .key = {"rpc-auth.addr.allow"}, - .type = GF_OPTION_TYPE_CLIENT_AUTH_ADDR, - .default_value = "all", - .description = "Allow a comma separated list of addresses and/or" - " hostnames to connect to the server. By default, all" - " connections are allowed. This allows users to " - "define a general rule for all exported volumes." - }, - { .key = {"rpc-auth.addr.reject"}, - .type = GF_OPTION_TYPE_CLIENT_AUTH_ADDR, - .default_value = "none", - .description = "Reject a comma separated list of addresses and/or" - " hostnames from connecting to the server. By default," - " all connections are allowed. This allows users to " - "define a general rule for all exported volumes." - }, - { .key = {"rpc-auth.addr.*.allow"}, - .type = GF_OPTION_TYPE_CLIENT_AUTH_ADDR, - .default_value = "all", - .description = "Allow a comma separated list of addresses and/or" - " hostnames to connect to the server. By default, all" - " connections are allowed. This allows users to " - "define a rule for a specific exported volume." - }, - { .key = {"rpc-auth.addr.*.reject"}, - .type = GF_OPTION_TYPE_CLIENT_AUTH_ADDR, - .default_value = "none", - .description = "Reject a comma separated list of addresses and/or" - " hostnames from connecting to the server. By default," - " all connections are allowed. This allows users to " - "define a rule for a specific exported volume." - }, - { .key = {"rpc-auth.ports.insecure"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "off", - .description = "Allow client connections from unprivileged ports. By " - "default only privileged ports are allowed. This is a" - "global setting in case insecure ports are to be " - "enabled for all exports using a single option." - }, - { .key = {"rpc-auth.ports.*.insecure"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "off", - .description = "Allow client connections from unprivileged ports. By " - "default only privileged ports are allowed. Use this" - " option to enable or disable insecure ports for " - "a specific subvolume and to override the global " - "setting set by the previous option." - }, - { .key = {"rpc-auth.addr.namelookup"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "off", - .description = "Users have the option of turning on name lookup for" - " incoming client connections using this option. Use this " - "option to turn on name lookups during address-based " - "authentication. Turning this on will enable you to" - " use hostnames in nfs.rpc-auth-* filters. In some " - "setups, the name server can take too long to reply to DNS " - "queries resulting in timeouts of mount requests. By " - "default, name lookup is off" - }, - { .key = {"nfs.dynamic-volumes"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "off", - .description = "Internal option set to tell gnfs to use a different" - " scheme for encoding file handles when DVM is being" - " used." - }, - { .key = {"nfs3.*.volume-id"}, - .type = GF_OPTION_TYPE_STR, - .default_value = "", - .description = "When nfs.dynamic-volumes is set, gnfs expects every " - "subvolume to have this option set for it, so that " - "gnfs can use this option to identify the volume. " - "If all subvolumes do not have this option set, an " - "error is reported." - }, - { .key = {"nfs.enable-ino32"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "no", - .description = "For nfs clients or apps that do not support 64-bit " - "inode numbers, use this option to make NFS return " - "32-bit inode numbers instead. Disabled by default, so" - " NFS returns 64-bit inode numbers." - }, - { .key = {"rpc.register-with-portmap"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "on", - .description = "For systems that need to run multiple nfs servers, " - "only one registration is possible with " - "portmap service. Use this option to turn off portmap " - "registration for Gluster NFS. On by default" - }, - { .key = {"rpc.outstanding-rpc-limit"}, - .type = GF_OPTION_TYPE_INT, - .min = RPCSVC_MIN_OUTSTANDING_RPC_LIMIT, - .max = RPCSVC_MAX_OUTSTANDING_RPC_LIMIT, - .default_value = TOSTRING(RPCSVC_DEF_NFS_OUTSTANDING_RPC_LIMIT), - .description = "Parameter to throttle the number of incoming RPC " - "requests from a client. 0 means no limit (can " - "potentially run out of memory)" - }, - { .key = {"nfs.port"}, - .type = GF_OPTION_TYPE_INT, - .min = 1, - .max = 0xffff, - .default_value = TOSTRING(GF_NFS3_PORT), - .description = "Use this option on systems that need Gluster NFS to " - "be associated with a non-default port number." - }, - { .key = {"nfs.mem-factor"}, - .type = GF_OPTION_TYPE_INT, - .min = 1, - .max = 1024, - .default_value = TOSTRING(GF_NFS_DEFAULT_MEMFACTOR), - .description = "Use this option to make NFS be faster on systems by " - "using more memory. This option specifies a multiple " - "that determines the total amount of memory used. " - "Default value is 15. Increase to use more memory in " - "order to improve performance for certain use cases." - "Please consult gluster-users list before using this " - "option." - }, - { .key = {"nfs.*.disable"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "false", - .description = "This option is used to start or stop the NFS server " - "for individual volumes." - }, - { .key = {"nfs.nlm"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "on", - .description = "This option, if set to 'off', disables NLM server " - "by not registering the service with the portmapper." - " Set it to 'on' to re-enable it. Default value: 'on'" - }, - - { .key = {"nfs.mount-udp"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "off", - .description = "set the option to 'on' to enable mountd on UDP. " - "Required for some Solaris and AIX NFS clients. " - "The need for enabling this option often depends " - "on the usage of NLM." - }, - { .key = {"nfs.mount-rmtab"}, - .type = GF_OPTION_TYPE_PATH, - .default_value = NFS_DATADIR "/rmtab", - .description = "Set the location of the cache file that is used to " - "list all the NFS-clients that have connected " - "through the MOUNT protocol. If this is on shared " - "storage, all GlusterFS servers will update and " - "output (with 'showmount') the same list. Set to " - "\"/-\" to disable." - }, - { .key = {OPT_SERVER_RPC_STATD}, - .type = GF_OPTION_TYPE_PATH, - .default_value = GF_RPC_STATD_PROG, - .description = "The executable of RPC statd utility. " - "Defaults to " GF_RPC_STATD_PROG - }, - { .key = {OPT_SERVER_RPC_STATD_PIDFILE}, - .type = GF_OPTION_TYPE_PATH, - .default_value = GF_RPC_STATD_PIDFILE, - .description = "The pid file of RPC statd utility. " - "Defaults to " GF_RPC_STATD_PIDFILE - }, - { .key = {OPT_SERVER_AUX_GIDS}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "off", - .description = "Let the server look up which groups a user belongs " - "to, overwriting the list passed from the client. " - "This enables support for group lists longer than " - "can be passed through the NFS protocol, but is not " - "secure unless users and groups are well synchronized " - "between clients and servers." - }, - { .key = {OPT_SERVER_GID_CACHE_TIMEOUT}, - .type = GF_OPTION_TYPE_INT, - .min = 0, - .max = 3600, - .default_value = "300", - .description = "Number of seconds to cache auxiliary-GID data, when " - OPT_SERVER_AUX_GIDS " is set." - }, - { .key = {"nfs.acl"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "on", - .description = "This option is used to control ACL support for NFS." - }, - { .key = {"nfs.drc"}, - .type = GF_OPTION_TYPE_STR, - .default_value = "off", - .description = "Enable Duplicate Request Cache in gNFS server to " - "improve correctness of non-idempotent operations like " - "write, delete, link, et al" - }, - { .key = {"nfs.drc-size"}, - .type = GF_OPTION_TYPE_INT, - .default_value = "0x20000", - .description = "Sets the number of non-idempotent " - "requests to cache in drc" - }, - { .key = {"nfs.exports-auth-enable"}, - .type = GF_OPTION_TYPE_BOOL, - .description = "Set the option to 'on' to enable exports/netgroup " - "authentication in the NFS server and mount daemon." - }, - - { .key = {"nfs.auth-refresh-interval-sec"}, - .type = GF_OPTION_TYPE_INT, - .description = "Frequency in seconds that the daemon should check for" - " changes in the exports/netgroups file." - }, - - { .key = {"nfs.auth-cache-ttl-sec"}, - .type = GF_OPTION_TYPE_INT, - .description = "Sets the TTL of an entry in the auth cache. Value is " - "in seconds." - }, - { .key = {"nfs.rdirplus"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "on", - .description = "When this option is set to off NFS falls back to " - "standard readdir instead of readdirp" - }, - { .key = {"nfs.event-threads"}, - .type = GF_OPTION_TYPE_SIZET, - .min = 1, - .max = 32, - .default_value = "1", - .description = "Specifies the number of event threads to execute in" - "in parallel. Larger values would help process" - " responses faster, depending on available processing" - " power. Range 1-32 threads.", - .op_version = {GD_OP_VERSION_4_0_0}, - .flags = OPT_FLAG_SETTABLE, - }, - { .key = {NULL} }, + {.key = {"nfs3.read-size"}, + .type = GF_OPTION_TYPE_SIZET, + .min = GF_NFS3_RTMIN, + .max = GF_NFS3_RTMAX, + .default_value = TOSTRING(GF_NFS3_RTPREF), + .description = "Size in which the client should issue read requests " + "to the Gluster NFSv3 server. Must be a multiple of " + "4KB (4096). Min and Max supported values are 4KB " + "(4096) and 1MB (1048576) respectively. If the " + "specified value is within the supported range but " + "not a multiple of 4096, it is rounded up to the " + "nearest multiple of 4096."}, + {.key = {"nfs3.write-size"}, + .type = GF_OPTION_TYPE_SIZET, + .min = GF_NFS3_WTMIN, + .max = GF_NFS3_WTMAX, + .default_value = TOSTRING(GF_NFS3_WTPREF), + .description = "Size in which the client should issue write requests " + "to the Gluster NFSv3 server. Must be a multiple of " + "1KB (1024). Min and Max supported values are " + "4KB (4096) and 1MB(1048576) respectively. If the " + "specified value is within the supported range but " + "not a multiple of 4096, it is rounded up to the " + "nearest multiple of 4096."}, + {.key = {"nfs3.readdir-size"}, + .type = GF_OPTION_TYPE_SIZET, + .min = GF_NFS3_DTMIN, + .max = GF_NFS3_DTMAX, + .default_value = TOSTRING(GF_NFS3_DTPREF), + .description = "Size in which the client should issue directory " + "reading requests to the Gluster NFSv3 server. Must " + "be a multiple of 1KB (1024). Min and Max supported " + "values are 4KB (4096) and 1MB (1048576) respectively." + "If the specified value is within the supported range " + "but not a multiple of 4096, it is rounded up to the " + "nearest multiple of 4096."}, + {.key = {"nfs3.*.volume-access"}, + .type = GF_OPTION_TYPE_STR, + .value = {"read-only", "read-write"}, + .default_value = "read-write", + .description = "Type of access desired for this subvolume: " + " read-only, read-write(default)"}, + {.key = {"nfs3.*.trusted-write"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + .description = "On an UNSTABLE write from client, return STABLE flag" + " to force client to not send a COMMIT request. In " + "some environments, combined with a replicated " + "GlusterFS setup, this option can improve write " + "performance. This flag allows user to trust Gluster" + " replication logic to sync data to the disks and " + "recover when required. COMMIT requests if received " + "will be handled in a default manner by fsyncing." + " STABLE writes are still handled in a sync manner. " + "Off by default." + + }, + {.key = {"nfs3.*.trusted-sync"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + .description = "All writes and COMMIT requests are treated as async." + " This implies that no write requests are guaranteed" + " to be on server disks when the write reply is " + "received at the NFS client. Trusted sync includes " + " trusted-write behaviour. Off by default." + + }, + {.key = {"nfs3.*.export-dir"}, + .type = GF_OPTION_TYPE_PATH, + .default_value = "", + .description = "By default, all subvolumes of nfs are exported as " + "individual exports. There are cases where a " + "subdirectory or subdirectories in the volume need to " + "be exported separately. This option can also be used " + "in conjunction with nfs3.export-volumes option to " + "restrict exports only to the subdirectories specified" + " through this option. Must be an absolute path. Along" + " with path allowed list of IPs/hostname can be " + "associated with each subdirectory. If provided " + "connection will allowed only from these IPs. By " + "default connections from all IPs are allowed. " + "Format: <dir>[(hostspec[|hostspec|...])][,...]. Where" + " hostspec can be an IP address, hostname or an IP " + "range in CIDR notation. " + "e.g. /foo(192.168.1.0/24|host1|10.1.1.8),/host2." + " NOTE: Care must be taken while configuring this " + "option as invalid entries and/or unreachable DNS " + "servers can introduce unwanted delay in all the mount" + " calls."}, + {.key = {"nfs3.export-dirs"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "on", + .description = "By default, all subvolumes of nfs are exported as " + "individual exports. There are cases where a " + "subdirectory or subdirectories in the volume need to " + "be exported separately. Enabling this option allows " + "any directory on a volumes to be exported separately." + "Directory exports are enabled by default."}, + {.key = {"nfs3.export-volumes"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "on", + .description = "Enable or disable exporting whole volumes, instead " + "if used in conjunction with nfs3.export-dir, can " + "allow setting up only subdirectories as exports. On " + "by default."}, + {.key = {"rpc-auth.auth-unix"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "on", + .description = "Disable or enable the AUTH_UNIX authentication type." + "Must always be enabled for better interoperability. " + "However, can be disabled if needed. Enabled by " + "default"}, + {.key = {"rpc-auth.auth-null"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "on", + .description = "Disable or enable the AUTH_NULL authentication type." + "Must always be enabled. This option is here only to" + " avoid unrecognized option warnings"}, + {.key = {"rpc-auth.auth-unix.*"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "on", + .description = "Disable or enable the AUTH_UNIX authentication type " + "for a particular exported volume overriding defaults" + " and general setting for AUTH_UNIX scheme. Must " + "always be enabled for better interoperability. " + "However, can be disabled if needed. Enabled by " + "default."}, + {.key = {"rpc-auth.auth-unix.*.allow"}, + .type = GF_OPTION_TYPE_STR, + .default_value = "on", + .description = "Disable or enable the AUTH_UNIX authentication type " + "for a particular exported volume overriding defaults" + " and general setting for AUTH_UNIX scheme. Must " + "always be enabled for better interoperability. " + "However, can be disabled if needed. Enabled by " + "default."}, + {.key = {"rpc-auth.auth-null.*"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "on", + .description = "Disable or enable the AUTH_NULL authentication type " + "for a particular exported volume overriding defaults" + " and general setting for AUTH_NULL. Must always be " + "enabled. This option is here only to avoid " + "unrecognized option warnings."}, + {.key = {"rpc-auth.addr.allow"}, + .type = GF_OPTION_TYPE_CLIENT_AUTH_ADDR, + .default_value = "all", + .description = "Allow a comma separated list of addresses and/or" + " hostnames to connect to the server. By default, all" + " connections are allowed. This allows users to " + "define a general rule for all exported volumes."}, + {.key = {"rpc-auth.addr.reject"}, + .type = GF_OPTION_TYPE_CLIENT_AUTH_ADDR, + .default_value = "none", + .description = "Reject a comma separated list of addresses and/or" + " hostnames from connecting to the server. By default," + " all connections are allowed. This allows users to " + "define a general rule for all exported volumes."}, + {.key = {"rpc-auth.addr.*.allow"}, + .type = GF_OPTION_TYPE_CLIENT_AUTH_ADDR, + .default_value = "all", + .description = "Allow a comma separated list of addresses and/or" + " hostnames to connect to the server. By default, all" + " connections are allowed. This allows users to " + "define a rule for a specific exported volume."}, + {.key = {"rpc-auth.addr.*.reject"}, + .type = GF_OPTION_TYPE_CLIENT_AUTH_ADDR, + .default_value = "none", + .description = "Reject a comma separated list of addresses and/or" + " hostnames from connecting to the server. By default," + " all connections are allowed. This allows users to " + "define a rule for a specific exported volume."}, + {.key = {"rpc-auth.ports.insecure"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + .description = "Allow client connections from unprivileged ports. By " + "default only privileged ports are allowed. This is a" + "global setting in case insecure ports are to be " + "enabled for all exports using a single option."}, + {.key = {"rpc-auth.ports.*.insecure"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + .description = "Allow client connections from unprivileged ports. By " + "default only privileged ports are allowed. Use this" + " option to enable or disable insecure ports for " + "a specific subvolume and to override the global " + "setting set by the previous option."}, + {.key = {"rpc-auth.addr.namelookup"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + .description = "Users have the option of turning on name lookup for" + " incoming client connections using this option. Use this " + "option to turn on name lookups during address-based " + "authentication. Turning this on will enable you to" + " use hostnames in nfs.rpc-auth-* filters. In some " + "setups, the name server can take too long to reply to DNS " + "queries resulting in timeouts of mount requests. By " + "default, name lookup is off"}, + {.key = {"nfs.dynamic-volumes"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + .description = "Internal option set to tell gnfs to use a different" + " scheme for encoding file handles when DVM is being" + " used."}, + {.key = {"nfs3.*.volume-id"}, + .type = GF_OPTION_TYPE_STR, + .default_value = "", + .description = "When nfs.dynamic-volumes is set, gnfs expects every " + "subvolume to have this option set for it, so that " + "gnfs can use this option to identify the volume. " + "If all subvolumes do not have this option set, an " + "error is reported."}, + {.key = {"nfs.enable-ino32"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "no", + .description = "For nfs clients or apps that do not support 64-bit " + "inode numbers, use this option to make NFS return " + "32-bit inode numbers instead. Disabled by default, so" + " NFS returns 64-bit inode numbers."}, + {.key = {"rpc.register-with-portmap"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "on", + .description = "For systems that need to run multiple nfs servers, " + "only one registration is possible with " + "portmap service. Use this option to turn off portmap " + "registration for Gluster NFS. On by default"}, + {.key = {"rpc.outstanding-rpc-limit"}, + .type = GF_OPTION_TYPE_INT, + .min = RPCSVC_MIN_OUTSTANDING_RPC_LIMIT, + .max = RPCSVC_MAX_OUTSTANDING_RPC_LIMIT, + .default_value = TOSTRING(RPCSVC_DEF_NFS_OUTSTANDING_RPC_LIMIT), + .description = "Parameter to throttle the number of incoming RPC " + "requests from a client. 0 means no limit (can " + "potentially run out of memory)"}, + {.key = {"nfs.port"}, + .type = GF_OPTION_TYPE_INT, + .min = 1, + .max = 0xffff, + .default_value = TOSTRING(GF_NFS3_PORT), + .description = "Use this option on systems that need Gluster NFS to " + "be associated with a non-default port number."}, + {.key = {"nfs.mem-factor"}, + .type = GF_OPTION_TYPE_INT, + .min = 1, + .max = 1024, + .default_value = TOSTRING(GF_NFS_DEFAULT_MEMFACTOR), + .description = "Use this option to make NFS be faster on systems by " + "using more memory. This option specifies a multiple " + "that determines the total amount of memory used. " + "Default value is 15. Increase to use more memory in " + "order to improve performance for certain use cases." + "Please consult gluster-users list before using this " + "option."}, + {.key = {"nfs.*.disable"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "false", + .description = "This option is used to start or stop the NFS server " + "for individual volumes."}, + {.key = {"nfs.nlm"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "on", + .description = "This option, if set to 'off', disables NLM server " + "by not registering the service with the portmapper." + " Set it to 'on' to re-enable it. Default value: 'on'"}, + + {.key = {"nfs.mount-udp"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + .description = "set the option to 'on' to enable mountd on UDP. " + "Required for some Solaris and AIX NFS clients. " + "The need for enabling this option often depends " + "on the usage of NLM."}, + {.key = {"nfs.mount-rmtab"}, + .type = GF_OPTION_TYPE_PATH, + .default_value = NFS_DATADIR "/rmtab", + .description = "Set the location of the cache file that is used to " + "list all the NFS-clients that have connected " + "through the MOUNT protocol. If this is on shared " + "storage, all GlusterFS servers will update and " + "output (with 'showmount') the same list. Set to " + "\"/-\" to disable."}, + {.key = {OPT_SERVER_RPC_STATD}, + .type = GF_OPTION_TYPE_PATH, + .default_value = GF_RPC_STATD_PROG, + .description = "The executable of RPC statd utility. " + "Defaults to " GF_RPC_STATD_PROG}, + {.key = {OPT_SERVER_RPC_STATD_PIDFILE}, + .type = GF_OPTION_TYPE_PATH, + .default_value = GF_RPC_STATD_PIDFILE, + .description = "The pid file of RPC statd utility. " + "Defaults to " GF_RPC_STATD_PIDFILE}, + {.key = {OPT_SERVER_AUX_GIDS}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + .description = "Let the server look up which groups a user belongs " + "to, overwriting the list passed from the client. " + "This enables support for group lists longer than " + "can be passed through the NFS protocol, but is not " + "secure unless users and groups are well synchronized " + "between clients and servers."}, + {.key = {OPT_SERVER_GID_CACHE_TIMEOUT}, + .type = GF_OPTION_TYPE_INT, + .min = 0, + .max = 3600, + .default_value = "300", + .description = "Number of seconds to cache auxiliary-GID data, " + "when " OPT_SERVER_AUX_GIDS " is set."}, + {.key = {"nfs.acl"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "on", + .description = "This option is used to control ACL support for NFS."}, + {.key = {"nfs.drc"}, + .type = GF_OPTION_TYPE_STR, + .default_value = "off", + .description = "Enable Duplicate Request Cache in gNFS server to " + "improve correctness of non-idempotent operations like " + "write, delete, link, et al"}, + {.key = {"nfs.drc-size"}, + .type = GF_OPTION_TYPE_INT, + .default_value = "0x20000", + .description = "Sets the number of non-idempotent " + "requests to cache in drc"}, + {.key = {"nfs.exports-auth-enable"}, + .type = GF_OPTION_TYPE_BOOL, + .description = "Set the option to 'on' to enable exports/netgroup " + "authentication in the NFS server and mount daemon."}, + + {.key = {"nfs.auth-refresh-interval-sec"}, + .type = GF_OPTION_TYPE_INT, + .description = "Frequency in seconds that the daemon should check for" + " changes in the exports/netgroups file."}, + + {.key = {"nfs.auth-cache-ttl-sec"}, + .type = GF_OPTION_TYPE_INT, + .description = "Sets the TTL of an entry in the auth cache. Value is " + "in seconds."}, + {.key = {"nfs.rdirplus"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "on", + .description = "When this option is set to off NFS falls back to " + "standard readdir instead of readdirp"}, + { + .key = {"nfs.event-threads"}, + .type = GF_OPTION_TYPE_SIZET, + .min = 1, + .max = 32, + .default_value = "1", + .description = "Specifies the number of event threads to execute in" + "in parallel. Larger values would help process" + " responses faster, depending on available processing" + " power. Range 1-32 threads.", + .op_version = {GD_OP_VERSION_4_0_0}, + .flags = OPT_FLAG_SETTABLE, + }, + {.key = {NULL}}, }; diff --git a/xlators/nfs/server/src/nfs3-fh.c b/xlators/nfs/server/src/nfs3-fh.c index 3feeae39da..c63f9328f5 100644 --- a/xlators/nfs/server/src/nfs3-fh.c +++ b/xlators/nfs/server/src/nfs3-fh.c @@ -20,167 +20,167 @@ #include "common-utils.h" #include "nfs-messages.h" - int -nfs3_fh_validate (struct nfs3_fh *fh) +nfs3_fh_validate(struct nfs3_fh *fh) { - if (!fh) - return 0; + if (!fh) + return 0; - if (fh->ident[0] != GF_NFSFH_IDENT0) - return 0; + if (fh->ident[0] != GF_NFSFH_IDENT0) + return 0; - if (fh->ident[1] != GF_NFSFH_IDENT1) - return 0; + if (fh->ident[1] != GF_NFSFH_IDENT1) + return 0; - if (fh->ident[2] != GF_NFSFH_IDENT2) - return 0; + if (fh->ident[2] != GF_NFSFH_IDENT2) + return 0; - if (fh->ident[3] != GF_NFSFH_IDENT3) - return 0; + if (fh->ident[3] != GF_NFSFH_IDENT3) + return 0; - return 1; + return 1; } - void -nfs3_fh_init (struct nfs3_fh *fh, struct iatt *buf) +nfs3_fh_init(struct nfs3_fh *fh, struct iatt *buf) { - if ((!fh) || (!buf)) - return; + 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; + 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); + gf_uuid_copy(fh->gfid, buf->ia_gfid); } - struct nfs3_fh -nfs3_fh_build_indexed_root_fh (xlator_list_t *cl, xlator_t *xl) +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; + 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); + gf_uuid_copy(buf.ia_gfid, root); + nfs3_fh_init(&fh, &buf); + fh.exportid[15] = nfs_xlator_to_xlid(cl, xl); - return fh; + return fh; } - struct nfs3_fh -nfs3_fh_build_uuid_root_fh (uuid_t volumeid, uuid_t mountid) +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; + 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_fh_is_root_fh (struct nfs3_fh *fh) +nfs3_fh_is_root_fh(struct nfs3_fh *fh) { - uuid_t rootgfid = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}; + uuid_t rootgfid = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}; - if (!fh) - return 0; + if (!fh) + return 0; - if (gf_uuid_compare (fh->gfid, rootgfid) == 0) - return 1; + if (gf_uuid_compare(fh->gfid, rootgfid) == 0) + return 1; - return 0; + return 0; } - void -nfs3_fh_to_str (struct nfs3_fh *fh, char *str, size_t len) +nfs3_fh_to_str(struct nfs3_fh *fh, char *str, size_t len) { - char gfid[GF_UUID_BUF_SIZE]; - char exportid[GF_UUID_BUF_SIZE]; - char mountid[GF_UUID_BUF_SIZE]; + char gfid[GF_UUID_BUF_SIZE]; + char exportid[GF_UUID_BUF_SIZE]; + char mountid[GF_UUID_BUF_SIZE]; - if ((!fh) || (!str)) - return; + if ((!fh) || (!str)) + return; - snprintf (str, len, "FH: exportid %s, gfid %s, mountid %s", - uuid_utoa_r (fh->exportid, exportid), - uuid_utoa_r (fh->gfid, gfid), - uuid_utoa_r (fh->mountid, mountid)); + snprintf(str, len, "FH: exportid %s, gfid %s, mountid %s", + uuid_utoa_r(fh->exportid, exportid), uuid_utoa_r(fh->gfid, gfid), + uuid_utoa_r(fh->mountid, mountid)); } void -nfs3_log_fh (struct nfs3_fh *fh) +nfs3_log_fh(struct nfs3_fh *fh) { - char gfidstr[512]; - char exportidstr[512]; + char gfidstr[512]; + char exportidstr[512]; - if (!fh) - return; + if (!fh) + return; - gf_msg_trace ("nfs3-fh", 0, "filehandle: exportid 0x%s, gfid 0x%s", - uuid_utoa_r (fh->exportid, exportidstr), - uuid_utoa_r (fh->gfid, gfidstr)); + gf_msg_trace("nfs3-fh", 0, "filehandle: exportid 0x%s, gfid 0x%s", + uuid_utoa_r(fh->exportid, exportidstr), + uuid_utoa_r(fh->gfid, gfidstr)); } int -nfs3_fh_build_parent_fh (struct nfs3_fh *child, struct iatt *newstat, - struct nfs3_fh *newfh) +nfs3_fh_build_parent_fh(struct nfs3_fh *child, struct iatt *newstat, + struct nfs3_fh *newfh) { - if ((!child) || (!newstat) || (!newfh)) - return -1; + if ((!child) || (!newstat) || (!newfh)) + return -1; - nfs3_fh_init (newfh, newstat); - gf_uuid_copy (newfh->exportid, child->exportid); - return 0; + nfs3_fh_init(newfh, newstat); + gf_uuid_copy(newfh->exportid, child->exportid); + return 0; } int -nfs3_build_fh (inode_t *inode, uuid_t exportid, struct nfs3_fh *newfh) +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; + 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; } int -nfs3_fh_build_child_fh (struct nfs3_fh *parent, struct iatt *newstat, - struct nfs3_fh *newfh) +nfs3_fh_build_child_fh(struct nfs3_fh *parent, struct iatt *newstat, + struct nfs3_fh *newfh) { - if ((!parent) || (!newstat) || (!newfh)) - return -1; + 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; + nfs3_fh_init(newfh, newstat); + gf_uuid_copy(newfh->exportid, parent->exportid); + gf_uuid_copy(newfh->mountid, parent->mountid); + return 0; } - uint32_t -nfs3_fh_compute_size () +nfs3_fh_compute_size() { - return GF_NFSFH_STATIC_SIZE; + return GF_NFSFH_STATIC_SIZE; } diff --git a/xlators/nfs/server/src/nfs3-helpers.c b/xlators/nfs/server/src/nfs3-helpers.c index 27edf471db..7fa278fdc2 100644 --- a/xlators/nfs/server/src/nfs3-helpers.c +++ b/xlators/nfs/server/src/nfs3-helpers.c @@ -27,231 +27,222 @@ #include <string.h> extern int -nfs3_set_root_looked_up (struct nfs3_state *nfs3, struct nfs3_fh *rootfh); +nfs3_set_root_looked_up(struct nfs3_state *nfs3, struct nfs3_fh *rootfh); extern int -nfs3_is_root_looked_up (struct nfs3_state *nfs3, struct nfs3_fh *rootfh); +nfs3_is_root_looked_up(struct nfs3_state *nfs3, struct nfs3_fh *rootfh); +#define nfs3_call_resume(cst) \ + do { \ + if (((cst)) && (cst)->resume_fn) \ + (cst)->resume_fn(cst); \ + } while (0) -#define nfs3_call_resume(cst) \ - do { \ - if (((cst)) && (cst)->resume_fn) \ - (cst)->resume_fn (cst); \ - } while (0) \ - -#define nfs3_call_resume_estale(csta) \ - do { \ - (csta)->resolve_ret = -1; \ - (csta)->resolve_errno = ESTALE; \ - nfs3_call_resume (csta); \ - } while (0) \ +#define nfs3_call_resume_estale(csta) \ + do { \ + (csta)->resolve_ret = -1; \ + (csta)->resolve_errno = ESTALE; \ + nfs3_call_resume(csta); \ + } while (0) struct nfs3stat_strerror { - nfsstat3 stat; - char strerror[100]; + nfsstat3 stat; + char strerror[100]; }; - struct nfs3stat_strerror nfs3stat_strerror_table[] = { - { NFS3_OK, "Call completed successfully." }, - { NFS3ERR_PERM, "Not owner" }, - { NFS3ERR_NOENT, "No such file or directory" }, - { NFS3ERR_IO, "I/O error" }, - { NFS3ERR_NXIO, "I/O error" }, - { NFS3ERR_ACCES, "Permission denied" }, - { NFS3ERR_EXIST, "File exists" }, - { NFS3ERR_XDEV, "Attempt to do a cross-device hard link"}, - { NFS3ERR_NODEV, "No such device" }, - { NFS3ERR_NOTDIR, "Not a directory" }, - { NFS3ERR_ISDIR, "Is a directory" }, - { NFS3ERR_INVAL, "Invalid argument for operation" }, - { NFS3ERR_FBIG, "File too large" }, - { NFS3ERR_NOSPC, "No space left on device" }, - { NFS3ERR_ROFS, "Read-only file system" }, - { NFS3ERR_MLINK, "Too many hard links" }, - { NFS3ERR_NAMETOOLONG, "Filename in operation was too long" }, - { NFS3ERR_NOTEMPTY, "Directory not empty" }, - { NFS3ERR_DQUOT, "Resource (quota) hard limit exceeded" }, - { NFS3ERR_STALE, "Invalid file handle" }, - { NFS3ERR_REMOTE, "Too many levels of remote in path" }, - { NFS3ERR_BADHANDLE, "Illegal NFS file handle" }, - { NFS3ERR_NOT_SYNC, "Update synchronization mismatch detected" }, - { NFS3ERR_BAD_COOKIE, "READDIR or READDIRPLUS cookie is stale"}, - { NFS3ERR_NOTSUPP, "Operation is not supported" }, - { NFS3ERR_TOOSMALL, "Buffer or request is too small" }, - { NFS3ERR_SERVERFAULT, "Error occurred on the server or IO Error" }, - { NFS3ERR_BADTYPE, "Type not supported by the server" }, - { NFS3ERR_JUKEBOX, "Cannot complete server initiated request" }, - { NFS3ERR_END_OF_LIST, "IO Error" }, + {NFS3_OK, "Call completed successfully."}, + {NFS3ERR_PERM, "Not owner"}, + {NFS3ERR_NOENT, "No such file or directory"}, + {NFS3ERR_IO, "I/O error"}, + {NFS3ERR_NXIO, "I/O error"}, + {NFS3ERR_ACCES, "Permission denied"}, + {NFS3ERR_EXIST, "File exists"}, + {NFS3ERR_XDEV, "Attempt to do a cross-device hard link"}, + {NFS3ERR_NODEV, "No such device"}, + {NFS3ERR_NOTDIR, "Not a directory"}, + {NFS3ERR_ISDIR, "Is a directory"}, + {NFS3ERR_INVAL, "Invalid argument for operation"}, + {NFS3ERR_FBIG, "File too large"}, + {NFS3ERR_NOSPC, "No space left on device"}, + {NFS3ERR_ROFS, "Read-only file system"}, + {NFS3ERR_MLINK, "Too many hard links"}, + {NFS3ERR_NAMETOOLONG, "Filename in operation was too long"}, + {NFS3ERR_NOTEMPTY, "Directory not empty"}, + {NFS3ERR_DQUOT, "Resource (quota) hard limit exceeded"}, + {NFS3ERR_STALE, "Invalid file handle"}, + {NFS3ERR_REMOTE, "Too many levels of remote in path"}, + {NFS3ERR_BADHANDLE, "Illegal NFS file handle"}, + {NFS3ERR_NOT_SYNC, "Update synchronization mismatch detected"}, + {NFS3ERR_BAD_COOKIE, "READDIR or READDIRPLUS cookie is stale"}, + {NFS3ERR_NOTSUPP, "Operation is not supported"}, + {NFS3ERR_TOOSMALL, "Buffer or request is too small"}, + {NFS3ERR_SERVERFAULT, "Error occurred on the server or IO Error"}, + {NFS3ERR_BADTYPE, "Type not supported by the server"}, + {NFS3ERR_JUKEBOX, "Cannot complete server initiated request"}, + {NFS3ERR_END_OF_LIST, "IO Error"}, }; - uint64_t -nfs3_iatt_gfid_to_ino (struct iatt *buf) +nfs3_iatt_gfid_to_ino(struct iatt *buf) { - uint64_t ino = 0; + uint64_t ino = 0; - if (!buf) - return 0; + if (!buf) + return 0; - if (gf_nfs_enable_ino32()) { - ino = (uint32_t )nfs_hash_gfid (buf->ia_gfid); - goto hashout; - } + if (gf_nfs_enable_ino32()) { + ino = (uint32_t)nfs_hash_gfid(buf->ia_gfid); + goto hashout; + } - /* from posix its guaranteed to send unique ino */ - ino = buf->ia_ino; + /* from posix its guaranteed to send unique ino */ + ino = buf->ia_ino; hashout: - return ino; + return ino; } - void -nfs3_map_deviceid_to_statdev (struct iatt *ia, uint64_t deviceid) +nfs3_map_deviceid_to_statdev(struct iatt *ia, uint64_t deviceid) { - if (!ia) - return; + if (!ia) + return; - ia->ia_dev = deviceid; + ia->ia_dev = deviceid; } - struct nfs3_fh -nfs3_extract_nfs3_fh (nfs_fh3 fh) +nfs3_extract_nfs3_fh(nfs_fh3 fh) { - struct nfs3_fh gfh; + struct nfs3_fh gfh; - memcpy (&gfh, fh.data.data_val, fh.data.data_len); - return gfh; + memcpy(&gfh, fh.data.data_val, fh.data.data_len); + return gfh; } - struct nfs3_fh -nfs3_extract_lookup_fh (lookup3args *args) +nfs3_extract_lookup_fh(lookup3args *args) { - return nfs3_extract_nfs3_fh(args->what.dir); + return nfs3_extract_nfs3_fh(args->what.dir); } - char * -nfs3_extract_lookup_name (lookup3args *args) +nfs3_extract_lookup_name(lookup3args *args) { - return args->what.name; + return args->what.name; } - nfsstat3 -nfs3_errno_to_nfsstat3 (int errnum) +nfs3_errno_to_nfsstat3(int errnum) { - nfsstat3 stat = NFS3_OK; - - switch (errnum) { + nfsstat3 stat = NFS3_OK; + switch (errnum) { case 0: - stat = NFS3_OK; - break; + stat = NFS3_OK; + break; case EPERM: - stat = NFS3ERR_PERM; - break; + stat = NFS3ERR_PERM; + break; case ENOENT: - stat = NFS3ERR_NOENT; - break; + stat = NFS3ERR_NOENT; + break; case EACCES: - stat = NFS3ERR_ACCES; - break; + stat = NFS3ERR_ACCES; + break; case EEXIST: - stat = NFS3ERR_EXIST; - break; + stat = NFS3ERR_EXIST; + break; case EXDEV: - stat = NFS3ERR_XDEV; - break; + stat = NFS3ERR_XDEV; + break; case ENODEV: - stat = NFS3ERR_NODEV; - break; + stat = NFS3ERR_NODEV; + break; case EIO: - stat = NFS3ERR_IO; - break; + stat = NFS3ERR_IO; + break; case ENXIO: - stat = NFS3ERR_NXIO; - break; + stat = NFS3ERR_NXIO; + break; case ENOTDIR: - stat = NFS3ERR_NOTDIR; - break; + stat = NFS3ERR_NOTDIR; + break; case EISDIR: - stat = NFS3ERR_ISDIR; - break; + stat = NFS3ERR_ISDIR; + break; case EINVAL: - stat = NFS3ERR_INVAL; - break; + stat = NFS3ERR_INVAL; + break; case ENOSPC: - stat = NFS3ERR_NOSPC; - break; + stat = NFS3ERR_NOSPC; + break; case EROFS: - stat = NFS3ERR_ROFS; - break; + stat = NFS3ERR_ROFS; + break; case EFBIG: - stat = NFS3ERR_FBIG; - break; + stat = NFS3ERR_FBIG; + break; case EMLINK: - stat = NFS3ERR_MLINK; - break; + stat = NFS3ERR_MLINK; + break; case ENAMETOOLONG: - stat = NFS3ERR_NAMETOOLONG; - break; + stat = NFS3ERR_NAMETOOLONG; + break; case ENOTEMPTY: - stat = NFS3ERR_NOTEMPTY; - break; + stat = NFS3ERR_NOTEMPTY; + break; case EFAULT: - stat = NFS3ERR_SERVERFAULT; - break; + stat = NFS3ERR_SERVERFAULT; + break; case ENOTSUP: case ENOSYS: - stat = NFS3ERR_NOTSUPP; - break; + stat = NFS3ERR_NOTSUPP; + break; case EBADF: - stat = NFS3ERR_BADTYPE; - break; + stat = NFS3ERR_BADTYPE; + break; case ESTALE: - stat = NFS3ERR_STALE; - break; + stat = NFS3ERR_STALE; + break; case ENOTCONN: - stat = NFS3ERR_IO; - break; + stat = NFS3ERR_IO; + break; case EDQUOT: - stat = NFS3ERR_DQUOT; - break; + stat = NFS3ERR_DQUOT; + break; default: - stat = NFS3ERR_SERVERFAULT; - break; - } + stat = NFS3ERR_SERVERFAULT; + break; + } - return stat; + return stat; } /* @@ -260,3681 +251,3581 @@ nfs3_errno_to_nfsstat3 (int errnum) * happens by any means, then set NFS3 status to NFS3ERR_SERVERFAULT. */ nfsstat3 -nfs3_cbk_errno_status (int32_t op_ret, int32_t op_errno) +nfs3_cbk_errno_status(int32_t op_ret, int32_t op_errno) { - if ((op_ret == -1) && (op_errno == 0)) { - return NFS3ERR_SERVERFAULT; - } + if ((op_ret == -1) && (op_errno == 0)) { + return NFS3ERR_SERVERFAULT; + } - return nfs3_errno_to_nfsstat3 (op_errno); + return nfs3_errno_to_nfsstat3(op_errno); } void -nfs3_fill_lookup3res_error (lookup3res *res, nfsstat3 stat, - struct iatt *dirstat) +nfs3_fill_lookup3res_error(lookup3res *res, nfsstat3 stat, struct iatt *dirstat) { - - memset (res, 0, sizeof (*res)); - res->status = stat; - if (!dirstat) { - res->lookup3res_u.resfail.dir_attributes.attributes_follow = FALSE; - } - + memset(res, 0, sizeof(*res)); + res->status = stat; + if (!dirstat) { + res->lookup3res_u.resfail.dir_attributes.attributes_follow = FALSE; + } } void -nfs3_stat_to_fattr3 (struct iatt *buf, fattr3 *fa) +nfs3_stat_to_fattr3(struct iatt *buf, fattr3 *fa) { - if (buf == NULL || fa == NULL) { - errno = EINVAL; - return; - } - - if (IA_ISDIR (buf->ia_type)) - fa->type = NF3DIR; - else if (IA_ISREG (buf->ia_type)) - fa->type = NF3REG; - else if (IA_ISCHR (buf->ia_type)) - fa->type = NF3CHR; - else if (IA_ISBLK (buf->ia_type)) - fa->type = NF3BLK; - else if (IA_ISFIFO (buf->ia_type)) - fa->type = NF3FIFO; - else if (IA_ISLNK (buf->ia_type)) - fa->type = NF3LNK; - else if (IA_ISSOCK (buf->ia_type)) - fa->type = NF3SOCK; - - if (IA_PROT_RUSR (buf->ia_prot)) - fa->mode |= NFS3MODE_ROWNER; - if (IA_PROT_WUSR (buf->ia_prot)) - fa->mode |= NFS3MODE_WOWNER; - if (IA_PROT_XUSR (buf->ia_prot)) - fa->mode |= NFS3MODE_XOWNER; - - if (IA_PROT_RGRP (buf->ia_prot)) - fa->mode |= NFS3MODE_RGROUP; - if (IA_PROT_WGRP (buf->ia_prot)) - fa->mode |= NFS3MODE_WGROUP; - if (IA_PROT_XGRP (buf->ia_prot)) - fa->mode |= NFS3MODE_XGROUP; - - if (IA_PROT_ROTH (buf->ia_prot)) - fa->mode |= NFS3MODE_ROTHER; - if (IA_PROT_WOTH (buf->ia_prot)) - fa->mode |= NFS3MODE_WOTHER; - if (IA_PROT_XOTH (buf->ia_prot)) - fa->mode |= NFS3MODE_XOTHER; - - if (IA_PROT_SUID (buf->ia_prot)) - fa->mode |= NFS3MODE_SETXUID; - if (IA_PROT_SGID (buf->ia_prot)) - fa->mode |= NFS3MODE_SETXGID; - if (IA_PROT_STCKY (buf->ia_prot)) - fa->mode |= NFS3MODE_SAVESWAPTXT; - - fa->nlink = buf->ia_nlink; - fa->uid = buf->ia_uid; - fa->gid = buf->ia_gid; - fa->size = buf->ia_size; - fa->used = (buf->ia_blocks * 512); - - if ((IA_ISCHR (buf->ia_type) || IA_ISBLK (buf->ia_type))) { - fa->rdev.specdata1 = ia_major (buf->ia_rdev); - fa->rdev.specdata2 = ia_minor (buf->ia_rdev); - } else { - fa->rdev.specdata1 = 0; - fa->rdev.specdata2 = 0; - } - - fa->fsid = buf->ia_dev; - fa->fileid = nfs3_iatt_gfid_to_ino (buf); - - fa->atime.seconds = buf->ia_atime; - fa->atime.nseconds = buf->ia_atime_nsec; - - fa->ctime.seconds = buf->ia_ctime; - fa->ctime.nseconds = buf->ia_ctime_nsec; - - fa->mtime.seconds = buf->ia_mtime; - fa->mtime.nseconds = buf->ia_mtime_nsec; + if (buf == NULL || fa == NULL) { + errno = EINVAL; + return; + } + + if (IA_ISDIR(buf->ia_type)) + fa->type = NF3DIR; + else if (IA_ISREG(buf->ia_type)) + fa->type = NF3REG; + else if (IA_ISCHR(buf->ia_type)) + fa->type = NF3CHR; + else if (IA_ISBLK(buf->ia_type)) + fa->type = NF3BLK; + else if (IA_ISFIFO(buf->ia_type)) + fa->type = NF3FIFO; + else if (IA_ISLNK(buf->ia_type)) + fa->type = NF3LNK; + else if (IA_ISSOCK(buf->ia_type)) + fa->type = NF3SOCK; + + if (IA_PROT_RUSR(buf->ia_prot)) + fa->mode |= NFS3MODE_ROWNER; + if (IA_PROT_WUSR(buf->ia_prot)) + fa->mode |= NFS3MODE_WOWNER; + if (IA_PROT_XUSR(buf->ia_prot)) + fa->mode |= NFS3MODE_XOWNER; + + if (IA_PROT_RGRP(buf->ia_prot)) + fa->mode |= NFS3MODE_RGROUP; + if (IA_PROT_WGRP(buf->ia_prot)) + fa->mode |= NFS3MODE_WGROUP; + if (IA_PROT_XGRP(buf->ia_prot)) + fa->mode |= NFS3MODE_XGROUP; + + if (IA_PROT_ROTH(buf->ia_prot)) + fa->mode |= NFS3MODE_ROTHER; + if (IA_PROT_WOTH(buf->ia_prot)) + fa->mode |= NFS3MODE_WOTHER; + if (IA_PROT_XOTH(buf->ia_prot)) + fa->mode |= NFS3MODE_XOTHER; + + if (IA_PROT_SUID(buf->ia_prot)) + fa->mode |= NFS3MODE_SETXUID; + if (IA_PROT_SGID(buf->ia_prot)) + fa->mode |= NFS3MODE_SETXGID; + if (IA_PROT_STCKY(buf->ia_prot)) + fa->mode |= NFS3MODE_SAVESWAPTXT; + + fa->nlink = buf->ia_nlink; + fa->uid = buf->ia_uid; + fa->gid = buf->ia_gid; + fa->size = buf->ia_size; + fa->used = (buf->ia_blocks * 512); + + if ((IA_ISCHR(buf->ia_type) || IA_ISBLK(buf->ia_type))) { + fa->rdev.specdata1 = ia_major(buf->ia_rdev); + fa->rdev.specdata2 = ia_minor(buf->ia_rdev); + } else { + fa->rdev.specdata1 = 0; + fa->rdev.specdata2 = 0; + } + + fa->fsid = buf->ia_dev; + fa->fileid = nfs3_iatt_gfid_to_ino(buf); + + fa->atime.seconds = buf->ia_atime; + fa->atime.nseconds = buf->ia_atime_nsec; + + fa->ctime.seconds = buf->ia_ctime; + fa->ctime.nseconds = buf->ia_ctime_nsec; + + fa->mtime.seconds = buf->ia_mtime; + fa->mtime.nseconds = buf->ia_mtime_nsec; } - post_op_attr -nfs3_stat_to_post_op_attr (struct iatt *buf) +nfs3_stat_to_post_op_attr(struct iatt *buf) { - post_op_attr attr = {0, }; - if (!buf) - return attr; + post_op_attr attr = { + 0, + }; + if (!buf) + return attr; - /* Some performance translators return zero-filled stats when they - * do not have up-to-date attributes. Need to handle this by not - * returning these zeroed out attrs. - */ - attr.attributes_follow = FALSE; - if (gf_is_zero_filled_stat (buf)) - goto out; + /* Some performance translators return zero-filled stats when they + * do not have up-to-date attributes. Need to handle this by not + * returning these zeroed out attrs. + */ + attr.attributes_follow = FALSE; + if (gf_is_zero_filled_stat(buf)) + goto out; - nfs3_stat_to_fattr3 (buf, &(attr.post_op_attr_u.attributes)); - attr.attributes_follow = TRUE; + nfs3_stat_to_fattr3(buf, &(attr.post_op_attr_u.attributes)); + attr.attributes_follow = TRUE; out: - return attr; + return attr; } - pre_op_attr -nfs3_stat_to_pre_op_attr (struct iatt *pre) -{ - pre_op_attr poa = {0, }; - - /* Some performance translators return zero-filled stats when they - * do not have up-to-date attributes. Need to handle this by not - * returning these zeroed out attrs. - */ - poa.attributes_follow = FALSE; - if (gf_is_zero_filled_stat (pre)) - goto out; - - poa.attributes_follow = TRUE; - poa.pre_op_attr_u.attributes.size = pre->ia_size; - poa.pre_op_attr_u.attributes.mtime.seconds = pre->ia_mtime; - poa.pre_op_attr_u.attributes.mtime.nseconds = pre->ia_mtime_nsec; - poa.pre_op_attr_u.attributes.ctime.seconds = pre->ia_ctime; - poa.pre_op_attr_u.attributes.ctime.nseconds = pre->ia_ctime_nsec; +nfs3_stat_to_pre_op_attr(struct iatt *pre) +{ + pre_op_attr poa = { + 0, + }; + + /* Some performance translators return zero-filled stats when they + * do not have up-to-date attributes. Need to handle this by not + * returning these zeroed out attrs. + */ + poa.attributes_follow = FALSE; + if (gf_is_zero_filled_stat(pre)) + goto out; + + poa.attributes_follow = TRUE; + poa.pre_op_attr_u.attributes.size = pre->ia_size; + poa.pre_op_attr_u.attributes.mtime.seconds = pre->ia_mtime; + poa.pre_op_attr_u.attributes.mtime.nseconds = pre->ia_mtime_nsec; + poa.pre_op_attr_u.attributes.ctime.seconds = pre->ia_ctime; + poa.pre_op_attr_u.attributes.ctime.nseconds = pre->ia_ctime_nsec; out: - return poa; + return poa; } void -nfs3_fill_lookup3res_success (lookup3res *res, nfsstat3 stat, - struct nfs3_fh *fh, struct iatt *buf, - struct iatt *postparent) +nfs3_fill_lookup3res_success(lookup3res *res, nfsstat3 stat, struct nfs3_fh *fh, + struct iatt *buf, struct iatt *postparent) { - post_op_attr obj, dir; - uint32_t fhlen = 0; + post_op_attr obj, dir; + uint32_t fhlen = 0; - res->status = stat; - if (fh) { - res->lookup3res_u.resok.object.data.data_val = (void *)fh; - fhlen = nfs3_fh_compute_size (); - res->lookup3res_u.resok.object.data.data_len = fhlen; - } + res->status = stat; + if (fh) { + res->lookup3res_u.resok.object.data.data_val = (void *)fh; + fhlen = nfs3_fh_compute_size(); + res->lookup3res_u.resok.object.data.data_len = fhlen; + } - obj.attributes_follow = FALSE; - dir.attributes_follow = FALSE; - obj = nfs3_stat_to_post_op_attr (buf); - dir = nfs3_stat_to_post_op_attr (postparent); + obj.attributes_follow = FALSE; + dir.attributes_follow = FALSE; + obj = nfs3_stat_to_post_op_attr(buf); + dir = nfs3_stat_to_post_op_attr(postparent); - res->lookup3res_u.resok.obj_attributes = obj; - res->lookup3res_u.resok.dir_attributes = dir; + res->lookup3res_u.resok.obj_attributes = obj; + res->lookup3res_u.resok.dir_attributes = dir; } - void -nfs3_fill_lookup3res (lookup3res *res, nfsstat3 stat, struct nfs3_fh *newfh, - struct iatt *buf, struct iatt *postparent, - uint64_t deviceid) +nfs3_fill_lookup3res(lookup3res *res, nfsstat3 stat, struct nfs3_fh *newfh, + struct iatt *buf, struct iatt *postparent, + uint64_t deviceid) { - - memset (res, 0, sizeof (*res)); - nfs3_map_deviceid_to_statdev (buf, deviceid); - nfs3_map_deviceid_to_statdev (postparent, deviceid); - if (stat != NFS3_OK) - nfs3_fill_lookup3res_error (res, stat, postparent); - else - nfs3_fill_lookup3res_success (res, stat, newfh, buf, - postparent); + memset(res, 0, sizeof(*res)); + nfs3_map_deviceid_to_statdev(buf, deviceid); + nfs3_map_deviceid_to_statdev(postparent, deviceid); + if (stat != NFS3_OK) + nfs3_fill_lookup3res_error(res, stat, postparent); + else + nfs3_fill_lookup3res_success(res, stat, newfh, buf, postparent); } struct nfs3_fh -nfs3_extract_getattr_fh (getattr3args *args) +nfs3_extract_getattr_fh(getattr3args *args) { - return nfs3_extract_nfs3_fh(args->object); + return nfs3_extract_nfs3_fh(args->object); } - void -nfs3_fill_getattr3res (getattr3res *res, nfsstat3 stat, struct iatt *buf, - uint64_t deviceid) +nfs3_fill_getattr3res(getattr3res *res, nfsstat3 stat, struct iatt *buf, + uint64_t deviceid) { + memset(res, 0, sizeof(*res)); + res->status = stat; + if (stat != NFS3_OK) + return; - memset (res, 0, sizeof (*res)); - res->status = stat; - if (stat != NFS3_OK) - return; - - nfs3_map_deviceid_to_statdev (buf, deviceid); - nfs3_stat_to_fattr3 (buf, &(res->getattr3res_u.resok.obj_attributes)); + nfs3_map_deviceid_to_statdev(buf, deviceid); + nfs3_stat_to_fattr3(buf, &(res->getattr3res_u.resok.obj_attributes)); } - struct nfs3_fh -nfs3_extract_fsinfo_fh (fsinfo3args *args) +nfs3_extract_fsinfo_fh(fsinfo3args *args) { - return nfs3_extract_nfs3_fh (args->fsroot); + return nfs3_extract_nfs3_fh(args->fsroot); } - void -nfs3_fill_fsinfo3res (struct nfs3_state *nfs3, fsinfo3res *res, - nfsstat3 status, struct iatt *fsroot, uint64_t deviceid) +nfs3_fill_fsinfo3res(struct nfs3_state *nfs3, fsinfo3res *res, nfsstat3 status, + struct iatt *fsroot, uint64_t deviceid) { - fsinfo3resok resok = {{0}, }; - nfstime3 tdelta = GF_NFS3_TIMEDELTA_SECS; + fsinfo3resok resok = { + {0}, + }; + nfstime3 tdelta = GF_NFS3_TIMEDELTA_SECS; - memset (res, 0, sizeof (*res)); - res->status = status; - if (status != NFS3_OK) - return; - - nfs3_map_deviceid_to_statdev (fsroot, deviceid); - resok.obj_attributes = nfs3_stat_to_post_op_attr (fsroot); - resok.rtmax = nfs3->readsize; - resok.rtpref = nfs3->readsize; - resok.rtmult = GF_NFS3_RTMULT; - resok.wtmax = nfs3->writesize; - resok.wtpref = nfs3->writesize; - resok.wtmult = GF_NFS3_WTMULT; - resok.dtpref = nfs3->readdirsize; - resok.maxfilesize = GF_NFS3_MAXFILESIZE; - resok.time_delta = tdelta; - resok.properties = GF_NFS3_FS_PROP; + memset(res, 0, sizeof(*res)); + res->status = status; + if (status != NFS3_OK) + return; - res->fsinfo3res_u.resok = resok; + nfs3_map_deviceid_to_statdev(fsroot, deviceid); + resok.obj_attributes = nfs3_stat_to_post_op_attr(fsroot); + resok.rtmax = nfs3->readsize; + resok.rtpref = nfs3->readsize; + resok.rtmult = GF_NFS3_RTMULT; + resok.wtmax = nfs3->writesize; + resok.wtpref = nfs3->writesize; + resok.wtmult = GF_NFS3_WTMULT; + resok.dtpref = nfs3->readdirsize; + resok.maxfilesize = GF_NFS3_MAXFILESIZE; + resok.time_delta = tdelta; + resok.properties = GF_NFS3_FS_PROP; + res->fsinfo3res_u.resok = resok; } - void -nfs3_prep_lookup3args (lookup3args *args, struct nfs3_fh *fh, char *name) +nfs3_prep_lookup3args(lookup3args *args, struct nfs3_fh *fh, char *name) { - memset (args, 0, sizeof (*args)); - args->what.dir.data.data_val = (void *)fh; - args->what.name = name; + memset(args, 0, sizeof(*args)); + args->what.dir.data.data_val = (void *)fh; + args->what.name = name; } - void -nfs3_prep_getattr3args (getattr3args *args, struct nfs3_fh *fh) +nfs3_prep_getattr3args(getattr3args *args, struct nfs3_fh *fh) { - memset (args, 0, sizeof (*args)); - args->object.data.data_val = (void *)fh; + memset(args, 0, sizeof(*args)); + args->object.data.data_val = (void *)fh; } - void -nfs3_prep_fsinfo3args (fsinfo3args *args, struct nfs3_fh *root) +nfs3_prep_fsinfo3args(fsinfo3args *args, struct nfs3_fh *root) { - memset (args, 0, sizeof (*args)); - args->fsroot.data.data_val = (void *)root; + memset(args, 0, sizeof(*args)); + args->fsroot.data.data_val = (void *)root; } - char * nfsstat3_strerror(int stat) { - int i; - for(i = 0; nfs3stat_strerror_table[i].stat != NFS3ERR_END_OF_LIST ; i++) { - if (nfs3stat_strerror_table[i].stat == stat) - return nfs3stat_strerror_table[i].strerror; - } + int i; + for (i = 0; nfs3stat_strerror_table[i].stat != NFS3ERR_END_OF_LIST; i++) { + if (nfs3stat_strerror_table[i].stat == stat) + return nfs3stat_strerror_table[i].strerror; + } - return nfs3stat_strerror_table[i].strerror; + return nfs3stat_strerror_table[i].strerror; } - - void -nfs3_prep_access3args (access3args *args, struct nfs3_fh *fh) +nfs3_prep_access3args(access3args *args, struct nfs3_fh *fh) { - memset (args, 0, sizeof (*args)); - args->object.data.data_val = (void *)fh; + memset(args, 0, sizeof(*args)); + args->object.data.data_val = (void *)fh; } -#define POSIX_READ 4 -#define POSIX_WRITE 2 -#define POSIX_EXEC 1 +#define POSIX_READ 4 +#define POSIX_WRITE 2 +#define POSIX_EXEC 1 uint32_t -nfs3_accessbits (int32_t accbits) +nfs3_accessbits(int32_t accbits) { - uint32_t accresult = 0; + uint32_t accresult = 0; - if (accbits & POSIX_READ) - accresult |= ACCESS3_READ; + if (accbits & POSIX_READ) + accresult |= ACCESS3_READ; - if (accbits & POSIX_WRITE) - accresult |= (ACCESS3_MODIFY | ACCESS3_EXTEND | ACCESS3_DELETE); + if (accbits & POSIX_WRITE) + accresult |= (ACCESS3_MODIFY | ACCESS3_EXTEND | ACCESS3_DELETE); - /* lookup on directory allowed only in case of execute permission */ - if (accbits & POSIX_EXEC) - accresult |= (ACCESS3_EXECUTE | ACCESS3_LOOKUP); + /* lookup on directory allowed only in case of execute permission */ + if (accbits & POSIX_EXEC) + accresult |= (ACCESS3_EXECUTE | ACCESS3_LOOKUP); - return accresult; + return accresult; } uint32_t -nfs3_request_to_accessbits (int32_t accbits) +nfs3_request_to_accessbits(int32_t accbits) { - uint32_t acc_request = 0; + uint32_t acc_request = 0; - if (accbits & ACCESS3_READ) - acc_request |= POSIX_READ; + if (accbits & ACCESS3_READ) + acc_request |= POSIX_READ; - if (accbits & (ACCESS3_MODIFY | ACCESS3_EXTEND | ACCESS3_DELETE)) - acc_request |= POSIX_WRITE; + if (accbits & (ACCESS3_MODIFY | ACCESS3_EXTEND | ACCESS3_DELETE)) + acc_request |= POSIX_WRITE; - /* For lookup on directory check for execute permission */ - if (accbits & (ACCESS3_EXECUTE | ACCESS3_LOOKUP)) - acc_request |= POSIX_EXEC; + /* For lookup on directory check for execute permission */ + if (accbits & (ACCESS3_EXECUTE | ACCESS3_LOOKUP)) + acc_request |= POSIX_EXEC; - return acc_request; + return acc_request; } void -nfs3_fill_access3res (access3res *res, nfsstat3 status, int32_t accbits, - int32_t reqaccbits) +nfs3_fill_access3res(access3res *res, nfsstat3 status, int32_t accbits, + int32_t reqaccbits) { - uint32_t accres = 0; + uint32_t accres = 0; - memset (res, 0, sizeof (*res)); - res->status = status; - if (status != NFS3_OK) - return; + memset(res, 0, sizeof(*res)); + res->status = status; + if (status != NFS3_OK) + return; - accres = nfs3_accessbits (accbits); + accres = nfs3_accessbits(accbits); - /* do not answer what was not asked */ - res->access3res_u.resok.access = accres & reqaccbits; + /* do not answer what was not asked */ + res->access3res_u.resok.access = accres & reqaccbits; } void -nfs3_prep_readdir3args (readdir3args *ra, struct nfs3_fh *fh) +nfs3_prep_readdir3args(readdir3args *ra, struct nfs3_fh *fh) { - memset (ra, 0, sizeof (*ra)); - ra->dir.data.data_val = (void *)fh; + memset(ra, 0, sizeof(*ra)); + ra->dir.data.data_val = (void *)fh; } - int -nfs3_is_dot_entry (char *entry) +nfs3_is_dot_entry(char *entry) { - int ret = 0; + int ret = 0; - if (!entry) - return 0; + if (!entry) + return 0; - if (strcmp (entry, ".") == 0) - ret = 1; + if (strcmp(entry, ".") == 0) + ret = 1; - return ret; + return ret; } - int -nfs3_is_parentdir_entry (char *entry) +nfs3_is_parentdir_entry(char *entry) { - int ret = 0; + int ret = 0; - if (!entry) - return 0; + if (!entry) + return 0; - if (strcmp (entry, "..") == 0) - ret = 1; + if (strcmp(entry, "..") == 0) + ret = 1; - return ret; + return ret; } - void -nfs3_funge_root_dotdot_dirent (gf_dirent_t *ent, struct nfs3_fh *dfh) +nfs3_funge_root_dotdot_dirent(gf_dirent_t *ent, struct nfs3_fh *dfh) { - if ((!ent) || (!dfh)) - return; - - if (nfs3_fh_is_root_fh (dfh) && - nfs3_is_parentdir_entry (ent->d_name)) { - ent->d_ino = 1; - ent->d_stat.ia_ino = 1; - } + if ((!ent) || (!dfh)) + return; - if (nfs3_fh_is_root_fh (dfh) && - nfs3_is_dot_entry (ent->d_name)) { - ent->d_ino = 1; - ent->d_stat.ia_ino = 1; - } + if (nfs3_fh_is_root_fh(dfh) && nfs3_is_parentdir_entry(ent->d_name)) { + ent->d_ino = 1; + ent->d_stat.ia_ino = 1; + } + if (nfs3_fh_is_root_fh(dfh) && nfs3_is_dot_entry(ent->d_name)) { + ent->d_ino = 1; + ent->d_stat.ia_ino = 1; + } } - entry3 * -nfs3_fill_entry3 (gf_dirent_t *entry, struct nfs3_fh *dfh) -{ - entry3 *ent = NULL; - int name_len = 0; - if ((!entry) || (!dfh)) - return NULL; - - ent = GF_CALLOC (1, sizeof (*ent), gf_nfs_mt_entry3); - if (!ent) - return NULL; - - gf_msg_trace (GF_NFS3, 0, "Entry: %s", entry->d_name); - - /* If the entry is . or .., we need to replace the physical ino and gen - * with 1 and 0 respectively if the directory is root. This funging is - * needed because there is no parent directory of the root. In that - * sense the behavior we provide is similar to the output of the - * command: "stat /.." - */ - entry->d_ino = nfs3_iatt_gfid_to_ino (&entry->d_stat); - nfs3_funge_root_dotdot_dirent (entry, dfh); - ent->fileid = entry->d_ino; - ent->cookie = entry->d_off; - name_len = strlen(entry->d_name); - ent->name = GF_MALLOC (name_len + 1, gf_nfs_mt_char); - if (!ent->name) { - GF_FREE (ent); - ent = NULL; - goto err; - } - strcpy (ent->name, entry->d_name); - ent->name[name_len] = '\0'; +nfs3_fill_entry3(gf_dirent_t *entry, struct nfs3_fh *dfh) +{ + entry3 *ent = NULL; + int name_len = 0; + if ((!entry) || (!dfh)) + return NULL; + + ent = GF_CALLOC(1, sizeof(*ent), gf_nfs_mt_entry3); + if (!ent) + return NULL; + + gf_msg_trace(GF_NFS3, 0, "Entry: %s", entry->d_name); + + /* If the entry is . or .., we need to replace the physical ino and gen + * with 1 and 0 respectively if the directory is root. This funging is + * needed because there is no parent directory of the root. In that + * sense the behavior we provide is similar to the output of the + * command: "stat /.." + */ + entry->d_ino = nfs3_iatt_gfid_to_ino(&entry->d_stat); + nfs3_funge_root_dotdot_dirent(entry, dfh); + ent->fileid = entry->d_ino; + ent->cookie = entry->d_off; + name_len = strlen(entry->d_name); + ent->name = GF_MALLOC(name_len + 1, gf_nfs_mt_char); + if (!ent->name) { + GF_FREE(ent); + ent = NULL; + goto err; + } + strcpy(ent->name, entry->d_name); + ent->name[name_len] = '\0'; err: - return ent; + return ent; } - void -nfs3_fill_post_op_fh3 (struct nfs3_fh *fh, post_op_fh3 *pfh) +nfs3_fill_post_op_fh3(struct nfs3_fh *fh, post_op_fh3 *pfh) { - uint32_t fhlen = 0; + uint32_t fhlen = 0; - if ((!fh) || (!pfh)) - return; + if ((!fh) || (!pfh)) + return; - pfh->handle_follows = 1; - fhlen = nfs3_fh_compute_size (); - pfh->post_op_fh3_u.handle.data.data_val = (void *)fh; - pfh->post_op_fh3_u.handle.data.data_len = fhlen; + pfh->handle_follows = 1; + fhlen = nfs3_fh_compute_size(); + pfh->post_op_fh3_u.handle.data.data_val = (void *)fh; + pfh->post_op_fh3_u.handle.data.data_len = fhlen; } - post_op_fh3 -nfs3_fh_to_post_op_fh3 (struct nfs3_fh *fh) +nfs3_fh_to_post_op_fh3(struct nfs3_fh *fh) { - post_op_fh3 pfh = {0, }; - char *fhp = NULL; + post_op_fh3 pfh = { + 0, + }; + char *fhp = NULL; - if (!fh) - return pfh; - - pfh.handle_follows = 1; + if (!fh) + return pfh; - fhp = GF_MALLOC (sizeof (*fh), gf_nfs_mt_char); - if (!fhp) - return pfh; + pfh.handle_follows = 1; - memcpy (fhp, fh, sizeof (*fh)); - nfs3_fill_post_op_fh3 ((struct nfs3_fh *)fhp, &pfh); + fhp = GF_MALLOC(sizeof(*fh), gf_nfs_mt_char); + if (!fhp) return pfh; -} + memcpy(fhp, fh, sizeof(*fh)); + nfs3_fill_post_op_fh3((struct nfs3_fh *)fhp, &pfh); + return pfh; +} entryp3 * -nfs3_fill_entryp3 (gf_dirent_t *entry, struct nfs3_fh *dirfh, uint64_t devid) +nfs3_fill_entryp3(gf_dirent_t *entry, struct nfs3_fh *dirfh, uint64_t devid) +{ + entryp3 *ent = NULL; + struct nfs3_fh newfh = { + {0}, + }; + int name_len = 0; + + if ((!entry) || (!dirfh)) + return NULL; + + /* If the entry is . or .., we need to replace the physical ino and gen + * with 1 and 0 respectively if the directory is root. This funging is + * needed because there is no parent directory of the root. In that + * sense the behavior we provide is similar to the output of the + * command: "stat /.." + */ + entry->d_ino = nfs3_iatt_gfid_to_ino(&entry->d_stat); + nfs3_funge_root_dotdot_dirent(entry, dirfh); + gf_msg_trace(GF_NFS3, 0, "Entry: %s, ino: %" PRIu64, entry->d_name, + entry->d_ino); + ent = GF_CALLOC(1, sizeof(*ent), gf_nfs_mt_entryp3); + if (!ent) + return NULL; + + ent->fileid = entry->d_ino; + ent->cookie = entry->d_off; + name_len = strlen(entry->d_name); + ent->name = GF_MALLOC(name_len + 1, gf_nfs_mt_char); + if (!ent->name) { + GF_FREE(ent); + ent = NULL; + goto err; + } + strcpy(ent->name, entry->d_name); + ent->name[name_len] = '\0'; + + nfs3_fh_build_child_fh(dirfh, &entry->d_stat, &newfh); + nfs3_map_deviceid_to_statdev(&entry->d_stat, devid); + /* * + * In tier volume, the readdirp send only to cold subvol + * which will populate in the 'T' file entries in the result. + * For such files an explicit stat call is required, by setting + * following argument client will perform the same. + * + * The inode value for 'T' files and directory is NULL, so just + * skip the check if it is directory. + */ + if (!(IA_ISDIR(entry->d_stat.ia_type)) && (entry->inode == NULL)) + ent->name_attributes.attributes_follow = FALSE; + else + ent->name_attributes = nfs3_stat_to_post_op_attr(&entry->d_stat); + + ent->name_handle = nfs3_fh_to_post_op_fh3(&newfh); +err: + return ent; +} + +void +nfs3_fill_readdir3res(readdir3res *res, nfsstat3 stat, struct nfs3_fh *dirfh, + uint64_t cverf, struct iatt *dirstat, + gf_dirent_t *entries, count3 count, int is_eof, + uint64_t deviceid) { - entryp3 *ent = NULL; - struct nfs3_fh newfh = {{0}, }; - int name_len = 0; + post_op_attr dirattr; + entry3 *ent = NULL; + entry3 *headentry = NULL; + entry3 *preventry = NULL; + count3 filled = 0; + gf_dirent_t *listhead = NULL; - if ((!entry) || (!dirfh)) - return NULL; + memset(res, 0, sizeof(*res)); + res->status = stat; + if (stat != NFS3_OK) + return; - /* If the entry is . or .., we need to replace the physical ino and gen - * with 1 and 0 respectively if the directory is root. This funging is - * needed because there is no parent directory of the root. In that - * sense the behavior we provide is similar to the output of the - * command: "stat /.." - */ - entry->d_ino = nfs3_iatt_gfid_to_ino (&entry->d_stat); - nfs3_funge_root_dotdot_dirent (entry, dirfh); - gf_msg_trace (GF_NFS3, 0, "Entry: %s, ino: %"PRIu64, - entry->d_name, entry->d_ino); - ent = GF_CALLOC (1, sizeof (*ent), gf_nfs_mt_entryp3); + nfs3_map_deviceid_to_statdev(dirstat, deviceid); + dirattr = nfs3_stat_to_post_op_attr(dirstat); + res->readdir3res_u.resok.dir_attributes = dirattr; + res->readdir3res_u.resok.reply.eof = (bool_t)is_eof; + memcpy(res->readdir3res_u.resok.cookieverf, &cverf, sizeof(cverf)); + + filled = NFS3_READDIR_RESOK_SIZE; + /* First entry is just the list head */ + listhead = entries; + entries = entries->next; + while (((entries) && (entries != listhead)) && (filled < count)) { + /* + if ((strcmp (entries->d_name, ".") == 0) || + (strcmp (entries->d_name, "..") == 0)) + goto nextentry; + */ + ent = nfs3_fill_entry3(entries, dirfh); if (!ent) - return NULL; - - ent->fileid = entry->d_ino; - ent->cookie = entry->d_off; - name_len = strlen (entry->d_name); - ent->name = GF_MALLOC (name_len + 1, gf_nfs_mt_char); - if (!ent->name) { - GF_FREE (ent); - ent = NULL; - goto err; - } - strcpy (ent->name, entry->d_name); - ent->name[name_len] = '\0'; - - nfs3_fh_build_child_fh (dirfh, &entry->d_stat, &newfh); - nfs3_map_deviceid_to_statdev (&entry->d_stat, devid); - /* * - * In tier volume, the readdirp send only to cold subvol - * which will populate in the 'T' file entries in the result. - * For such files an explicit stat call is required, by setting - * following argument client will perform the same. - * - * The inode value for 'T' files and directory is NULL, so just - * skip the check if it is directory. - */ - if (!(IA_ISDIR(entry->d_stat.ia_type)) && (entry->inode == NULL)) - ent->name_attributes.attributes_follow = FALSE; - else - ent->name_attributes = - nfs3_stat_to_post_op_attr (&entry->d_stat); + break; - ent->name_handle = nfs3_fh_to_post_op_fh3 (&newfh); -err: - return ent; -} + if (!headentry) + headentry = ent; + if (preventry) { + preventry->nextentry = ent; + preventry = ent; + } else + preventry = ent; -void -nfs3_fill_readdir3res (readdir3res *res, nfsstat3 stat, struct nfs3_fh *dirfh, - uint64_t cverf, struct iatt *dirstat, - gf_dirent_t *entries, count3 count, int is_eof, - uint64_t deviceid) -{ - post_op_attr dirattr; - entry3 *ent = NULL; - entry3 *headentry = NULL; - entry3 *preventry = NULL; - count3 filled = 0; - gf_dirent_t *listhead = NULL; - - memset (res, 0, sizeof (*res)); - res->status = stat; - if (stat != NFS3_OK) - return; - - nfs3_map_deviceid_to_statdev (dirstat, deviceid); - dirattr = nfs3_stat_to_post_op_attr (dirstat); - res->readdir3res_u.resok.dir_attributes = dirattr; - res->readdir3res_u.resok.reply.eof = (bool_t)is_eof; - memcpy (res->readdir3res_u.resok.cookieverf, &cverf, sizeof (cverf)); - - filled = NFS3_READDIR_RESOK_SIZE; - /* First entry is just the list head */ - listhead = entries; + filled += NFS3_ENTRY3_FIXED_SIZE + strlen(ent->name); + // nextentry: entries = entries->next; - while (((entries) && (entries != listhead)) && (filled < count)) { - /* - if ((strcmp (entries->d_name, ".") == 0) || - (strcmp (entries->d_name, "..") == 0)) - goto nextentry; - */ - ent = nfs3_fill_entry3 (entries, dirfh); - if (!ent) - break; - - if (!headentry) - headentry = ent; - - if (preventry) { - preventry->nextentry = ent; - preventry = ent; - } else - preventry = ent; - - filled += NFS3_ENTRY3_FIXED_SIZE + strlen (ent->name); -//nextentry: - entries = entries->next; - } + } - res->readdir3res_u.resok.reply.entries = headentry; + res->readdir3res_u.resok.reply.entries = headentry; - return; + return; } - void -nfs3_fill_readdirp3res (readdirp3res *res, nfsstat3 stat, - struct nfs3_fh *dirfh, uint64_t cverf, - struct iatt *dirstat, gf_dirent_t *entries, - count3 dircount, count3 maxcount, int is_eof, - uint64_t deviceid) -{ - post_op_attr dirattr; - entryp3 *ent = NULL; - entryp3 *headentry = NULL; - entryp3 *preventry = NULL; - count3 filled = 0; - gf_dirent_t *listhead = NULL; - int fhlen = 0; +nfs3_fill_readdirp3res(readdirp3res *res, nfsstat3 stat, struct nfs3_fh *dirfh, + uint64_t cverf, struct iatt *dirstat, + gf_dirent_t *entries, count3 dircount, count3 maxcount, + int is_eof, uint64_t deviceid) +{ + post_op_attr dirattr; + entryp3 *ent = NULL; + entryp3 *headentry = NULL; + entryp3 *preventry = NULL; + count3 filled = 0; + gf_dirent_t *listhead = NULL; + int fhlen = 0; + + memset(res, 0, sizeof(*res)); + res->status = stat; + if (stat != NFS3_OK) + return; - memset (res, 0, sizeof (*res)); - res->status = stat; - if (stat != NFS3_OK) - return; + nfs3_map_deviceid_to_statdev(dirstat, deviceid); + dirattr = nfs3_stat_to_post_op_attr(dirstat); + res->readdirp3res_u.resok.dir_attributes = dirattr; + res->readdirp3res_u.resok.reply.eof = (bool_t)is_eof; + memcpy(res->readdirp3res_u.resok.cookieverf, &cverf, sizeof(cverf)); + + filled = NFS3_READDIR_RESOK_SIZE; + /* First entry is just the list head */ + listhead = entries; + entries = entries->next; + while (((entries) && (entries != listhead)) && (filled < maxcount)) { + /* Linux does not display . and .. entries unless we provide + * these entries here. + */ + /* if ((strcmp (entries->d_name, ".") == 0) || + (strcmp (entries->d_name, "..") == 0)) + goto nextentry; + */ + ent = nfs3_fill_entryp3(entries, dirfh, deviceid); + if (!ent) + break; - nfs3_map_deviceid_to_statdev (dirstat, deviceid); - dirattr = nfs3_stat_to_post_op_attr (dirstat); - res->readdirp3res_u.resok.dir_attributes = dirattr; - res->readdirp3res_u.resok.reply.eof = (bool_t)is_eof; - memcpy (res->readdirp3res_u.resok.cookieverf, &cverf, sizeof (cverf)); + if (!headentry) + headentry = ent; - filled = NFS3_READDIR_RESOK_SIZE; - /* First entry is just the list head */ - listhead = entries; + if (preventry) { + preventry->nextentry = ent; + preventry = ent; + } else + preventry = ent; + + fhlen = ent->name_handle.post_op_fh3_u.handle.data.data_len; + filled += NFS3_ENTRYP3_FIXED_SIZE + fhlen + strlen(ent->name); + // nextentry: entries = entries->next; - while (((entries) && (entries != listhead)) && (filled < maxcount)) { - /* Linux does not display . and .. entries unless we provide - * these entries here. - */ -/* if ((strcmp (entries->d_name, ".") == 0) || - (strcmp (entries->d_name, "..") == 0)) - goto nextentry; - */ - ent = nfs3_fill_entryp3 (entries, dirfh, deviceid); - if (!ent) - break; - - if (!headentry) - headentry = ent; - - if (preventry) { - preventry->nextentry = ent; - preventry = ent; - } else - preventry = ent; - - fhlen = ent->name_handle.post_op_fh3_u.handle.data.data_len; - filled += NFS3_ENTRYP3_FIXED_SIZE + fhlen + strlen (ent->name); -//nextentry: - entries = entries->next; - } + } - res->readdirp3res_u.resok.reply.entries = headentry; + res->readdirp3res_u.resok.reply.entries = headentry; - return; + return; } - void -nfs3_prep_readdirp3args (readdirp3args *ra, struct nfs3_fh *fh) +nfs3_prep_readdirp3args(readdirp3args *ra, struct nfs3_fh *fh) { - memset (ra, 0, sizeof (*ra)); - ra->dir.data.data_val = (void *)fh; + memset(ra, 0, sizeof(*ra)); + ra->dir.data.data_val = (void *)fh; } void -nfs3_free_readdirp3res (readdirp3res *res) +nfs3_free_readdirp3res(readdirp3res *res) { - entryp3 *ent = NULL; - entryp3 *next = NULL; - - if (!res) - return; + entryp3 *ent = NULL; + entryp3 *next = NULL; - ent = res->readdirp3res_u.resok.reply.entries; - while (ent) { + if (!res) + return; - next = ent->nextentry; - GF_FREE (ent->name); - GF_FREE (ent->name_handle.post_op_fh3_u.handle.data.data_val); - GF_FREE (ent); - ent = next; - } + ent = res->readdirp3res_u.resok.reply.entries; + while (ent) { + next = ent->nextentry; + GF_FREE(ent->name); + GF_FREE(ent->name_handle.post_op_fh3_u.handle.data.data_val); + GF_FREE(ent); + ent = next; + } - return; + return; } - void -nfs3_free_readdir3res (readdir3res *res) +nfs3_free_readdir3res(readdir3res *res) { - entry3 *ent = NULL; - entry3 *next = NULL; + entry3 *ent = NULL; + entry3 *next = NULL; - if (!res) - return; - - ent = res->readdir3res_u.resok.reply.entries; - while (ent) { + if (!res) + return; - next = ent->nextentry; - GF_FREE (ent->name); - GF_FREE (ent); - ent = next; - } + ent = res->readdir3res_u.resok.reply.entries; + while (ent) { + next = ent->nextentry; + GF_FREE(ent->name); + GF_FREE(ent); + ent = next; + } - return; + return; } void -nfs3_prep_fsstat3args (fsstat3args *args, struct nfs3_fh *fh) +nfs3_prep_fsstat3args(fsstat3args *args, struct nfs3_fh *fh) { - memset (args, 0, sizeof (*args)); - args->fsroot.data.data_val = (char *)fh; + memset(args, 0, sizeof(*args)); + args->fsroot.data.data_val = (char *)fh; } - void -nfs3_fill_fsstat3res (fsstat3res *res, nfsstat3 stat, struct statvfs *fsbuf, - struct iatt *postbuf, uint64_t deviceid) +nfs3_fill_fsstat3res(fsstat3res *res, nfsstat3 stat, struct statvfs *fsbuf, + struct iatt *postbuf, uint64_t deviceid) { - post_op_attr poa; - fsstat3resok resok; + post_op_attr poa; + fsstat3resok resok; - memset (res, 0, sizeof (*res)); - res->status = stat; - if (stat != NFS3_OK) - return; + memset(res, 0, sizeof(*res)); + res->status = stat; + if (stat != NFS3_OK) + return; - nfs3_map_deviceid_to_statdev (postbuf, deviceid); - poa = nfs3_stat_to_post_op_attr (postbuf); - resok.tbytes = (size3)(fsbuf->f_frsize * fsbuf->f_blocks); - resok.fbytes = (size3)(fsbuf->f_frsize * fsbuf->f_bfree); - resok.abytes = (size3)(fsbuf->f_frsize * fsbuf->f_bavail); - resok.tfiles = (size3)(fsbuf->f_files); - resok.ffiles = (size3)(fsbuf->f_ffree); - resok.afiles = (size3)(fsbuf->f_favail); - resok.invarsec = 0; + nfs3_map_deviceid_to_statdev(postbuf, deviceid); + poa = nfs3_stat_to_post_op_attr(postbuf); + resok.tbytes = (size3)(fsbuf->f_frsize * fsbuf->f_blocks); + resok.fbytes = (size3)(fsbuf->f_frsize * fsbuf->f_bfree); + resok.abytes = (size3)(fsbuf->f_frsize * fsbuf->f_bavail); + resok.tfiles = (size3)(fsbuf->f_files); + resok.ffiles = (size3)(fsbuf->f_ffree); + resok.afiles = (size3)(fsbuf->f_favail); + resok.invarsec = 0; - resok.obj_attributes = poa; - res->fsstat3res_u.resok = resok; + resok.obj_attributes = poa; + res->fsstat3res_u.resok = resok; } - int32_t -nfs3_sattr3_to_setattr_valid (sattr3 *sattr, struct iatt *buf, mode_t *omode) -{ - int32_t valid = 0; - ia_prot_t prot = {0, }; - mode_t mode = 0; - - if (!sattr) - return 0; - - if (sattr->mode.set_it) { - valid |= GF_SET_ATTR_MODE; - - if (sattr->mode.set_mode3_u.mode & NFS3MODE_ROWNER) { - mode |= S_IRUSR; - prot.owner.read = 1; - } - if (sattr->mode.set_mode3_u.mode & NFS3MODE_WOWNER) { - mode |= S_IWUSR; - prot.owner.write = 1; - } - if (sattr->mode.set_mode3_u.mode & NFS3MODE_XOWNER) { - mode |= S_IXUSR; - prot.owner.exec = 1; - } - - if (sattr->mode.set_mode3_u.mode & NFS3MODE_RGROUP) { - mode |= S_IRGRP; - prot.group.read = 1; - } - if (sattr->mode.set_mode3_u.mode & NFS3MODE_WGROUP) { - mode |= S_IWGRP; - prot.group.write = 1; - } - if (sattr->mode.set_mode3_u.mode & NFS3MODE_XGROUP) { - mode |= S_IXGRP; - prot.group.exec = 1; - } - - if (sattr->mode.set_mode3_u.mode & NFS3MODE_ROTHER) { - mode |= S_IROTH; - prot.other.read = 1; - } - if (sattr->mode.set_mode3_u.mode & NFS3MODE_WOTHER) { - mode |= S_IWOTH; - prot.other.write = 1; - } - if (sattr->mode.set_mode3_u.mode & NFS3MODE_XOTHER) { - mode |= S_IXOTH; - prot.other.exec = 1; - } - - if (sattr->mode.set_mode3_u.mode & NFS3MODE_SETXUID) { - mode |= S_ISUID; - prot.suid = 1; - } - if (sattr->mode.set_mode3_u.mode & NFS3MODE_SETXGID) { - mode |= S_ISGID; - prot.sgid = 1; - } - if (sattr->mode.set_mode3_u.mode & NFS3MODE_SAVESWAPTXT) { - mode |= S_ISVTX; - prot.sticky = 1; - } - - if (buf) - buf->ia_prot = prot; - /* Create fop still requires the old mode_t style argument. */ - if (omode) - *omode = mode; - } +nfs3_sattr3_to_setattr_valid(sattr3 *sattr, struct iatt *buf, mode_t *omode) +{ + int32_t valid = 0; + ia_prot_t prot = { + 0, + }; + mode_t mode = 0; - if (sattr->uid.set_it) { - valid |= GF_SET_ATTR_UID; - if (buf) - buf->ia_uid = sattr->uid.set_uid3_u.uid; - } + if (!sattr) + return 0; - if (sattr->gid.set_it) { - valid |= GF_SET_ATTR_GID; - if (buf) - buf->ia_gid = sattr->gid.set_gid3_u.gid; - } + if (sattr->mode.set_it) { + valid |= GF_SET_ATTR_MODE; - if (sattr->size.set_it) { - valid |= GF_SET_ATTR_SIZE; - if (buf) - buf->ia_size = sattr->size.set_size3_u.size; + if (sattr->mode.set_mode3_u.mode & NFS3MODE_ROWNER) { + mode |= S_IRUSR; + prot.owner.read = 1; } - - if (sattr->atime.set_it == SET_TO_CLIENT_TIME) { - valid |= GF_SET_ATTR_ATIME; - if (buf) - buf->ia_atime = sattr->atime.set_atime_u.atime.seconds; + if (sattr->mode.set_mode3_u.mode & NFS3MODE_WOWNER) { + mode |= S_IWUSR; + prot.owner.write = 1; + } + if (sattr->mode.set_mode3_u.mode & NFS3MODE_XOWNER) { + mode |= S_IXUSR; + prot.owner.exec = 1; } - if (sattr->atime.set_it == SET_TO_SERVER_TIME) { - valid |= GF_SET_ATTR_ATIME; - if (buf) - buf->ia_atime = time (NULL); + if (sattr->mode.set_mode3_u.mode & NFS3MODE_RGROUP) { + mode |= S_IRGRP; + prot.group.read = 1; + } + if (sattr->mode.set_mode3_u.mode & NFS3MODE_WGROUP) { + mode |= S_IWGRP; + prot.group.write = 1; + } + if (sattr->mode.set_mode3_u.mode & NFS3MODE_XGROUP) { + mode |= S_IXGRP; + prot.group.exec = 1; } - if (sattr->mtime.set_it == SET_TO_CLIENT_TIME) { - valid |= GF_SET_ATTR_MTIME; - if (buf) - buf->ia_mtime = sattr->mtime.set_mtime_u.mtime.seconds; + if (sattr->mode.set_mode3_u.mode & NFS3MODE_ROTHER) { + mode |= S_IROTH; + prot.other.read = 1; + } + if (sattr->mode.set_mode3_u.mode & NFS3MODE_WOTHER) { + mode |= S_IWOTH; + prot.other.write = 1; + } + if (sattr->mode.set_mode3_u.mode & NFS3MODE_XOTHER) { + mode |= S_IXOTH; + prot.other.exec = 1; } - if (sattr->mtime.set_it == SET_TO_SERVER_TIME) { - valid |= GF_SET_ATTR_MTIME; - if (buf) - buf->ia_mtime = time (NULL); + if (sattr->mode.set_mode3_u.mode & NFS3MODE_SETXUID) { + mode |= S_ISUID; + prot.suid = 1; + } + if (sattr->mode.set_mode3_u.mode & NFS3MODE_SETXGID) { + mode |= S_ISGID; + prot.sgid = 1; + } + if (sattr->mode.set_mode3_u.mode & NFS3MODE_SAVESWAPTXT) { + mode |= S_ISVTX; + prot.sticky = 1; } - return valid; + if (buf) + buf->ia_prot = prot; + /* Create fop still requires the old mode_t style argument. */ + if (omode) + *omode = mode; + } + + if (sattr->uid.set_it) { + valid |= GF_SET_ATTR_UID; + if (buf) + buf->ia_uid = sattr->uid.set_uid3_u.uid; + } + + if (sattr->gid.set_it) { + valid |= GF_SET_ATTR_GID; + if (buf) + buf->ia_gid = sattr->gid.set_gid3_u.gid; + } + + if (sattr->size.set_it) { + valid |= GF_SET_ATTR_SIZE; + if (buf) + buf->ia_size = sattr->size.set_size3_u.size; + } + + if (sattr->atime.set_it == SET_TO_CLIENT_TIME) { + valid |= GF_SET_ATTR_ATIME; + if (buf) + buf->ia_atime = sattr->atime.set_atime_u.atime.seconds; + } + + if (sattr->atime.set_it == SET_TO_SERVER_TIME) { + valid |= GF_SET_ATTR_ATIME; + if (buf) + buf->ia_atime = time(NULL); + } + + if (sattr->mtime.set_it == SET_TO_CLIENT_TIME) { + valid |= GF_SET_ATTR_MTIME; + if (buf) + buf->ia_mtime = sattr->mtime.set_mtime_u.mtime.seconds; + } + + if (sattr->mtime.set_it == SET_TO_SERVER_TIME) { + valid |= GF_SET_ATTR_MTIME; + if (buf) + buf->ia_mtime = time(NULL); + } + + return valid; } - wcc_data -nfs3_stat_to_wcc_data (struct iatt *pre, struct iatt *post) +nfs3_stat_to_wcc_data(struct iatt *pre, struct iatt *post) { - wcc_data wd = {{0}, }; + wcc_data wd = { + {0}, + }; - if (post) - wd.after = nfs3_stat_to_post_op_attr (post); - if (pre) - wd.before = nfs3_stat_to_pre_op_attr (pre); + if (post) + wd.after = nfs3_stat_to_post_op_attr(post); + if (pre) + wd.before = nfs3_stat_to_pre_op_attr(pre); - return wd; + return wd; } void -nfs3_fill_create3res (create3res *res, nfsstat3 stat, struct nfs3_fh *newfh, - struct iatt *newbuf, struct iatt *preparent, - struct iatt *postparent, uint64_t deviceid) +nfs3_fill_create3res(create3res *res, nfsstat3 stat, struct nfs3_fh *newfh, + struct iatt *newbuf, struct iatt *preparent, + struct iatt *postparent, uint64_t deviceid) { - post_op_attr poa = {0, }; - wcc_data dirwcc = {{0}, }; + post_op_attr poa = { + 0, + }; + wcc_data dirwcc = { + {0}, + }; - memset (res, 0, sizeof (*res)); - res->status = stat; - if (stat != NFS3_OK) - return; + memset(res, 0, sizeof(*res)); + res->status = stat; + if (stat != NFS3_OK) + return; - nfs3_fill_post_op_fh3 (newfh, &res->create3res_u.resok.obj); - nfs3_map_deviceid_to_statdev (newbuf, deviceid); - poa = nfs3_stat_to_post_op_attr (newbuf); - res->create3res_u.resok.obj_attributes = poa; - nfs3_map_deviceid_to_statdev (preparent, deviceid); - nfs3_map_deviceid_to_statdev (postparent, deviceid); - dirwcc = nfs3_stat_to_wcc_data (preparent, postparent); + nfs3_fill_post_op_fh3(newfh, &res->create3res_u.resok.obj); + nfs3_map_deviceid_to_statdev(newbuf, deviceid); + poa = nfs3_stat_to_post_op_attr(newbuf); + res->create3res_u.resok.obj_attributes = poa; + nfs3_map_deviceid_to_statdev(preparent, deviceid); + nfs3_map_deviceid_to_statdev(postparent, deviceid); + dirwcc = nfs3_stat_to_wcc_data(preparent, postparent); - res->create3res_u.resok.dir_wcc = dirwcc; + res->create3res_u.resok.dir_wcc = dirwcc; } void -nfs3_prep_create3args (create3args *args, struct nfs3_fh *fh, char *name) +nfs3_prep_create3args(create3args *args, struct nfs3_fh *fh, char *name) { - - memset (args, 0, sizeof (*args)); - args->where.dir.data.data_val = (void *)fh; - args->where.name = name; + memset(args, 0, sizeof(*args)); + args->where.dir.data.data_val = (void *)fh; + args->where.name = name; } void -nfs3_prep_setattr3args (setattr3args *args, struct nfs3_fh *fh) +nfs3_prep_setattr3args(setattr3args *args, struct nfs3_fh *fh) { - memset (args, 0, sizeof (*args)); - args->object.data.data_val = (void *)fh; + memset(args, 0, sizeof(*args)); + args->object.data.data_val = (void *)fh; } - void -nfs3_fill_setattr3res (setattr3res *res, nfsstat3 stat, struct iatt *preop, - struct iatt *postop, uint64_t deviceid) +nfs3_fill_setattr3res(setattr3res *res, nfsstat3 stat, struct iatt *preop, + struct iatt *postop, uint64_t deviceid) { - wcc_data wcc; - memset (res, 0, sizeof (*res)); - res->status = stat; - if (stat != NFS3_OK) - return; + wcc_data wcc; + memset(res, 0, sizeof(*res)); + res->status = stat; + if (stat != NFS3_OK) + return; - nfs3_map_deviceid_to_statdev (preop, deviceid); - nfs3_map_deviceid_to_statdev (postop, deviceid); - wcc = nfs3_stat_to_wcc_data (preop, postop); - res->setattr3res_u.resok.obj_wcc = wcc; + nfs3_map_deviceid_to_statdev(preop, deviceid); + nfs3_map_deviceid_to_statdev(postop, deviceid); + wcc = nfs3_stat_to_wcc_data(preop, postop); + res->setattr3res_u.resok.obj_wcc = wcc; } - void -nfs3_prep_mkdir3args (mkdir3args *args, struct nfs3_fh *dirfh, char *name) +nfs3_prep_mkdir3args(mkdir3args *args, struct nfs3_fh *dirfh, char *name) { - - memset (args, 0, sizeof (*args)); - args->where.dir.data.data_val = (void *)dirfh; - args->where.name = name; + memset(args, 0, sizeof(*args)); + args->where.dir.data.data_val = (void *)dirfh; + args->where.name = name; } - void -nfs3_fill_mkdir3res (mkdir3res *res, nfsstat3 stat, struct nfs3_fh *fh, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, uint64_t deviceid) +nfs3_fill_mkdir3res(mkdir3res *res, nfsstat3 stat, struct nfs3_fh *fh, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, uint64_t deviceid) { - wcc_data dirwcc; - post_op_attr poa; - - memset (res, 0, sizeof (*res)); - res->status = stat; - if (stat != NFS3_OK) - return; + wcc_data dirwcc; + post_op_attr poa; - nfs3_fill_post_op_fh3 (fh, &res->mkdir3res_u.resok.obj); - nfs3_map_deviceid_to_statdev (buf, deviceid); - poa = nfs3_stat_to_post_op_attr (buf); - nfs3_map_deviceid_to_statdev (preparent, deviceid); - nfs3_map_deviceid_to_statdev (postparent, deviceid); - dirwcc = nfs3_stat_to_wcc_data (preparent, postparent); - res->mkdir3res_u.resok.obj_attributes = poa; - res->mkdir3res_u.resok.dir_wcc = dirwcc; + memset(res, 0, sizeof(*res)); + res->status = stat; + if (stat != NFS3_OK) + return; + nfs3_fill_post_op_fh3(fh, &res->mkdir3res_u.resok.obj); + nfs3_map_deviceid_to_statdev(buf, deviceid); + poa = nfs3_stat_to_post_op_attr(buf); + nfs3_map_deviceid_to_statdev(preparent, deviceid); + nfs3_map_deviceid_to_statdev(postparent, deviceid); + dirwcc = nfs3_stat_to_wcc_data(preparent, postparent); + res->mkdir3res_u.resok.obj_attributes = poa; + res->mkdir3res_u.resok.dir_wcc = dirwcc; } - void -nfs3_prep_symlink3args (symlink3args *args, struct nfs3_fh *dirfh, char *name, - char *target) +nfs3_prep_symlink3args(symlink3args *args, struct nfs3_fh *dirfh, char *name, + char *target) { - memset (args, 0, sizeof (*args)); - args->where.dir.data.data_val = (void *)dirfh; - args->where.name = name; - args->symlink.symlink_data = target; + memset(args, 0, sizeof(*args)); + args->where.dir.data.data_val = (void *)dirfh; + args->where.name = name; + args->symlink.symlink_data = target; } - void -nfs3_fill_symlink3res (symlink3res *res, nfsstat3 stat, struct nfs3_fh *fh, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, uint64_t deviceid) +nfs3_fill_symlink3res(symlink3res *res, nfsstat3 stat, struct nfs3_fh *fh, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, uint64_t deviceid) { - wcc_data dirwcc; - post_op_attr poa; + wcc_data dirwcc; + post_op_attr poa; - memset (res, 0, sizeof (*res)); - res->status = stat; - if (stat != NFS3_OK) - return; - - nfs3_fill_post_op_fh3 (fh, &res->symlink3res_u.resok.obj); - nfs3_map_deviceid_to_statdev (buf, deviceid); - poa = nfs3_stat_to_post_op_attr (buf); - nfs3_map_deviceid_to_statdev (postparent, deviceid); - nfs3_map_deviceid_to_statdev (preparent, deviceid); - dirwcc = nfs3_stat_to_wcc_data (preparent, postparent); - res->symlink3res_u.resok.obj_attributes = poa; - res->symlink3res_u.resok.dir_wcc = dirwcc; + memset(res, 0, sizeof(*res)); + res->status = stat; + if (stat != NFS3_OK) + return; + nfs3_fill_post_op_fh3(fh, &res->symlink3res_u.resok.obj); + nfs3_map_deviceid_to_statdev(buf, deviceid); + poa = nfs3_stat_to_post_op_attr(buf); + nfs3_map_deviceid_to_statdev(postparent, deviceid); + nfs3_map_deviceid_to_statdev(preparent, deviceid); + dirwcc = nfs3_stat_to_wcc_data(preparent, postparent); + res->symlink3res_u.resok.obj_attributes = poa; + res->symlink3res_u.resok.dir_wcc = dirwcc; } - void -nfs3_prep_readlink3args (readlink3args *args, struct nfs3_fh *fh) +nfs3_prep_readlink3args(readlink3args *args, struct nfs3_fh *fh) { - - memset (args, 0, sizeof (*args)); - args->symlink.data.data_val = (void *)fh; + memset(args, 0, sizeof(*args)); + args->symlink.data.data_val = (void *)fh; } - void -nfs3_fill_readlink3res (readlink3res *res, nfsstat3 stat, char *path, - struct iatt *buf, uint64_t deviceid) +nfs3_fill_readlink3res(readlink3res *res, nfsstat3 stat, char *path, + struct iatt *buf, uint64_t deviceid) { - post_op_attr poa; + post_op_attr poa; - memset (res, 0, sizeof (*res)); - res->status = stat; + memset(res, 0, sizeof(*res)); + res->status = stat; - if (stat != NFS3_OK) - return; + if (stat != NFS3_OK) + return; - nfs3_map_deviceid_to_statdev (buf, deviceid); - poa = nfs3_stat_to_post_op_attr (buf); - res->readlink3res_u.resok.data = (void *)path; - res->readlink3res_u.resok.symlink_attributes = poa; + nfs3_map_deviceid_to_statdev(buf, deviceid); + poa = nfs3_stat_to_post_op_attr(buf); + res->readlink3res_u.resok.data = (void *)path; + res->readlink3res_u.resok.symlink_attributes = poa; } - void -nfs3_prep_mknod3args (mknod3args *args, struct nfs3_fh *fh, char *name) +nfs3_prep_mknod3args(mknod3args *args, struct nfs3_fh *fh, char *name) { - memset (args, 0, sizeof (*args)); - args->where.dir.data.data_val = (void *)fh; - args->where.name = name; - + memset(args, 0, sizeof(*args)); + args->where.dir.data.data_val = (void *)fh; + args->where.name = name; } void -nfs3_fill_mknod3res (mknod3res *res, nfsstat3 stat, struct nfs3_fh *fh, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, uint64_t deviceid) +nfs3_fill_mknod3res(mknod3res *res, nfsstat3 stat, struct nfs3_fh *fh, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, uint64_t deviceid) { - post_op_attr poa; - wcc_data wccdir; - - memset (res, 0, sizeof (*res)); - res->status = stat; - if (stat != NFS3_OK) - return; + post_op_attr poa; + wcc_data wccdir; - nfs3_fill_post_op_fh3 (fh, &res->mknod3res_u.resok.obj); - nfs3_map_deviceid_to_statdev (buf, deviceid); - poa = nfs3_stat_to_post_op_attr (buf); - nfs3_map_deviceid_to_statdev (preparent, deviceid); - nfs3_map_deviceid_to_statdev (postparent, deviceid); - wccdir = nfs3_stat_to_wcc_data (preparent, postparent); - res->mknod3res_u.resok.obj_attributes = poa; - res->mknod3res_u.resok.dir_wcc = wccdir; + memset(res, 0, sizeof(*res)); + res->status = stat; + if (stat != NFS3_OK) + return; + nfs3_fill_post_op_fh3(fh, &res->mknod3res_u.resok.obj); + nfs3_map_deviceid_to_statdev(buf, deviceid); + poa = nfs3_stat_to_post_op_attr(buf); + nfs3_map_deviceid_to_statdev(preparent, deviceid); + nfs3_map_deviceid_to_statdev(postparent, deviceid); + wccdir = nfs3_stat_to_wcc_data(preparent, postparent); + res->mknod3res_u.resok.obj_attributes = poa; + res->mknod3res_u.resok.dir_wcc = wccdir; } - void -nfs3_fill_remove3res (remove3res *res, nfsstat3 stat, struct iatt *preparent, - struct iatt *postparent, uint64_t deviceid) +nfs3_fill_remove3res(remove3res *res, nfsstat3 stat, struct iatt *preparent, + struct iatt *postparent, uint64_t deviceid) { - wcc_data dirwcc; + wcc_data dirwcc; - memset (res, 0, sizeof (*res)); - res->status = stat; - if (stat != NFS3_OK) - return; + memset(res, 0, sizeof(*res)); + res->status = stat; + if (stat != NFS3_OK) + return; - nfs3_map_deviceid_to_statdev (preparent, deviceid); - nfs3_map_deviceid_to_statdev (postparent, deviceid); - dirwcc = nfs3_stat_to_wcc_data (preparent, postparent); - res->remove3res_u.resok.dir_wcc = dirwcc; + nfs3_map_deviceid_to_statdev(preparent, deviceid); + nfs3_map_deviceid_to_statdev(postparent, deviceid); + dirwcc = nfs3_stat_to_wcc_data(preparent, postparent); + res->remove3res_u.resok.dir_wcc = dirwcc; } - void -nfs3_prep_remove3args (remove3args *args, struct nfs3_fh *fh, char *name) +nfs3_prep_remove3args(remove3args *args, struct nfs3_fh *fh, char *name) { - memset (args, 0, sizeof (*args)); - args->object.dir.data.data_val = (void *)fh; - args->object.name = name; + memset(args, 0, sizeof(*args)); + args->object.dir.data.data_val = (void *)fh; + args->object.name = name; } - void -nfs3_prep_rmdir3args (rmdir3args *args, struct nfs3_fh *fh, char *name) +nfs3_prep_rmdir3args(rmdir3args *args, struct nfs3_fh *fh, char *name) { - memset (args, 0, sizeof (*args)); - args->object.dir.data.data_val = (void *)fh; - args->object.name = name; + memset(args, 0, sizeof(*args)); + args->object.dir.data.data_val = (void *)fh; + args->object.name = name; } - void -nfs3_fill_rmdir3res (rmdir3res *res, nfsstat3 stat, struct iatt *preparent, - struct iatt *postparent, uint64_t deviceid) +nfs3_fill_rmdir3res(rmdir3res *res, nfsstat3 stat, struct iatt *preparent, + struct iatt *postparent, uint64_t deviceid) { - wcc_data dirwcc; - memset (res, 0, sizeof (*res)); - res->status = stat; + wcc_data dirwcc; + memset(res, 0, sizeof(*res)); + res->status = stat; - if (stat != NFS3_OK) - return; + if (stat != NFS3_OK) + return; - nfs3_map_deviceid_to_statdev (postparent, deviceid); - nfs3_map_deviceid_to_statdev (preparent, deviceid); - dirwcc = nfs3_stat_to_wcc_data (preparent, postparent); - res->rmdir3res_u.resok.dir_wcc = dirwcc; + nfs3_map_deviceid_to_statdev(postparent, deviceid); + nfs3_map_deviceid_to_statdev(preparent, deviceid); + dirwcc = nfs3_stat_to_wcc_data(preparent, postparent); + res->rmdir3res_u.resok.dir_wcc = dirwcc; } - void -nfs3_prep_link3args (link3args *args, struct nfs3_fh *target, - struct nfs3_fh * dirfh, char *name) +nfs3_prep_link3args(link3args *args, struct nfs3_fh *target, + struct nfs3_fh *dirfh, char *name) { - memset (args, 0, sizeof (*args)); - args->file.data.data_val = (void *)target; - args->link.dir.data.data_val = (void *)dirfh; - args->link.name = name; + memset(args, 0, sizeof(*args)); + args->file.data.data_val = (void *)target; + args->link.dir.data.data_val = (void *)dirfh; + args->link.name = name; } - void -nfs3_fill_link3res (link3res *res, nfsstat3 stat, struct iatt *buf, - struct iatt *preparent, struct iatt *postparent, - uint64_t deviceid) +nfs3_fill_link3res(link3res *res, nfsstat3 stat, struct iatt *buf, + struct iatt *preparent, struct iatt *postparent, + uint64_t deviceid) { - post_op_attr poa; - wcc_data dirwcc; + post_op_attr poa; + wcc_data dirwcc; - memset (res, 0, sizeof (*res)); - res->status = stat; - if (stat != NFS3_OK) - return; + memset(res, 0, sizeof(*res)); + res->status = stat; + if (stat != NFS3_OK) + return; - nfs3_map_deviceid_to_statdev (preparent, deviceid); - nfs3_map_deviceid_to_statdev (postparent, deviceid); - nfs3_map_deviceid_to_statdev (buf,deviceid); - poa = nfs3_stat_to_post_op_attr (buf); - dirwcc = nfs3_stat_to_wcc_data (preparent, postparent); - res->link3res_u.resok.file_attributes = poa; - res->link3res_u.resok.linkdir_wcc = dirwcc; + nfs3_map_deviceid_to_statdev(preparent, deviceid); + nfs3_map_deviceid_to_statdev(postparent, deviceid); + nfs3_map_deviceid_to_statdev(buf, deviceid); + poa = nfs3_stat_to_post_op_attr(buf); + dirwcc = nfs3_stat_to_wcc_data(preparent, postparent); + res->link3res_u.resok.file_attributes = poa; + res->link3res_u.resok.linkdir_wcc = dirwcc; } - - void -nfs3_prep_rename3args (rename3args *args, struct nfs3_fh *olddirfh, - char *oldname, struct nfs3_fh *newdirfh, char *newname) +nfs3_prep_rename3args(rename3args *args, struct nfs3_fh *olddirfh, + char *oldname, struct nfs3_fh *newdirfh, char *newname) { - memset (args, 0, sizeof (*args)); - - args->from.name = oldname; - args->from.dir.data.data_val = (void *)olddirfh; - args->to.name = newname; - args->to.dir.data.data_val = (void *)newdirfh; + memset(args, 0, sizeof(*args)); + args->from.name = oldname; + args->from.dir.data.data_val = (void *)olddirfh; + args->to.name = newname; + args->to.dir.data.data_val = (void *)newdirfh; } - void -nfs3_fill_rename3res (rename3res *res, nfsstat3 stat, struct iatt *buf, - struct iatt *preoldparent, struct iatt *postoldparent, - struct iatt *prenewparent, struct iatt *postnewparent, - uint64_t deviceid) +nfs3_fill_rename3res(rename3res *res, nfsstat3 stat, struct iatt *buf, + struct iatt *preoldparent, struct iatt *postoldparent, + struct iatt *prenewparent, struct iatt *postnewparent, + uint64_t deviceid) { - wcc_data dirwcc; + wcc_data dirwcc; - memset (res, 0, sizeof (*res)); - res->status = stat; - if (stat != NFS3_OK) - return; + memset(res, 0, sizeof(*res)); + res->status = stat; + if (stat != NFS3_OK) + return; - nfs3_map_deviceid_to_statdev (preoldparent, deviceid); - nfs3_map_deviceid_to_statdev (postoldparent, deviceid); - nfs3_map_deviceid_to_statdev (prenewparent, deviceid); - nfs3_map_deviceid_to_statdev (postnewparent, deviceid); - nfs3_map_deviceid_to_statdev (buf, deviceid); - dirwcc = nfs3_stat_to_wcc_data (preoldparent, postoldparent); - res->rename3res_u.resok.fromdir_wcc = dirwcc; - dirwcc = nfs3_stat_to_wcc_data (prenewparent, postnewparent); - res->rename3res_u.resok.todir_wcc = dirwcc; + nfs3_map_deviceid_to_statdev(preoldparent, deviceid); + nfs3_map_deviceid_to_statdev(postoldparent, deviceid); + nfs3_map_deviceid_to_statdev(prenewparent, deviceid); + nfs3_map_deviceid_to_statdev(postnewparent, deviceid); + nfs3_map_deviceid_to_statdev(buf, deviceid); + dirwcc = nfs3_stat_to_wcc_data(preoldparent, postoldparent); + res->rename3res_u.resok.fromdir_wcc = dirwcc; + dirwcc = nfs3_stat_to_wcc_data(prenewparent, postnewparent); + res->rename3res_u.resok.todir_wcc = dirwcc; } - void -nfs3_prep_write3args (write3args *args, struct nfs3_fh *fh) +nfs3_prep_write3args(write3args *args, struct nfs3_fh *fh) { - memset (args, 0, sizeof (*args)); - args->file.data.data_val = (void *)fh; + memset(args, 0, sizeof(*args)); + args->file.data.data_val = (void *)fh; } - void -nfs3_fill_write3res (write3res *res, nfsstat3 stat, count3 count, - stable_how stable, uint64_t wverf, struct iatt *prestat, - struct iatt *poststat, uint64_t deviceid) +nfs3_fill_write3res(write3res *res, nfsstat3 stat, count3 count, + stable_how stable, uint64_t wverf, struct iatt *prestat, + struct iatt *poststat, uint64_t deviceid) { - write3resok resok; - memset (res, 0, sizeof (*res)); - res->status = stat; - if (stat != NFS3_OK) - return; + write3resok resok; + memset(res, 0, sizeof(*res)); + res->status = stat; + if (stat != NFS3_OK) + return; - nfs3_map_deviceid_to_statdev (prestat, deviceid); - nfs3_map_deviceid_to_statdev (poststat, deviceid); - resok.file_wcc = nfs3_stat_to_wcc_data (prestat, poststat); - resok.count = count; - resok.committed = stable; - memcpy (resok.verf, &wverf, sizeof (wverf)); + nfs3_map_deviceid_to_statdev(prestat, deviceid); + nfs3_map_deviceid_to_statdev(poststat, deviceid); + resok.file_wcc = nfs3_stat_to_wcc_data(prestat, poststat); + resok.count = count; + resok.committed = stable; + memcpy(resok.verf, &wverf, sizeof(wverf)); - res->write3res_u.resok = resok; + res->write3res_u.resok = resok; } - void -nfs3_prep_commit3args (commit3args *args, struct nfs3_fh *fh) +nfs3_prep_commit3args(commit3args *args, struct nfs3_fh *fh) { - memset (args, 0, sizeof (*args)); - args->file.data.data_val = (void *)fh; + memset(args, 0, sizeof(*args)); + args->file.data.data_val = (void *)fh; } - void -nfs3_fill_commit3res (commit3res *res, nfsstat3 stat, uint64_t wverf, - struct iatt *prestat, struct iatt *poststat, - uint64_t deviceid) +nfs3_fill_commit3res(commit3res *res, nfsstat3 stat, uint64_t wverf, + struct iatt *prestat, struct iatt *poststat, + uint64_t deviceid) { - memset (res, 0, sizeof (*res)); - res->status = stat; - if (stat != NFS3_OK) - return; + memset(res, 0, sizeof(*res)); + res->status = stat; + if (stat != NFS3_OK) + return; - nfs3_map_deviceid_to_statdev (poststat, deviceid); - nfs3_map_deviceid_to_statdev (prestat, deviceid); - res->commit3res_u.resok.file_wcc = nfs3_stat_to_wcc_data (prestat, - poststat); - memcpy (res->commit3res_u.resok.verf, &wverf, sizeof (wverf)); + nfs3_map_deviceid_to_statdev(poststat, deviceid); + nfs3_map_deviceid_to_statdev(prestat, deviceid); + res->commit3res_u.resok.file_wcc = nfs3_stat_to_wcc_data(prestat, poststat); + memcpy(res->commit3res_u.resok.verf, &wverf, sizeof(wverf)); } void -nfs3_fill_read3res (read3res *res, nfsstat3 stat, count3 count, - struct iatt *poststat, int is_eof, uint64_t deviceid) +nfs3_fill_read3res(read3res *res, nfsstat3 stat, count3 count, + struct iatt *poststat, int is_eof, uint64_t deviceid) { - post_op_attr poa; + post_op_attr poa; - memset (res, 0, sizeof (*res)); - res->status = stat; - if (stat != NFS3_OK) - return; + memset(res, 0, sizeof(*res)); + res->status = stat; + if (stat != NFS3_OK) + return; - nfs3_map_deviceid_to_statdev (poststat, deviceid); - poa = nfs3_stat_to_post_op_attr (poststat); - res->read3res_u.resok.file_attributes = poa; - res->read3res_u.resok.count = count; - res->read3res_u.resok.eof = is_eof; - res->read3res_u.resok.data.data_len = count; + nfs3_map_deviceid_to_statdev(poststat, deviceid); + poa = nfs3_stat_to_post_op_attr(poststat); + res->read3res_u.resok.file_attributes = poa; + res->read3res_u.resok.count = count; + res->read3res_u.resok.eof = is_eof; + res->read3res_u.resok.data.data_len = count; } - void -nfs3_prep_read3args (read3args *args, struct nfs3_fh *fh) +nfs3_prep_read3args(read3args *args, struct nfs3_fh *fh) { - memset (args, 0, sizeof (*args)); - args->file.data.data_val = (void *)fh; + memset(args, 0, sizeof(*args)); + args->file.data.data_val = (void *)fh; } - void -nfs3_fill_pathconf3res (pathconf3res *res, nfsstat3 stat, struct iatt *buf, - uint64_t deviceid) +nfs3_fill_pathconf3res(pathconf3res *res, nfsstat3 stat, struct iatt *buf, + uint64_t deviceid) { - pathconf3resok resok; + pathconf3resok resok; - memset (res, 0, sizeof (*res)); - res->status = stat; - if (stat != NFS3_OK) - return; + memset(res, 0, sizeof(*res)); + res->status = stat; + if (stat != NFS3_OK) + return; - nfs3_map_deviceid_to_statdev (buf, deviceid); - resok.obj_attributes = nfs3_stat_to_post_op_attr (buf); - resok.linkmax = 256; - resok.name_max = NFS_NAME_MAX; - resok.no_trunc = TRUE; - resok.chown_restricted = FALSE; - resok.case_insensitive = FALSE; - resok.case_preserving = TRUE; + nfs3_map_deviceid_to_statdev(buf, deviceid); + resok.obj_attributes = nfs3_stat_to_post_op_attr(buf); + resok.linkmax = 256; + resok.name_max = NFS_NAME_MAX; + resok.no_trunc = TRUE; + resok.chown_restricted = FALSE; + resok.case_insensitive = FALSE; + resok.case_preserving = TRUE; - res->pathconf3res_u.resok = resok; + res->pathconf3res_u.resok = resok; } - void -nfs3_prep_pathconf3args (pathconf3args *args, struct nfs3_fh *fh) +nfs3_prep_pathconf3args(pathconf3args *args, struct nfs3_fh *fh) { - memset (args, 0, sizeof (*args)); - args->object.data.data_val = (void *)fh; + memset(args, 0, sizeof(*args)); + args->object.data.data_val = (void *)fh; } - int -nfs3_verify_dircookie (struct nfs3_state *nfs3, fd_t *dirfd, cookie3 cookie, - uint64_t cverf, nfsstat3 *stat) +nfs3_verify_dircookie(struct nfs3_state *nfs3, fd_t *dirfd, cookie3 cookie, + uint64_t cverf, nfsstat3 *stat) { - int ret = -1; + int ret = -1; - if ((!nfs3) || (!dirfd)) - return -1; + if ((!nfs3) || (!dirfd)) + return -1; - /* Can assume that this is first read on the dir, so cookie check - * is successful by default. - */ - if (cookie == 0) - return 0; - - gf_msg_trace (GF_NFS3, 0, "Verifying cookie: cverf: %"PRIu64 - ", cookie: %"PRIu64, cverf, cookie); - /* The cookie bad, no way cverf will be zero with a non-zero cookie. */ - if ((cverf == 0) && (cookie != 0)) { - gf_msg_trace (GF_NFS3, 0, "Bad cookie requested"); - if (stat) - *stat = NFS3ERR_BAD_COOKIE; - goto err; - } + /* Can assume that this is first read on the dir, so cookie check + * is successful by default. + */ + if (cookie == 0) + return 0; - /* Yes, its true, our cookie is simply the fd_t address. - * NOTE: We used have the check for cookieverf but VMWare client sends - * a readdirp requests even after we've told it that EOF has been - * reached on the directory. This causes a problem because we close a - * dir fd_t after reaching EOF. The next readdirp sent by VMWare - * contains the address of the closed fd_t as cookieverf. Since we - * closed that fd_t, this readdirp results in a new opendir which will - * give an fd_t that will fail this check below. - */ -/* if ((cverf != (uint64_t)dirfd)) { - gf_log (GF_NFS3, GF_LOG_TRACE, "Cookieverf does not match"); - if (stat) - *stat = NFS3ERR_BAD_COOKIE; - goto err; - } -*/ - gf_msg_trace (GF_NFS3, 0, "Cookie verified"); + gf_msg_trace(GF_NFS3, 0, + "Verifying cookie: cverf: %" PRIu64 ", cookie: %" PRIu64, + cverf, cookie); + /* The cookie bad, no way cverf will be zero with a non-zero cookie. */ + if ((cverf == 0) && (cookie != 0)) { + gf_msg_trace(GF_NFS3, 0, "Bad cookie requested"); if (stat) - *stat = NFS3_OK; - ret = 0; + *stat = NFS3ERR_BAD_COOKIE; + goto err; + } + + /* Yes, its true, our cookie is simply the fd_t address. + * NOTE: We used have the check for cookieverf but VMWare client sends + * a readdirp requests even after we've told it that EOF has been + * reached on the directory. This causes a problem because we close a + * dir fd_t after reaching EOF. The next readdirp sent by VMWare + * contains the address of the closed fd_t as cookieverf. Since we + * closed that fd_t, this readdirp results in a new opendir which will + * give an fd_t that will fail this check below. + */ + /* if ((cverf != (uint64_t)dirfd)) { + gf_log (GF_NFS3, GF_LOG_TRACE, "Cookieverf does not match"); + if (stat) + *stat = NFS3ERR_BAD_COOKIE; + goto err; + } + */ + gf_msg_trace(GF_NFS3, 0, "Cookie verified"); + if (stat) + *stat = NFS3_OK; + ret = 0; err: - return ret; + return ret; } - void -nfs3_stat_to_errstr (uint32_t xid, char *op, nfsstat3 stat, int pstat, - char *errstr, size_t len) +nfs3_stat_to_errstr(uint32_t xid, char *op, nfsstat3 stat, int pstat, + char *errstr, size_t len) { - if ((!op) || (!errstr)) - return; + if ((!op) || (!errstr)) + return; - snprintf (errstr, len, "XID: %x, %s: NFS: %d(%s), POSIX: %d(%s)", - xid, op,stat, nfsstat3_strerror (stat), pstat, - strerror (pstat)); + snprintf(errstr, len, "XID: %x, %s: NFS: %d(%s), POSIX: %d(%s)", xid, op, + stat, nfsstat3_strerror(stat), pstat, strerror(pstat)); } void -nfs3_log_common_call (uint32_t xid, char *op, struct nfs3_fh *fh) +nfs3_log_common_call(uint32_t xid, char *op, struct nfs3_fh *fh) { - char fhstr[1024]; + char fhstr[1024]; - if (THIS->ctx->log.loglevel < GF_LOG_DEBUG) - return; + if (THIS->ctx->log.loglevel < GF_LOG_DEBUG) + return; - nfs3_fh_to_str (fh, fhstr, sizeof (fhstr)); - gf_msg_debug (GF_NFS3, 0, "XID: %x, %s: args: %s", xid, op, fhstr); + nfs3_fh_to_str(fh, fhstr, sizeof(fhstr)); + gf_msg_debug(GF_NFS3, 0, "XID: %x, %s: args: %s", xid, op, fhstr); } - void -nfs3_log_fh_entry_call (uint32_t xid, char *op, struct nfs3_fh *fh, - char *name) +nfs3_log_fh_entry_call(uint32_t xid, char *op, struct nfs3_fh *fh, char *name) { - char fhstr[1024]; + char fhstr[1024]; - if (THIS->ctx->log.loglevel < GF_LOG_DEBUG) - return; - nfs3_fh_to_str (fh, fhstr, sizeof (fhstr)); - gf_msg_debug (GF_NFS3, 0, "XID: %x, %s: args: %s, name: %s", xid, - op, fhstr, name); + if (THIS->ctx->log.loglevel < GF_LOG_DEBUG) + return; + nfs3_fh_to_str(fh, fhstr, sizeof(fhstr)); + gf_msg_debug(GF_NFS3, 0, "XID: %x, %s: args: %s, name: %s", xid, op, fhstr, + name); } - void -nfs3_log_rename_call (uint32_t xid, struct nfs3_fh *src, char *sname, - struct nfs3_fh *dst, char *dname) +nfs3_log_rename_call(uint32_t xid, struct nfs3_fh *src, char *sname, + struct nfs3_fh *dst, char *dname) { - char sfhstr[1024]; - char dfhstr[1024]; + char sfhstr[1024]; + char dfhstr[1024]; - if (THIS->ctx->log.loglevel < GF_LOG_DEBUG) - return; - nfs3_fh_to_str (src, sfhstr, sizeof (sfhstr)); - nfs3_fh_to_str (dst, dfhstr, sizeof (dfhstr)); - gf_msg_debug (GF_NFS3, 0, "XID: %x, RENAME: args: Src: %s, " - "name: %s, Dst: %s, name: %s", xid, sfhstr, sname, - dfhstr, dname); + if (THIS->ctx->log.loglevel < GF_LOG_DEBUG) + return; + nfs3_fh_to_str(src, sfhstr, sizeof(sfhstr)); + nfs3_fh_to_str(dst, dfhstr, sizeof(dfhstr)); + gf_msg_debug(GF_NFS3, 0, + "XID: %x, RENAME: args: Src: %s, " + "name: %s, Dst: %s, name: %s", + xid, sfhstr, sname, dfhstr, dname); } - - void -nfs3_log_create_call (uint32_t xid, struct nfs3_fh *fh, char *name, - createmode3 mode) +nfs3_log_create_call(uint32_t xid, struct nfs3_fh *fh, char *name, + createmode3 mode) { - char fhstr[1024]; - char *modestr = NULL; - char exclmode[] = "EXCLUSIVE"; - char unchkd[] = "UNCHECKED"; - char guarded[] = "GUARDED"; + char fhstr[1024]; + char *modestr = NULL; + char exclmode[] = "EXCLUSIVE"; + char unchkd[] = "UNCHECKED"; + char guarded[] = "GUARDED"; - if (THIS->ctx->log.loglevel < GF_LOG_DEBUG) - return; - nfs3_fh_to_str (fh, fhstr, sizeof (fhstr)); - if (mode == EXCLUSIVE) - modestr = exclmode; - else if (mode == GUARDED) - modestr = guarded; - else - modestr = unchkd; + if (THIS->ctx->log.loglevel < GF_LOG_DEBUG) + return; + nfs3_fh_to_str(fh, fhstr, sizeof(fhstr)); + if (mode == EXCLUSIVE) + modestr = exclmode; + else if (mode == GUARDED) + modestr = guarded; + else + modestr = unchkd; - gf_msg_debug (GF_NFS3, 0, "XID: %x, CREATE: args: %s, name: %s," - " mode: %s", xid, fhstr, name, modestr); + gf_msg_debug(GF_NFS3, 0, + "XID: %x, CREATE: args: %s, name: %s," + " mode: %s", + xid, fhstr, name, modestr); } - void -nfs3_log_mknod_call (uint32_t xid, struct nfs3_fh *fh, char *name, int type) +nfs3_log_mknod_call(uint32_t xid, struct nfs3_fh *fh, char *name, int type) { - char fhstr[1024]; - char *modestr = NULL; - char chr[] = "CHAR"; - char blk[] = "BLK"; - char sock[] = "SOCK"; - char fifo[] = "FIFO"; + char fhstr[1024]; + char *modestr = NULL; + char chr[] = "CHAR"; + char blk[] = "BLK"; + char sock[] = "SOCK"; + char fifo[] = "FIFO"; - if (THIS->ctx->log.loglevel < GF_LOG_DEBUG) - return; - nfs3_fh_to_str (fh, fhstr, sizeof (fhstr)); - if (type == NF3CHR) - modestr = chr; - else if (type == NF3BLK) - modestr = blk; - else if (type == NF3SOCK) - modestr = sock; - else - modestr = fifo; + if (THIS->ctx->log.loglevel < GF_LOG_DEBUG) + return; + nfs3_fh_to_str(fh, fhstr, sizeof(fhstr)); + if (type == NF3CHR) + modestr = chr; + else if (type == NF3BLK) + modestr = blk; + else if (type == NF3SOCK) + modestr = sock; + else + modestr = fifo; - gf_msg_debug (GF_NFS3, 0, "XID: %x, MKNOD: args: %s, name: %s," - " type: %s", xid, fhstr, name, modestr); + gf_msg_debug(GF_NFS3, 0, + "XID: %x, MKNOD: args: %s, name: %s," + " type: %s", + xid, fhstr, name, modestr); } - - void -nfs3_log_symlink_call (uint32_t xid, struct nfs3_fh *fh, char *name, char *tgt) +nfs3_log_symlink_call(uint32_t xid, struct nfs3_fh *fh, char *name, char *tgt) { - char fhstr[1024]; + char fhstr[1024]; - if (THIS->ctx->log.loglevel < GF_LOG_DEBUG) - return; - nfs3_fh_to_str (fh, fhstr, sizeof (fhstr)); - gf_msg_debug (GF_NFS3, 0, "XID: %x, SYMLINK: args: %s, name: %s," - " target: %s", xid, fhstr, name, tgt); + if (THIS->ctx->log.loglevel < GF_LOG_DEBUG) + return; + nfs3_fh_to_str(fh, fhstr, sizeof(fhstr)); + gf_msg_debug(GF_NFS3, 0, + "XID: %x, SYMLINK: args: %s, name: %s," + " target: %s", + xid, fhstr, name, tgt); } - void -nfs3_log_link_call (uint32_t xid, struct nfs3_fh *fh, char *name, - struct nfs3_fh *tgt) +nfs3_log_link_call(uint32_t xid, struct nfs3_fh *fh, char *name, + struct nfs3_fh *tgt) { - char dfhstr[1024]; - char tfhstr[1024]; + char dfhstr[1024]; + char tfhstr[1024]; - if (THIS->ctx->log.loglevel < GF_LOG_DEBUG) - return; - nfs3_fh_to_str (fh, dfhstr, sizeof (dfhstr)); - nfs3_fh_to_str (tgt, tfhstr, sizeof (tfhstr)); - gf_msg_debug (GF_NFS3, 0, "XID: %x, LINK: args: %s, name: %s," - " target: %s", xid, dfhstr, name, tfhstr); + if (THIS->ctx->log.loglevel < GF_LOG_DEBUG) + return; + nfs3_fh_to_str(fh, dfhstr, sizeof(dfhstr)); + nfs3_fh_to_str(tgt, tfhstr, sizeof(tfhstr)); + gf_msg_debug(GF_NFS3, 0, + "XID: %x, LINK: args: %s, name: %s," + " target: %s", + xid, dfhstr, name, tfhstr); } - void -nfs3_log_rw_call (uint32_t xid, char *op, struct nfs3_fh *fh, offset3 offt, - count3 count, int stablewrite) +nfs3_log_rw_call(uint32_t xid, char *op, struct nfs3_fh *fh, offset3 offt, + count3 count, int stablewrite) { - char fhstr[1024]; - - if (THIS->ctx->log.loglevel < GF_LOG_DEBUG) - return; - nfs3_fh_to_str (fh, fhstr, sizeof (fhstr)); - if (stablewrite == -1) - gf_msg_debug (GF_NFS3, 0, "XID: %x, %s: args: %s, offset:" - " %"PRIu64", count: %"PRIu32, xid, op, fhstr, - offt, count); - else - gf_msg_debug (GF_NFS3, 0, "XID: %x, %s: args: %s, offset:" - " %"PRIu64", count: %"PRIu32", %s", xid, op, - fhstr, offt, count, - (stablewrite == UNSTABLE)?"UNSTABLE":"STABLE"); + char fhstr[1024]; + if (THIS->ctx->log.loglevel < GF_LOG_DEBUG) + return; + nfs3_fh_to_str(fh, fhstr, sizeof(fhstr)); + if (stablewrite == -1) + gf_msg_debug(GF_NFS3, 0, + "XID: %x, %s: args: %s, offset:" + " %" PRIu64 ", count: %" PRIu32, + xid, op, fhstr, offt, count); + else + gf_msg_debug(GF_NFS3, 0, + "XID: %x, %s: args: %s, offset:" + " %" PRIu64 ", count: %" PRIu32 ", %s", + xid, op, fhstr, offt, count, + (stablewrite == UNSTABLE) ? "UNSTABLE" : "STABLE"); } - int -nfs3_getattr_loglevel (nfsstat3 stat) { - - int ll = GF_LOG_DEBUG; - - switch (stat) { +nfs3_getattr_loglevel(nfsstat3 stat) +{ + int ll = GF_LOG_DEBUG; + switch (stat) { case NFS3ERR_PERM: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOENT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ACCES: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_EXIST: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_XDEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NODEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_IO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NXIO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ISDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_INVAL: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOSPC: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ROFS: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_FBIG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_MLINK: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NAMETOOLONG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTEMPTY: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_SERVERFAULT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTSUPP: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_BADHANDLE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_STALE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_DQUOT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; default: - ll = GF_LOG_DEBUG; - break; - } + ll = GF_LOG_DEBUG; + break; + } - return ll; + return ll; } - int -nfs3_setattr_loglevel (nfsstat3 stat) { - - int ll = GF_LOG_DEBUG; - - switch (stat) { +nfs3_setattr_loglevel(nfsstat3 stat) +{ + int ll = GF_LOG_DEBUG; + switch (stat) { case NFS3ERR_NOENT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_EXIST: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_XDEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NODEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_IO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NXIO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ISDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_INVAL: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOSPC: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ROFS: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_FBIG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_MLINK: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NAMETOOLONG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTEMPTY: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_SERVERFAULT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTSUPP: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_BADHANDLE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_STALE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_DQUOT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; default: - ll = GF_LOG_DEBUG; - break; - } + ll = GF_LOG_DEBUG; + break; + } - return ll; + return ll; } - int -nfs3_lookup_loglevel (nfsstat3 stat) { - - int ll = GF_LOG_DEBUG; - - switch (stat) { +nfs3_lookup_loglevel(nfsstat3 stat) +{ + int ll = GF_LOG_DEBUG; + switch (stat) { case NFS3ERR_PERM: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ACCES: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_EXIST: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_XDEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NODEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_IO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NXIO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ISDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_INVAL: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOSPC: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ROFS: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_FBIG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_MLINK: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NAMETOOLONG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTEMPTY: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_SERVERFAULT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTSUPP: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_BADHANDLE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_STALE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_DQUOT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; default: - ll = GF_LOG_DEBUG; - break; - } + ll = GF_LOG_DEBUG; + break; + } - return ll; + return ll; } - int -nfs3_access_loglevel (nfsstat3 stat) { - - int ll = GF_LOG_DEBUG; - - switch (stat) { +nfs3_access_loglevel(nfsstat3 stat) +{ + int ll = GF_LOG_DEBUG; + switch (stat) { case NFS3ERR_NOENT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_EXIST: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_XDEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NODEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_IO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NXIO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ISDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_INVAL: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOSPC: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ROFS: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_FBIG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_MLINK: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NAMETOOLONG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTEMPTY: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_SERVERFAULT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTSUPP: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_BADHANDLE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_STALE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_DQUOT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; default: - ll = GF_LOG_DEBUG; - break; - } + ll = GF_LOG_DEBUG; + break; + } - return ll; + return ll; } - int -nfs3_readlink_loglevel (nfsstat3 stat) { - - int ll = GF_LOG_DEBUG; - - switch (stat) { +nfs3_readlink_loglevel(nfsstat3 stat) +{ + int ll = GF_LOG_DEBUG; + switch (stat) { case NFS3ERR_EXIST: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_XDEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NODEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_IO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NXIO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ISDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_INVAL: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOSPC: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ROFS: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_FBIG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_MLINK: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTEMPTY: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_SERVERFAULT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTSUPP: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_BADHANDLE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_STALE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_DQUOT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; default: - ll = GF_LOG_DEBUG; - break; - } + ll = GF_LOG_DEBUG; + break; + } - return ll; + return ll; } int -nfs3_read_loglevel (nfsstat3 stat) { - - int ll = GF_LOG_DEBUG; - - switch (stat) { +nfs3_read_loglevel(nfsstat3 stat) +{ + int ll = GF_LOG_DEBUG; + switch (stat) { case NFS3ERR_NOENT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_EXIST: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_XDEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NODEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_IO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NXIO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ISDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_INVAL: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOSPC: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ROFS: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_FBIG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_MLINK: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NAMETOOLONG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTEMPTY: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_SERVERFAULT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTSUPP: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_BADHANDLE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_STALE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_DQUOT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; default: - ll = GF_LOG_DEBUG; - break; - } + ll = GF_LOG_DEBUG; + break; + } - return ll; + return ll; } - int -nfs3_write_loglevel (nfsstat3 stat) { - - int ll = GF_LOG_DEBUG; - - switch (stat) { +nfs3_write_loglevel(nfsstat3 stat) +{ + int ll = GF_LOG_DEBUG; + switch (stat) { case NFS3ERR_NOENT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_EXIST: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_XDEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NODEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_IO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NXIO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ISDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_INVAL: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOSPC: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ROFS: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_FBIG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_MLINK: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NAMETOOLONG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTEMPTY: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_SERVERFAULT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTSUPP: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_BADHANDLE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_STALE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_DQUOT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; default: - ll = GF_LOG_DEBUG; - break; - } + ll = GF_LOG_DEBUG; + break; + } - return ll; + return ll; } - int -nfs3_create_loglevel (nfsstat3 stat) { - - int ll = GF_LOG_DEBUG; - - switch (stat) { +nfs3_create_loglevel(nfsstat3 stat) +{ + int ll = GF_LOG_DEBUG; + switch (stat) { case NFS3ERR_NOENT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_EXIST: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_XDEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NODEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_IO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NXIO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ISDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_INVAL: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_FBIG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_MLINK: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTEMPTY: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_SERVERFAULT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTSUPP: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_BADHANDLE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_STALE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; default: - ll = GF_LOG_DEBUG; - break; - } + ll = GF_LOG_DEBUG; + break; + } - return ll; + return ll; } - int -nfs3_mkdir_loglevel (nfsstat3 stat) { - - int ll = GF_LOG_DEBUG; - - switch (stat) { +nfs3_mkdir_loglevel(nfsstat3 stat) +{ + int ll = GF_LOG_DEBUG; + switch (stat) { case NFS3ERR_NOENT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_XDEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NODEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_IO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NXIO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ISDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_INVAL: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_FBIG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_MLINK: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTEMPTY: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_SERVERFAULT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTSUPP: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_BADHANDLE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_STALE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_DQUOT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; default: - ll = GF_LOG_DEBUG; - break; - } + ll = GF_LOG_DEBUG; + break; + } - return ll; + return ll; } - int -nfs3_symlink_loglevel (nfsstat3 stat) { - - int ll = GF_LOG_DEBUG; - - switch (stat) { +nfs3_symlink_loglevel(nfsstat3 stat) +{ + int ll = GF_LOG_DEBUG; + switch (stat) { case NFS3ERR_XDEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NODEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_IO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NXIO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ISDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_INVAL: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_FBIG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_MLINK: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTEMPTY: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_SERVERFAULT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTSUPP: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_BADHANDLE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_STALE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_DQUOT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; default: - ll = GF_LOG_DEBUG; - break; - } + ll = GF_LOG_DEBUG; + break; + } - return ll; + return ll; } - int -nfs3_mknod_loglevel (nfsstat3 stat) { - - int ll = GF_LOG_DEBUG; - - switch (stat) { +nfs3_mknod_loglevel(nfsstat3 stat) +{ + int ll = GF_LOG_DEBUG; + switch (stat) { case NFS3ERR_NOENT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_XDEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NODEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_IO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NXIO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ISDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_INVAL: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_FBIG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_MLINK: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTEMPTY: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_SERVERFAULT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTSUPP: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_BADHANDLE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_STALE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; default: - ll = GF_LOG_DEBUG; - break; - } + ll = GF_LOG_DEBUG; + break; + } - return ll; + return ll; } int -nfs3_remove_loglevel (nfsstat3 stat) { - - int ll = GF_LOG_DEBUG; - - switch (stat) { +nfs3_remove_loglevel(nfsstat3 stat) +{ + int ll = GF_LOG_DEBUG; + switch (stat) { case NFS3ERR_EXIST: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_XDEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NODEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_IO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NXIO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_INVAL: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOSPC: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_FBIG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_MLINK: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_SERVERFAULT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTSUPP: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_BADHANDLE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_STALE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_DQUOT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; default: - ll = GF_LOG_DEBUG; - break; - } + ll = GF_LOG_DEBUG; + break; + } - return ll; + return ll; } - int -nfs3_rmdir_loglevel (nfsstat3 stat) { - - int ll = GF_LOG_DEBUG; - - switch (stat) { +nfs3_rmdir_loglevel(nfsstat3 stat) +{ + int ll = GF_LOG_DEBUG; + switch (stat) { case NFS3ERR_EXIST: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_XDEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NODEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_IO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NXIO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_INVAL: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOSPC: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_FBIG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_MLINK: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_SERVERFAULT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTSUPP: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_BADHANDLE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_STALE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_DQUOT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; default: - ll = GF_LOG_DEBUG; - break; - } + ll = GF_LOG_DEBUG; + break; + } - return ll; + return ll; } - int -nfs3_rename_loglevel (nfsstat3 stat) { - - int ll = GF_LOG_DEBUG; - - switch (stat) { +nfs3_rename_loglevel(nfsstat3 stat) +{ + int ll = GF_LOG_DEBUG; + switch (stat) { case NFS3ERR_XDEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NODEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_IO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NXIO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ISDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_INVAL: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOSPC: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_FBIG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_MLINK: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTEMPTY: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_SERVERFAULT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTSUPP: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_BADHANDLE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_STALE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_DQUOT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; default: - ll = GF_LOG_DEBUG; - break; - } + ll = GF_LOG_DEBUG; + break; + } - return ll; + return ll; } - int -nfs3_link_loglevel (nfsstat3 stat) { - - int ll = GF_LOG_DEBUG; - - switch (stat) { +nfs3_link_loglevel(nfsstat3 stat) +{ + int ll = GF_LOG_DEBUG; + switch (stat) { case NFS3ERR_XDEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NODEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_IO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NXIO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_INVAL: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_FBIG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_MLINK: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTEMPTY: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_SERVERFAULT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTSUPP: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_BADHANDLE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_STALE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_DQUOT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; default: - ll = GF_LOG_DEBUG; - break; - } + ll = GF_LOG_DEBUG; + break; + } - return ll; + return ll; } - int -nfs3_readdir_loglevel (nfsstat3 stat) { - - int ll = GF_LOG_DEBUG; - - switch (stat) { +nfs3_readdir_loglevel(nfsstat3 stat) +{ + int ll = GF_LOG_DEBUG; + switch (stat) { case NFS3ERR_NOENT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_EXIST: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_XDEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NODEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_IO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NXIO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ISDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_INVAL: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOSPC: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ROFS: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_FBIG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_MLINK: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NAMETOOLONG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTEMPTY: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_SERVERFAULT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTSUPP: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_BADHANDLE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_STALE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_DQUOT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; default: - ll = GF_LOG_DEBUG; - break; - } + ll = GF_LOG_DEBUG; + break; + } - return ll; + return ll; } - int -nfs3_fsstat_loglevel (nfsstat3 stat) { - - int ll = GF_LOG_DEBUG; - - switch (stat) { +nfs3_fsstat_loglevel(nfsstat3 stat) +{ + int ll = GF_LOG_DEBUG; + switch (stat) { case NFS3ERR_PERM: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOENT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ACCES: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_EXIST: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_XDEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NODEV: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_IO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NXIO: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ISDIR: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_INVAL: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOSPC: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_ROFS: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_FBIG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_MLINK: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NAMETOOLONG: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTEMPTY: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_SERVERFAULT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_NOTSUPP: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_BADHANDLE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_STALE: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; case NFS3ERR_DQUOT: - ll = GF_LOG_WARNING; - break; + ll = GF_LOG_WARNING; + break; default: - ll = GF_LOG_DEBUG; - break; - } + ll = GF_LOG_DEBUG; + break; + } - return ll; + return ll; } struct nfs3op_str { - int op; - char str[100]; + int op; + char str[100]; }; struct nfs3op_str nfs3op_strings[] = { - { NFS3_NULL, "NULL"}, - { NFS3_GETATTR, "GETATTR"}, - { NFS3_SETATTR, "SETATTR"}, - { NFS3_LOOKUP, "LOOKUP"}, - { NFS3_ACCESS, "ACCESS"}, - { NFS3_READLINK, "READLINK"}, - { NFS3_READ, "READ"}, - { NFS3_WRITE, "WRITE"}, - { NFS3_CREATE, "CREATE"}, - { NFS3_MKDIR, "MKDIR"}, - { NFS3_SYMLINK, "SYMLINK"}, - { NFS3_MKNOD, "MKNOD"}, - { NFS3_REMOVE, "REMOVE"}, - { NFS3_RMDIR, "RMDIR"}, - { NFS3_RENAME, "RENAME"}, - { NFS3_LINK, "LINK"}, - { NFS3_READDIR, "READDIR"}, - { NFS3_READDIRP, "READDIRP"}, - { NFS3_FSSTAT, "FSSTAT"}, - { NFS3_FSINFO, "FSINFO"}, - { NFS3_PATHCONF, "PATHCONF"}, - { NFS3_COMMIT, "COMMIT"}, + {NFS3_NULL, "NULL"}, {NFS3_GETATTR, "GETATTR"}, + {NFS3_SETATTR, "SETATTR"}, {NFS3_LOOKUP, "LOOKUP"}, + {NFS3_ACCESS, "ACCESS"}, {NFS3_READLINK, "READLINK"}, + {NFS3_READ, "READ"}, {NFS3_WRITE, "WRITE"}, + {NFS3_CREATE, "CREATE"}, {NFS3_MKDIR, "MKDIR"}, + {NFS3_SYMLINK, "SYMLINK"}, {NFS3_MKNOD, "MKNOD"}, + {NFS3_REMOVE, "REMOVE"}, {NFS3_RMDIR, "RMDIR"}, + {NFS3_RENAME, "RENAME"}, {NFS3_LINK, "LINK"}, + {NFS3_READDIR, "READDIR"}, {NFS3_READDIRP, "READDIRP"}, + {NFS3_FSSTAT, "FSSTAT"}, {NFS3_FSINFO, "FSINFO"}, + {NFS3_PATHCONF, "PATHCONF"}, {NFS3_COMMIT, "COMMIT"}, }; int -nfs3_loglevel (int nfs_op, nfsstat3 stat) { - - int ll = GF_LOG_DEBUG; +nfs3_loglevel(int nfs_op, nfsstat3 stat) +{ + int ll = GF_LOG_DEBUG; - switch (nfs_op) { - case NFS3_GETATTR: - ll = nfs3_getattr_loglevel (stat); - break; + switch (nfs_op) { + case NFS3_GETATTR: + ll = nfs3_getattr_loglevel(stat); + break; - case NFS3_SETATTR: - ll = nfs3_setattr_loglevel (stat); - break; + case NFS3_SETATTR: + ll = nfs3_setattr_loglevel(stat); + break; - case NFS3_LOOKUP: - ll = nfs3_lookup_loglevel (stat); - break; + case NFS3_LOOKUP: + ll = nfs3_lookup_loglevel(stat); + break; - case NFS3_ACCESS: - ll = nfs3_access_loglevel (stat); - break; + case NFS3_ACCESS: + ll = nfs3_access_loglevel(stat); + break; - case NFS3_READLINK: - ll = nfs3_readlink_loglevel (stat); - break; + case NFS3_READLINK: + ll = nfs3_readlink_loglevel(stat); + break; - case NFS3_READ: - ll = nfs3_read_loglevel (stat); - break; + case NFS3_READ: + ll = nfs3_read_loglevel(stat); + break; - case NFS3_WRITE: - ll = nfs3_write_loglevel (stat); - break; + case NFS3_WRITE: + ll = nfs3_write_loglevel(stat); + break; - case NFS3_CREATE: - ll = nfs3_create_loglevel (stat); - break; + case NFS3_CREATE: + ll = nfs3_create_loglevel(stat); + break; - case NFS3_MKDIR: - ll = nfs3_mkdir_loglevel (stat); - break; + case NFS3_MKDIR: + ll = nfs3_mkdir_loglevel(stat); + break; - case NFS3_SYMLINK: - ll = nfs3_symlink_loglevel (stat); - break; + case NFS3_SYMLINK: + ll = nfs3_symlink_loglevel(stat); + break; - case NFS3_MKNOD: - ll = nfs3_mknod_loglevel (stat); - break; + case NFS3_MKNOD: + ll = nfs3_mknod_loglevel(stat); + break; - case NFS3_REMOVE: - ll = nfs3_remove_loglevel (stat); - break; + case NFS3_REMOVE: + ll = nfs3_remove_loglevel(stat); + break; - case NFS3_RMDIR: - ll = nfs3_rmdir_loglevel (stat); - break; + case NFS3_RMDIR: + ll = nfs3_rmdir_loglevel(stat); + break; - case NFS3_RENAME: - ll = nfs3_rename_loglevel (stat); - break; + case NFS3_RENAME: + ll = nfs3_rename_loglevel(stat); + break; - case NFS3_LINK: - ll = nfs3_link_loglevel (stat); - break; + case NFS3_LINK: + ll = nfs3_link_loglevel(stat); + break; - case NFS3_READDIR: - ll = nfs3_readdir_loglevel (stat); - break; + case NFS3_READDIR: + ll = nfs3_readdir_loglevel(stat); + break; - case NFS3_READDIRP: - ll = nfs3_readdir_loglevel (stat); - break; + case NFS3_READDIRP: + ll = nfs3_readdir_loglevel(stat); + break; - case NFS3_FSSTAT: - ll = nfs3_fsstat_loglevel (stat); - break; + case NFS3_FSSTAT: + ll = nfs3_fsstat_loglevel(stat); + break; - case NFS3_FSINFO: - ll = nfs3_fsstat_loglevel (stat); - break; + case NFS3_FSINFO: + ll = nfs3_fsstat_loglevel(stat); + break; - case NFS3_PATHCONF: - ll = nfs3_fsstat_loglevel (stat); - break; + case NFS3_PATHCONF: + ll = nfs3_fsstat_loglevel(stat); + break; - case NFS3_COMMIT: - ll = nfs3_write_loglevel (stat); - break; + case NFS3_COMMIT: + ll = nfs3_write_loglevel(stat); + break; - default: - ll = GF_LOG_DEBUG; - break; - } + default: + ll = GF_LOG_DEBUG; + break; + } - return ll; + return ll; } void -nfs3_log_common_res (uint32_t xid, int op, nfsstat3 stat, int pstat, - const char *path) +nfs3_log_common_res(uint32_t xid, int op, nfsstat3 stat, int pstat, + const char *path) { - char errstr[1024]; - int ll = nfs3_loglevel (op, stat); - - if (THIS->ctx->log.loglevel < ll) - return; - nfs3_stat_to_errstr (xid, nfs3op_strings[op].str, stat, pstat, errstr, sizeof (errstr)); - if (ll == GF_LOG_DEBUG) - gf_msg_debug (GF_NFS3, 0, "%s => (%s)", path, - errstr); - else - gf_msg (GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR, - "%s => (%s)", path, errstr); + char errstr[1024]; + int ll = nfs3_loglevel(op, stat); + if (THIS->ctx->log.loglevel < ll) + return; + nfs3_stat_to_errstr(xid, nfs3op_strings[op].str, stat, pstat, errstr, + sizeof(errstr)); + if (ll == GF_LOG_DEBUG) + gf_msg_debug(GF_NFS3, 0, "%s => (%s)", path, errstr); + else + gf_msg(GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR, "%s => (%s)", path, + errstr); } void -nfs3_log_readlink_res (uint32_t xid, nfsstat3 stat, int pstat, char *linkpath, - const char *path) +nfs3_log_readlink_res(uint32_t xid, nfsstat3 stat, int pstat, char *linkpath, + const char *path) { - char errstr[1024]; - int ll = nfs3_loglevel (NFS3_READLINK, stat); - - if (THIS->ctx->log.loglevel < ll) - return; + char errstr[1024]; + int ll = nfs3_loglevel(NFS3_READLINK, stat); - nfs3_stat_to_errstr (xid, "READLINK", stat, pstat, errstr, sizeof (errstr)); - if (ll == GF_LOG_DEBUG) - gf_msg_debug (GF_NFS3, 0, "%s => (%s), target: %s", path, - errstr, linkpath); - else - gf_msg (GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR, - "%s => (%s) target: %s" , path, - errstr, linkpath); -} - -void -nfs3_log_read_res (uint32_t xid, nfsstat3 stat, int pstat, count3 count, - int is_eof, struct iovec *vec, - int32_t veccount, const char *path) -{ - char errstr[1024]; - int ll = GF_LOG_DEBUG; - - ll = nfs3_loglevel (NFS3_READ, stat); - if (THIS->ctx->log.loglevel < ll) - return; - nfs3_stat_to_errstr (xid, "READ", stat, pstat, errstr, sizeof (errstr)); - if (vec) - if (ll == GF_LOG_DEBUG) - gf_msg_debug (GF_NFS3, 0, - "%s => (%s), count: %"PRIu32", is_eof:" - " %d, vector: count: %d, len: %zd", path, - errstr, count, is_eof, veccount, - vec->iov_len); - else - gf_msg (GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR, - "%s => (%s), count: %"PRIu32", is_eof:" - " %d, vector: count: %d, len: %zd", path, - errstr, count, is_eof, veccount, vec->iov_len); - else - if (ll == GF_LOG_DEBUG) - gf_msg_debug (GF_NFS3, 0, - "%s => (%s), count: %"PRIu32", is_eof:" - " %d", path, errstr, count, is_eof); - else - gf_msg (GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR, - "%s => (%s), count: %"PRIu32", is_eof:" - " %d", path, errstr, count, is_eof); + if (THIS->ctx->log.loglevel < ll) + return; + nfs3_stat_to_errstr(xid, "READLINK", stat, pstat, errstr, sizeof(errstr)); + if (ll == GF_LOG_DEBUG) + gf_msg_debug(GF_NFS3, 0, "%s => (%s), target: %s", path, errstr, + linkpath); + else + gf_msg(GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR, "%s => (%s) target: %s", + path, errstr, linkpath); } void -nfs3_log_write_res (uint32_t xid, nfsstat3 stat, int pstat, count3 count, - int stable, uint64_t wverf, const char *path) +nfs3_log_read_res(uint32_t xid, nfsstat3 stat, int pstat, count3 count, + int is_eof, struct iovec *vec, int32_t veccount, + const char *path) { - char errstr[1024]; - int ll = nfs3_loglevel (NFS3_WRITE, stat); - - if (THIS->ctx->log.loglevel < ll) - return; + char errstr[1024]; + int ll = GF_LOG_DEBUG; - nfs3_stat_to_errstr (xid, "WRITE", stat, pstat, errstr, sizeof (errstr)); + ll = nfs3_loglevel(NFS3_READ, stat); + if (THIS->ctx->log.loglevel < ll) + return; + nfs3_stat_to_errstr(xid, "READ", stat, pstat, errstr, sizeof(errstr)); + if (vec) if (ll == GF_LOG_DEBUG) - gf_msg_debug (GF_NFS3, 0, - "%s => (%s), count: %"PRIu32", %s,wverf: " - "%"PRIu64, path, errstr, count, - (stable == UNSTABLE)?"UNSTABLE":"STABLE", wverf); + gf_msg_debug(GF_NFS3, 0, + "%s => (%s), count: %" PRIu32 + ", is_eof:" + " %d, vector: count: %d, len: %zd", + path, errstr, count, is_eof, veccount, vec->iov_len); else - gf_msg (GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR, - "%s => (%s), count: %"PRIu32", %s,wverf: %"PRIu64 - , path, errstr, count, - (stable == UNSTABLE)?"UNSTABLE":"STABLE", wverf); + gf_msg(GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR, + "%s => (%s), count: %" PRIu32 + ", is_eof:" + " %d, vector: count: %d, len: %zd", + path, errstr, count, is_eof, veccount, vec->iov_len); + else if (ll == GF_LOG_DEBUG) + gf_msg_debug(GF_NFS3, 0, + "%s => (%s), count: %" PRIu32 + ", is_eof:" + " %d", + path, errstr, count, is_eof); + else + gf_msg(GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR, + "%s => (%s), count: %" PRIu32 + ", is_eof:" + " %d", + path, errstr, count, is_eof); +} + +void +nfs3_log_write_res(uint32_t xid, nfsstat3 stat, int pstat, count3 count, + int stable, uint64_t wverf, const char *path) +{ + char errstr[1024]; + int ll = nfs3_loglevel(NFS3_WRITE, stat); + + if (THIS->ctx->log.loglevel < ll) + return; + + nfs3_stat_to_errstr(xid, "WRITE", stat, pstat, errstr, sizeof(errstr)); + if (ll == GF_LOG_DEBUG) + gf_msg_debug(GF_NFS3, 0, + "%s => (%s), count: %" PRIu32 + ", %s,wverf: " + "%" PRIu64, + path, errstr, count, + (stable == UNSTABLE) ? "UNSTABLE" : "STABLE", wverf); + else + gf_msg(GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR, + "%s => (%s), count: %" PRIu32 ", %s,wverf: %" PRIu64, path, + errstr, count, (stable == UNSTABLE) ? "UNSTABLE" : "STABLE", + wverf); } void -nfs3_log_newfh_res (uint32_t xid, int op, nfsstat3 stat, int pstat, - struct nfs3_fh *newfh, const char *path) +nfs3_log_newfh_res(uint32_t xid, int op, nfsstat3 stat, int pstat, + struct nfs3_fh *newfh, const char *path) { - char errstr[1024]; - char fhstr[1024]; - int ll = nfs3_loglevel (op, stat); + char errstr[1024]; + char fhstr[1024]; + int ll = nfs3_loglevel(op, stat); - if (THIS->ctx->log.loglevel < ll) - return; - nfs3_stat_to_errstr (xid, nfs3op_strings[op].str, stat, pstat, errstr, sizeof (errstr)); - nfs3_fh_to_str (newfh, fhstr, sizeof (fhstr)); + if (THIS->ctx->log.loglevel < ll) + return; + nfs3_stat_to_errstr(xid, nfs3op_strings[op].str, stat, pstat, errstr, + sizeof(errstr)); + nfs3_fh_to_str(newfh, fhstr, sizeof(fhstr)); - if (ll == GF_LOG_DEBUG) - gf_msg_debug (GF_NFS3, 0, "%s => (%s), %s", path, errstr, - fhstr); - else - gf_msg (GF_NFS3, nfs3_loglevel (op, stat), errno, NFS_MSG_STAT_ERROR, - "%s => (%s), %s", path, errstr, fhstr); + if (ll == GF_LOG_DEBUG) + gf_msg_debug(GF_NFS3, 0, "%s => (%s), %s", path, errstr, fhstr); + else + gf_msg(GF_NFS3, nfs3_loglevel(op, stat), errno, NFS_MSG_STAT_ERROR, + "%s => (%s), %s", path, errstr, fhstr); } void -nfs3_log_readdir_res (uint32_t xid, nfsstat3 stat, int pstat, uint64_t cverf, - count3 count, int is_eof, const char *path) +nfs3_log_readdir_res(uint32_t xid, nfsstat3 stat, int pstat, uint64_t cverf, + count3 count, int is_eof, const char *path) { - char errstr[1024]; - int ll = nfs3_loglevel (NFS3_READDIR, stat); + char errstr[1024]; + int ll = nfs3_loglevel(NFS3_READDIR, stat); - if (THIS->ctx->log.loglevel < ll) - return; - nfs3_stat_to_errstr (xid, "READDIR", stat, pstat, errstr, sizeof (errstr)); - if (ll == GF_LOG_DEBUG) - gf_msg_debug (GF_NFS3, 0, - "%s => (%s), count: %"PRIu32", cverf: %"PRIu64 - ", is_eof: %d", path, errstr, count, cverf, - is_eof); - else - gf_msg (GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR, - "%s => (%s), count: %"PRIu32", cverf: %"PRIu64 - ", is_eof: %d", path, errstr, count, cverf, is_eof); + if (THIS->ctx->log.loglevel < ll) + return; + nfs3_stat_to_errstr(xid, "READDIR", stat, pstat, errstr, sizeof(errstr)); + if (ll == GF_LOG_DEBUG) + gf_msg_debug(GF_NFS3, 0, + "%s => (%s), count: %" PRIu32 ", cverf: %" PRIu64 + ", is_eof: %d", + path, errstr, count, cverf, is_eof); + else + gf_msg(GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR, + "%s => (%s), count: %" PRIu32 ", cverf: %" PRIu64 ", is_eof: %d", + path, errstr, count, cverf, is_eof); } void -nfs3_log_readdirp_res (uint32_t xid, nfsstat3 stat, int pstat, uint64_t cverf, - count3 dircount, count3 maxcount, int is_eof, - const char *path) +nfs3_log_readdirp_res(uint32_t xid, nfsstat3 stat, int pstat, uint64_t cverf, + count3 dircount, count3 maxcount, int is_eof, + const char *path) { - char errstr[1024]; - int ll = nfs3_loglevel (NFS3_READDIRP, stat); - - if (THIS->ctx->log.loglevel < ll) - return; - nfs3_stat_to_errstr (xid, "READDIRPLUS", stat, pstat, errstr, sizeof (errstr)); - if (ll == GF_LOG_DEBUG) - gf_msg_debug (GF_NFS3, 0, - "%s => (%s), dircount: %"PRIu32", maxcount: %" - PRIu32", cverf: %"PRIu64", is_eof: %d", path, - errstr, dircount, maxcount, cverf, is_eof); - else - gf_msg (GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR, - "%s => (%s), dircount: %"PRIu32", maxcount: %" - PRIu32", cverf: %"PRIu64", is_eof: %d", path, errstr, - dircount, maxcount, cverf, is_eof); + char errstr[1024]; + int ll = nfs3_loglevel(NFS3_READDIRP, stat); + if (THIS->ctx->log.loglevel < ll) + return; + nfs3_stat_to_errstr(xid, "READDIRPLUS", stat, pstat, errstr, + sizeof(errstr)); + if (ll == GF_LOG_DEBUG) + gf_msg_debug(GF_NFS3, 0, + "%s => (%s), dircount: %" PRIu32 ", maxcount: %" PRIu32 + ", cverf: %" PRIu64 ", is_eof: %d", + path, errstr, dircount, maxcount, cverf, is_eof); + else + gf_msg(GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR, + "%s => (%s), dircount: %" PRIu32 ", maxcount: %" PRIu32 + ", cverf: %" PRIu64 ", is_eof: %d", + path, errstr, dircount, maxcount, cverf, is_eof); } void -nfs3_log_commit_res (uint32_t xid, nfsstat3 stat, int pstat, uint64_t wverf, - const char *path) +nfs3_log_commit_res(uint32_t xid, nfsstat3 stat, int pstat, uint64_t wverf, + const char *path) { - char errstr[1024]; - int ll = nfs3_loglevel (NFS3_COMMIT, stat); - - if (THIS->ctx->log.loglevel < ll) - return; - nfs3_stat_to_errstr (xid, "COMMIT", stat, pstat, errstr, sizeof (errstr)); - if (ll == GF_LOG_DEBUG) - gf_msg_debug (GF_NFS3, 0, "%s => (%s), wverf: %"PRIu64, - path, errstr, wverf); - else - gf_msg (GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR, - "%s => (%s), wverf: %"PRIu64, path, errstr, wverf); + char errstr[1024]; + int ll = nfs3_loglevel(NFS3_COMMIT, stat); + if (THIS->ctx->log.loglevel < ll) + return; + nfs3_stat_to_errstr(xid, "COMMIT", stat, pstat, errstr, sizeof(errstr)); + if (ll == GF_LOG_DEBUG) + gf_msg_debug(GF_NFS3, 0, "%s => (%s), wverf: %" PRIu64, path, errstr, + wverf); + else + gf_msg(GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR, + "%s => (%s), wverf: %" PRIu64, path, errstr, wverf); } void -nfs3_log_readdir_call (uint32_t xid, struct nfs3_fh *fh, count3 dircount, - count3 maxcount) +nfs3_log_readdir_call(uint32_t xid, struct nfs3_fh *fh, count3 dircount, + count3 maxcount) { - char fhstr[1024]; + char fhstr[1024]; - if (THIS->ctx->log.loglevel < GF_LOG_DEBUG) - return; + if (THIS->ctx->log.loglevel < GF_LOG_DEBUG) + return; - nfs3_fh_to_str (fh, fhstr, sizeof (fhstr)); + nfs3_fh_to_str(fh, fhstr, sizeof(fhstr)); - if (maxcount == 0) - gf_msg_debug (GF_NFS3, 0, "XID: %x, READDIR: args: %s," - " count: %d", xid, fhstr, (uint32_t)dircount); - else - gf_msg_debug (GF_NFS3, 0, "XID: %x, READDIRPLUS: args: %s," - " dircount: %d, maxcount: %d", xid, fhstr, - (uint32_t)dircount, (uint32_t)maxcount); + if (maxcount == 0) + gf_msg_debug(GF_NFS3, 0, + "XID: %x, READDIR: args: %s," + " count: %d", + xid, fhstr, (uint32_t)dircount); + else + gf_msg_debug(GF_NFS3, 0, + "XID: %x, READDIRPLUS: args: %s," + " dircount: %d, maxcount: %d", + xid, fhstr, (uint32_t)dircount, (uint32_t)maxcount); } int -nfs3_fh_resolve_inode_done (nfs3_call_state_t *cs, inode_t *inode) +nfs3_fh_resolve_inode_done(nfs3_call_state_t *cs, inode_t *inode) { - int ret = -EFAULT; + int ret = -EFAULT; - if ((!cs) || (!inode)) - return ret; + if ((!cs) || (!inode)) + return ret; - gf_msg_trace (GF_NFS3, 0, "FH inode resolved"); - ret = nfs_inode_loc_fill (inode, &cs->resolvedloc, NFS_RESOLVE_EXIST); - if (ret < 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, - NFS_MSG_INODE_LOC_FILL_ERROR, - "inode loc fill failed"); - goto err; - } + gf_msg_trace(GF_NFS3, 0, "FH inode resolved"); + ret = nfs_inode_loc_fill(inode, &cs->resolvedloc, NFS_RESOLVE_EXIST); + if (ret < 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_INODE_LOC_FILL_ERROR, + "inode loc fill failed"); + goto err; + } - nfs3_call_resume (cs); + nfs3_call_resume(cs); err: - return ret; + return ret; } int32_t -nfs3_fh_resolve_entry_lookup_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, - int32_t op_errno, inode_t *inode, - struct iatt *buf, dict_t *xattr, - struct iatt *postparent) -{ - nfs3_call_state_t *cs = NULL; - inode_t *linked_inode = NULL; - - cs = frame->local; - cs->resolve_ret = op_ret; - cs->resolve_errno = op_errno; - - if (op_ret == -1) { - if (op_errno == ENOENT) { - gf_msg_trace (GF_NFS3, 0, "Lookup failed: %s: %s", - cs->resolvedloc.path, - strerror (op_errno)); - } else { - gf_msg (GF_NFS3, GF_LOG_ERROR, op_errno, - NFS_MSG_LOOKUP_FAIL, "Lookup failed: %s: %s", - cs->resolvedloc.path, strerror (op_errno)); - } - goto err; - } else - gf_msg_trace (GF_NFS3, 0, "Entry looked up: %s", - cs->resolvedloc.path); - - memcpy (&cs->stbuf, buf, sizeof (*buf)); - memcpy (&cs->postparent, postparent, sizeof (*postparent)); - linked_inode = inode_link (inode, cs->resolvedloc.parent, - cs->resolvedloc.name, buf); - if (linked_inode) { - nfs_fix_generation (this, linked_inode); - inode_lookup (linked_inode); - inode_unref (cs->resolvedloc.inode); - cs->resolvedloc.inode = linked_inode; +nfs3_fh_resolve_entry_lookup_cbk(call_frame_t *frame, void *cookie, + xlator_t *this, int32_t op_ret, + int32_t op_errno, inode_t *inode, + struct iatt *buf, dict_t *xattr, + struct iatt *postparent) +{ + nfs3_call_state_t *cs = NULL; + inode_t *linked_inode = NULL; + + cs = frame->local; + cs->resolve_ret = op_ret; + cs->resolve_errno = op_errno; + + if (op_ret == -1) { + if (op_errno == ENOENT) { + gf_msg_trace(GF_NFS3, 0, "Lookup failed: %s: %s", + cs->resolvedloc.path, strerror(op_errno)); + } else { + gf_msg(GF_NFS3, GF_LOG_ERROR, op_errno, NFS_MSG_LOOKUP_FAIL, + "Lookup failed: %s: %s", cs->resolvedloc.path, + strerror(op_errno)); } + goto err; + } else + gf_msg_trace(GF_NFS3, 0, "Entry looked up: %s", cs->resolvedloc.path); + + memcpy(&cs->stbuf, buf, sizeof(*buf)); + memcpy(&cs->postparent, postparent, sizeof(*postparent)); + linked_inode = inode_link(inode, cs->resolvedloc.parent, + cs->resolvedloc.name, buf); + if (linked_inode) { + nfs_fix_generation(this, linked_inode); + inode_lookup(linked_inode); + inode_unref(cs->resolvedloc.inode); + cs->resolvedloc.inode = linked_inode; + } err: - nfs3_call_resume (cs); - return 0; + nfs3_call_resume(cs); + return 0; } int32_t -nfs3_fh_resolve_inode_lookup_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, - int32_t op_errno, inode_t *inode, - struct iatt *buf, dict_t *xattr, - struct iatt *postparent) -{ - nfs3_call_state_t *cs = NULL; - inode_t *linked_inode = NULL; - - cs = frame->local; - cs->resolve_ret = op_ret; - cs->resolve_errno = op_errno; - - if (op_ret == -1) { - if (op_errno == ENOENT) { - gf_msg_trace (GF_NFS3, 0, "Lookup failed: %s: %s", - cs->resolvedloc.path, - strerror (op_errno)); - } else { - gf_msg (GF_NFS3, GF_LOG_ERROR, op_errno, - NFS_MSG_LOOKUP_FAIL, "Lookup failed: %s: %s", - cs->resolvedloc.path, strerror (op_errno)); - } - nfs3_call_resume (cs); - goto err; - } +nfs3_fh_resolve_inode_lookup_cbk(call_frame_t *frame, void *cookie, + xlator_t *this, int32_t op_ret, + int32_t op_errno, inode_t *inode, + struct iatt *buf, dict_t *xattr, + struct iatt *postparent) +{ + nfs3_call_state_t *cs = NULL; + inode_t *linked_inode = NULL; - memcpy (&cs->stbuf, buf, sizeof(*buf)); - memcpy (&cs->postparent, buf, sizeof(*postparent)); - linked_inode = inode_link (inode, cs->resolvedloc.parent, - cs->resolvedloc.name, buf); - if (linked_inode) { - nfs_fix_generation (this, linked_inode); - inode_lookup (linked_inode); - inode_unref (cs->resolvedloc.inode); - cs->resolvedloc.inode = linked_inode; - } + cs = frame->local; + cs->resolve_ret = op_ret; + cs->resolve_errno = op_errno; - /* If it is an entry lookup and we landed in the callback for hard - * inode resolution, it means the parent inode was not available and - * had to be resolved first. Now that is done, lets head back into - * entry resolution. - */ - if (cs->resolventry) - nfs3_fh_resolve_entry_hard (cs); - else - nfs3_call_resume (cs); + if (op_ret == -1) { + if (op_errno == ENOENT) { + gf_msg_trace(GF_NFS3, 0, "Lookup failed: %s: %s", + cs->resolvedloc.path, strerror(op_errno)); + } else { + gf_msg(GF_NFS3, GF_LOG_ERROR, op_errno, NFS_MSG_LOOKUP_FAIL, + "Lookup failed: %s: %s", cs->resolvedloc.path, + strerror(op_errno)); + } + nfs3_call_resume(cs); + goto err; + } + + memcpy(&cs->stbuf, buf, sizeof(*buf)); + memcpy(&cs->postparent, buf, sizeof(*postparent)); + linked_inode = inode_link(inode, cs->resolvedloc.parent, + cs->resolvedloc.name, buf); + if (linked_inode) { + nfs_fix_generation(this, linked_inode); + inode_lookup(linked_inode); + inode_unref(cs->resolvedloc.inode); + cs->resolvedloc.inode = linked_inode; + } + + /* If it is an entry lookup and we landed in the callback for hard + * inode resolution, it means the parent inode was not available and + * had to be resolved first. Now that is done, lets head back into + * entry resolution. + */ + if (cs->resolventry) + nfs3_fh_resolve_entry_hard(cs); + else + nfs3_call_resume(cs); err: - return 0; + return 0; } - /* Needs no extra argument since it knows that the fh to be resolved is in * resolvefh and that it needs to start looking from the root. */ int -nfs3_fh_resolve_inode_hard (nfs3_call_state_t *cs) -{ - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - - if (!cs) - return ret; - - gf_msg_trace (GF_NFS3, 0, "FH hard resolution for: gfid 0x%s", - uuid_utoa (cs->resolvefh.gfid)); - cs->hardresolved = 1; - nfs_loc_wipe (&cs->resolvedloc); - ret = nfs_gfid_loc_fill (cs->vol->itable, cs->resolvefh.gfid, - &cs->resolvedloc, NFS_RESOLVE_CREATE); - if (ret < 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, - NFS_MSG_INODE_LOC_FILL_ERROR, - "Failed to fill loc using gfid: " - "%s", strerror (-ret)); - goto out; - } +nfs3_fh_resolve_inode_hard(nfs3_call_state_t *cs) +{ + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; - nfs_user_root_create (&nfu); - ret = nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - nfs3_fh_resolve_inode_lookup_cbk, cs); + if (!cs) + return ret; + + gf_msg_trace(GF_NFS3, 0, "FH hard resolution for: gfid 0x%s", + uuid_utoa(cs->resolvefh.gfid)); + cs->hardresolved = 1; + nfs_loc_wipe(&cs->resolvedloc); + ret = nfs_gfid_loc_fill(cs->vol->itable, cs->resolvefh.gfid, + &cs->resolvedloc, NFS_RESOLVE_CREATE); + if (ret < 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_INODE_LOC_FILL_ERROR, + "Failed to fill loc using gfid: " + "%s", + strerror(-ret)); + goto out; + } + + nfs_user_root_create(&nfu); + ret = nfs_lookup(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + nfs3_fh_resolve_inode_lookup_cbk, cs); out: - return ret; + return ret; } - int -nfs3_fh_resolve_entry_hard (nfs3_call_state_t *cs) -{ - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - gf_boolean_t freshlookup = _gf_false; - - if (!cs) - return ret; - - nfs_loc_wipe (&cs->resolvedloc); - nfs_user_root_create (&nfu); - gf_msg_trace (GF_NFS3, 0, "FH hard resolution: gfid: %s " - ", entry: %s", uuid_utoa (cs->resolvefh.gfid), - cs->resolventry); - - ret = nfs_entry_loc_fill (cs->nfsx, cs->vol->itable, cs->resolvefh.gfid, - cs->resolventry, &cs->resolvedloc, - NFS_RESOLVE_CREATE, &freshlookup); - - if (ret == -2) { - gf_msg_trace (GF_NFS3, 0, "Entry needs lookup: %s", - cs->resolvedloc.path); - /* If the NFS op is lookup, let the resume callback - * handle the sending of the lookup fop. Similarly, - * if the NFS op is create, let the create call - * go ahead in the resume callback so that an EEXIST gets - * handled at posix without an extra fop at this point. - */ - if (freshlookup && (nfs3_lookup_op (cs) || - (nfs3_create_op (cs) && !nfs3_create_exclusive_op (cs)))) { - cs->lookuptype = GF_NFS3_FRESH; - cs->resolve_ret = 0; - cs->hardresolved = 0; - nfs3_call_resume (cs); - } else { - cs->hardresolved = 1; - nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - nfs3_fh_resolve_entry_lookup_cbk, cs); - } - ret = 0; - } else if (ret == -1) { - gf_msg_trace (GF_NFS3, 0, "Entry needs parent lookup: %s", - cs->resolvedloc.path); - ret = nfs3_fh_resolve_inode_hard (cs); - } else if (ret == 0) { - cs->resolve_ret = 0; - nfs3_call_resume (cs); - } +nfs3_fh_resolve_entry_hard(nfs3_call_state_t *cs) +{ + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + gf_boolean_t freshlookup = _gf_false; + if (!cs) return ret; + + nfs_loc_wipe(&cs->resolvedloc); + nfs_user_root_create(&nfu); + gf_msg_trace(GF_NFS3, 0, + "FH hard resolution: gfid: %s " + ", entry: %s", + uuid_utoa(cs->resolvefh.gfid), cs->resolventry); + + ret = nfs_entry_loc_fill(cs->nfsx, cs->vol->itable, cs->resolvefh.gfid, + cs->resolventry, &cs->resolvedloc, + NFS_RESOLVE_CREATE, &freshlookup); + + if (ret == -2) { + gf_msg_trace(GF_NFS3, 0, "Entry needs lookup: %s", + cs->resolvedloc.path); + /* If the NFS op is lookup, let the resume callback + * handle the sending of the lookup fop. Similarly, + * if the NFS op is create, let the create call + * go ahead in the resume callback so that an EEXIST gets + * handled at posix without an extra fop at this point. + */ + if (freshlookup && + (nfs3_lookup_op(cs) || + (nfs3_create_op(cs) && !nfs3_create_exclusive_op(cs)))) { + cs->lookuptype = GF_NFS3_FRESH; + cs->resolve_ret = 0; + cs->hardresolved = 0; + nfs3_call_resume(cs); + } else { + cs->hardresolved = 1; + nfs_lookup(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + nfs3_fh_resolve_entry_lookup_cbk, cs); + } + ret = 0; + } else if (ret == -1) { + gf_msg_trace(GF_NFS3, 0, "Entry needs parent lookup: %s", + cs->resolvedloc.path); + ret = nfs3_fh_resolve_inode_hard(cs); + } else if (ret == 0) { + cs->resolve_ret = 0; + nfs3_call_resume(cs); + } + + return ret; } int -nfs3_fh_resolve_inode (nfs3_call_state_t *cs) +nfs3_fh_resolve_inode(nfs3_call_state_t *cs) { - inode_t *inode = NULL; - int ret = -EFAULT; - xlator_t *this = NULL; + inode_t *inode = NULL; + int ret = -EFAULT; + xlator_t *this = NULL; - if (!cs) - return ret; + if (!cs) + return ret; - this = cs->nfsx; - gf_msg_trace (GF_NFS3, 0, "FH needs inode resolution"); - gf_uuid_copy (cs->resolvedloc.gfid, cs->resolvefh.gfid); + this = cs->nfsx; + gf_msg_trace(GF_NFS3, 0, "FH needs inode resolution"); + gf_uuid_copy(cs->resolvedloc.gfid, cs->resolvefh.gfid); - inode = inode_find (cs->vol->itable, cs->resolvefh.gfid); - if (!inode || inode_ctx_get (inode, this, NULL)) - ret = nfs3_fh_resolve_inode_hard (cs); - else - ret = nfs3_fh_resolve_inode_done (cs, inode); + inode = inode_find(cs->vol->itable, cs->resolvefh.gfid); + if (!inode || inode_ctx_get(inode, this, NULL)) + ret = nfs3_fh_resolve_inode_hard(cs); + else + ret = nfs3_fh_resolve_inode_done(cs, inode); - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - return ret; + return ret; } int -nfs3_fh_resolve_entry (nfs3_call_state_t *cs) +nfs3_fh_resolve_entry(nfs3_call_state_t *cs) { - int ret = -EFAULT; + int ret = -EFAULT; - if (!cs) - return ret; + if (!cs) + return ret; - return nfs3_fh_resolve_entry_hard (cs); + return nfs3_fh_resolve_entry_hard(cs); } - int -nfs3_fh_resolve_resume (nfs3_call_state_t *cs) +nfs3_fh_resolve_resume(nfs3_call_state_t *cs) { - int ret = -EFAULT; + int ret = -EFAULT; - if (!cs) - return ret; + if (!cs) + return ret; - if (cs->resolve_ret < 0) - goto err_resume_call; + if (cs->resolve_ret < 0) + goto err_resume_call; - if (!cs->resolventry) - ret = nfs3_fh_resolve_inode (cs); - else - ret = nfs3_fh_resolve_entry (cs); + if (!cs->resolventry) + ret = nfs3_fh_resolve_inode(cs); + else + ret = nfs3_fh_resolve_entry(cs); err_resume_call: - if (ret < 0) { - cs->resolve_ret = -1; - cs->resolve_errno = EFAULT; - nfs3_call_resume (cs); - ret = 0; - } + if (ret < 0) { + cs->resolve_ret = -1; + cs->resolve_errno = EFAULT; + nfs3_call_resume(cs); + ret = 0; + } - return ret; + return ret; } - int32_t -nfs3_fh_resolve_root_lookup_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, - int32_t op_errno, inode_t *inode, - struct iatt *buf, dict_t *xattr, - struct iatt *postparent) -{ - nfs3_call_state_t *cs = NULL; - - cs = frame->local; - cs->resolve_ret = op_ret; - cs->resolve_errno = op_errno; - - if (op_ret == -1) { - gf_msg (GF_NFS3, GF_LOG_ERROR, op_errno, - NFS_MSG_LOOKUP_ROOT_FAIL, "Root lookup failed: %s", - strerror (op_errno)); - goto err; - } else - gf_msg_trace (GF_NFS3, 0, "Root looked up: %s", - cs->resolvedloc.path); - - nfs3_set_root_looked_up (cs->nfs3state, &cs->resolvefh); +nfs3_fh_resolve_root_lookup_cbk(call_frame_t *frame, void *cookie, + xlator_t *this, int32_t op_ret, + int32_t op_errno, inode_t *inode, + struct iatt *buf, dict_t *xattr, + struct iatt *postparent) +{ + nfs3_call_state_t *cs = NULL; + + cs = frame->local; + cs->resolve_ret = op_ret; + cs->resolve_errno = op_errno; + + if (op_ret == -1) { + gf_msg(GF_NFS3, GF_LOG_ERROR, op_errno, NFS_MSG_LOOKUP_ROOT_FAIL, + "Root lookup failed: %s", strerror(op_errno)); + goto err; + } else + gf_msg_trace(GF_NFS3, 0, "Root looked up: %s", cs->resolvedloc.path); + + nfs3_set_root_looked_up(cs->nfs3state, &cs->resolvefh); err: - nfs3_fh_resolve_resume (cs); - return 0; + nfs3_fh_resolve_resume(cs); + return 0; } - int -nfs3_fh_resolve_root (nfs3_call_state_t *cs) +nfs3_fh_resolve_root(nfs3_call_state_t *cs) { - int ret = -EFAULT; - nfs_user_t nfu = {0, }; + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; - if (!cs) - return ret; + if (!cs) + return ret; - if (nfs3_is_root_looked_up (cs->nfs3state, &cs->resolvefh)) { - ret = nfs3_fh_resolve_resume (cs); - goto out; - } + if (nfs3_is_root_looked_up(cs->nfs3state, &cs->resolvefh)) { + ret = nfs3_fh_resolve_resume(cs); + goto out; + } - nfs_user_root_create (&nfu); - gf_msg_trace (GF_NFS3, 0, "Root needs lookup"); - ret = nfs_root_loc_fill (cs->vol->itable, &cs->resolvedloc); - if (ret < 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_LOOKUP_ROOT_FAIL, - "Failed to lookup root from itable: %s", - strerror (-ret)); - goto out; - } + nfs_user_root_create(&nfu); + gf_msg_trace(GF_NFS3, 0, "Root needs lookup"); + ret = nfs_root_loc_fill(cs->vol->itable, &cs->resolvedloc); + if (ret < 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_LOOKUP_ROOT_FAIL, + "Failed to lookup root from itable: %s", strerror(-ret)); + goto out; + } - ret = nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - nfs3_fh_resolve_root_lookup_cbk, cs); + ret = nfs_lookup(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + nfs3_fh_resolve_root_lookup_cbk, cs); out: - return ret; + return ret; } /** @@ -3944,25 +3835,27 @@ out: * @req : The request to get host/peer from */ int -__nfs3_fh_auth_get_peer (const rpcsvc_request_t *req, char *peer) -{ - struct sockaddr_storage sastorage = {0, }; - rpc_transport_t *trans = NULL; - int ret = 0; - - /* Why do we pass in the peer here and then - * store it rather than malloc() and return a char * ? We want to avoid - * heap allocations in the IO path as much as possible for speed - * so we try to keep all allocations on the stack. - */ - trans = rpcsvc_request_transport (req); - ret = rpcsvc_transport_peeraddr (trans, peer, RPCSVC_PEER_STRLEN, - &sastorage, sizeof (sastorage)); - if (ret != 0) { - gf_msg (GF_NFS3, GF_LOG_WARNING, 0, NFS_MSG_GET_PEER_ADDR_FAIL, - "Failed to get peer addr: %s", gai_strerror (ret)); - } - return ret; +__nfs3_fh_auth_get_peer(const rpcsvc_request_t *req, char *peer) +{ + struct sockaddr_storage sastorage = { + 0, + }; + rpc_transport_t *trans = NULL; + int ret = 0; + + /* Why do we pass in the peer here and then + * store it rather than malloc() and return a char * ? We want to avoid + * heap allocations in the IO path as much as possible for speed + * so we try to keep all allocations on the stack. + */ + trans = rpcsvc_request_transport(req); + ret = rpcsvc_transport_peeraddr(trans, peer, RPCSVC_PEER_STRLEN, &sastorage, + sizeof(sastorage)); + if (ret != 0) { + gf_msg(GF_NFS3, GF_LOG_WARNING, 0, NFS_MSG_GET_PEER_ADDR_FAIL, + "Failed to get peer addr: %s", gai_strerror(ret)); + } + return ret; } /* @@ -3975,44 +3868,44 @@ __nfs3_fh_auth_get_peer (const rpcsvc_request_t *req, char *peer) * -EROFS for unauthorized write operations (rm, mkdir, write) */ int -nfs3_fh_auth_nfsop (nfs3_call_state_t *cs, gf_boolean_t is_write_op) +nfs3_fh_auth_nfsop(nfs3_call_state_t *cs, gf_boolean_t is_write_op) { - struct nfs_state *nfs = NULL; - struct mount3_state *ms = NULL; + struct nfs_state *nfs = NULL; + struct mount3_state *ms = NULL; - nfs = (struct nfs_state *)cs->nfsx->private; - ms = (struct mount3_state *)nfs->mstate; - return mnt3_authenticate_request (ms, cs->req, &cs->resolvefh, NULL, - NULL, NULL, NULL, is_write_op); + nfs = (struct nfs_state *)cs->nfsx->private; + ms = (struct mount3_state *)nfs->mstate; + return mnt3_authenticate_request(ms, cs->req, &cs->resolvefh, NULL, NULL, + NULL, NULL, is_write_op); } int -nfs3_fh_resolve_and_resume (nfs3_call_state_t *cs, struct nfs3_fh *fh, - char *entry, nfs3_resume_fn_t resum_fn) +nfs3_fh_resolve_and_resume(nfs3_call_state_t *cs, struct nfs3_fh *fh, + char *entry, nfs3_resume_fn_t resum_fn) { - int ret = -EFAULT; + int ret = -EFAULT; - if ((!cs) || (!fh)) - return ret; - - cs->resume_fn = resum_fn; - cs->resolvefh = *fh; - cs->hashidx = 0; + if ((!cs) || (!fh)) + return ret; - /* Check if the resolution is: - * a. fh resolution - * - * or - * - * b. (fh, basename) resolution - */ - if (entry) { /* b */ - cs->resolventry = gf_strdup (entry); - if (!cs->resolventry) - goto err; - } + cs->resume_fn = resum_fn; + cs->resolvefh = *fh; + cs->hashidx = 0; + + /* Check if the resolution is: + * a. fh resolution + * + * or + * + * b. (fh, basename) resolution + */ + if (entry) { /* b */ + cs->resolventry = gf_strdup(entry); + if (!cs->resolventry) + goto err; + } - ret = nfs3_fh_resolve_root (cs); + ret = nfs3_fh_resolve_root(cs); err: - return ret; + return ret; } diff --git a/xlators/nfs/server/src/nfs3.c b/xlators/nfs/server/src/nfs3.c index e9a52ba939..42799bdfd3 100644 --- a/xlators/nfs/server/src/nfs3.c +++ b/xlators/nfs/server/src/nfs3.c @@ -35,391 +35,370 @@ #include <sys/statvfs.h> #include <time.h> -#define nfs3_validate_strlen_or_goto(str, len, label, status, retval) \ - do { \ - if ((str)) { \ - if (strlen ((str)) > (len)) { \ - gf_msg (GF_NFS3, GF_LOG_ERROR, \ - ENAMETOOLONG, \ - NFS_MSG_STR_TOO_LONG, \ - "strlen too long"); \ - status = NFS3ERR_NAMETOOLONG; \ - retval = -ENAMETOOLONG; \ - goto label; \ - } \ - } \ - } while (0); \ - -#define nfs3_validate_nfs3_state(request, state, status, label, retval) \ - do { \ - state = rpcsvc_request_program_private (request); \ - if (!state) { \ - gf_msg (GF_NFS3, GF_LOG_ERROR, EFAULT, \ - NFS_MSG_STATE_MISSING, "NFSv3 state " \ - "missing from RPC request"); \ - status = NFS3ERR_SERVERFAULT; \ - ret = -EFAULT; \ - goto label; \ - } \ - } while (0); \ - +#define nfs3_validate_strlen_or_goto(str, len, label, status, retval) \ + do { \ + if ((str)) { \ + if (strlen((str)) > (len)) { \ + gf_msg(GF_NFS3, GF_LOG_ERROR, ENAMETOOLONG, \ + NFS_MSG_STR_TOO_LONG, "strlen too long"); \ + status = NFS3ERR_NAMETOOLONG; \ + retval = -ENAMETOOLONG; \ + goto label; \ + } \ + } \ + } while (0); + +#define nfs3_validate_nfs3_state(request, state, status, label, retval) \ + do { \ + state = rpcsvc_request_program_private(request); \ + if (!state) { \ + gf_msg(GF_NFS3, GF_LOG_ERROR, EFAULT, NFS_MSG_STATE_MISSING, \ + "NFSv3 state " \ + "missing from RPC request"); \ + status = NFS3ERR_SERVERFAULT; \ + ret = -EFAULT; \ + goto label; \ + } \ + } while (0); struct nfs3_export * -__nfs3_get_export_by_index (struct nfs3_state *nfs3, uuid_t exportid) +__nfs3_get_export_by_index(struct nfs3_state *nfs3, uuid_t exportid) { - struct nfs3_export *exp = NULL; - int index = 0; - int searchindex = 0; + struct nfs3_export *exp = NULL; + int index = 0; + int searchindex = 0; - searchindex = nfs3_fh_exportid_to_index (exportid); - list_for_each_entry (exp, &nfs3->exports, explist) { - if (searchindex == index) - goto found; + searchindex = nfs3_fh_exportid_to_index(exportid); + list_for_each_entry(exp, &nfs3->exports, explist) + { + if (searchindex == index) + goto found; - ++index; - } + ++index; + } - exp = NULL; - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_INDEX_NOT_FOUND, - "searchindex=%d not found", searchindex); + exp = NULL; + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_INDEX_NOT_FOUND, + "searchindex=%d not found", searchindex); found: - return exp; + return exp; } - struct nfs3_export * -__nfs3_get_export_by_volumeid (struct nfs3_state *nfs3, uuid_t exportid) +__nfs3_get_export_by_volumeid(struct nfs3_state *nfs3, uuid_t exportid) { - struct nfs3_export *exp = NULL; + struct nfs3_export *exp = NULL; - list_for_each_entry (exp, &nfs3->exports, explist) { - if (!gf_uuid_compare (exportid, exp->volumeid)) - goto found; - } + list_for_each_entry(exp, &nfs3->exports, explist) + { + if (!gf_uuid_compare(exportid, exp->volumeid)) + goto found; + } - exp = NULL; + exp = NULL; found: - return exp; + return exp; } - struct nfs3_export * -__nfs3_get_export_by_exportid (struct nfs3_state *nfs3, uuid_t exportid) +__nfs3_get_export_by_exportid(struct nfs3_state *nfs3, uuid_t exportid) { - struct nfs3_export *exp = NULL; + struct nfs3_export *exp = NULL; - if (!nfs3) - return exp; + if (!nfs3) + return exp; - if (gf_nfs_dvm_off (nfs_state(nfs3->nfsx))) - exp = __nfs3_get_export_by_index (nfs3, exportid); - else - exp = __nfs3_get_export_by_volumeid (nfs3, exportid); + if (gf_nfs_dvm_off(nfs_state(nfs3->nfsx))) + exp = __nfs3_get_export_by_index(nfs3, exportid); + else + exp = __nfs3_get_export_by_volumeid(nfs3, exportid); - return exp; + return exp; } - int -nfs3_export_access (struct nfs3_state *nfs3, uuid_t exportid) +nfs3_export_access(struct nfs3_state *nfs3, uuid_t exportid) { - int ret = GF_NFS3_VOLACCESS_RO; - struct nfs3_export *exp = NULL; + int ret = GF_NFS3_VOLACCESS_RO; + struct nfs3_export *exp = NULL; - GF_VALIDATE_OR_GOTO (GF_NFS3, nfs3, err); + GF_VALIDATE_OR_GOTO(GF_NFS3, nfs3, err); - exp = __nfs3_get_export_by_exportid (nfs3, exportid); + exp = __nfs3_get_export_by_exportid(nfs3, exportid); - if (!exp) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_EXPORT_ID_FAIL, - "Failed to get export by ID"); - goto err; - } + if (!exp) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_EXPORT_ID_FAIL, + "Failed to get export by ID"); + goto err; + } - ret = exp->access; + ret = exp->access; err: - return ret; + return ret; } -#define nfs3_check_rw_volaccess(nfs3state, exid, status, label) \ - do { \ - if (nfs3_export_access (nfs3state,exid)!=GF_NFS3_VOLACCESS_RW){\ - gf_msg (GF_NFS3, GF_LOG_ERROR, EACCES, \ - NFS_MSG_NO_RW_ACCESS, \ - "No read-write access"); \ - status = NFS3ERR_ROFS; \ - goto label; \ - } \ - } while (0) \ - - +#define nfs3_check_rw_volaccess(nfs3state, exid, status, label) \ + do { \ + if (nfs3_export_access(nfs3state, exid) != GF_NFS3_VOLACCESS_RW) { \ + gf_msg(GF_NFS3, GF_LOG_ERROR, EACCES, NFS_MSG_NO_RW_ACCESS, \ + "No read-write access"); \ + status = NFS3ERR_ROFS; \ + goto label; \ + } \ + } while (0) xlator_t * -nfs3_fh_to_xlator (struct nfs3_state *nfs3, struct nfs3_fh *fh) +nfs3_fh_to_xlator(struct nfs3_state *nfs3, struct nfs3_fh *fh) { - xlator_t *vol = NULL; - struct nfs3_export *exp = NULL; + xlator_t *vol = NULL; + struct nfs3_export *exp = NULL; - GF_VALIDATE_OR_GOTO (GF_NFS3, nfs3, out); - GF_VALIDATE_OR_GOTO (GF_NFS3, fh, out); + GF_VALIDATE_OR_GOTO(GF_NFS3, nfs3, out); + GF_VALIDATE_OR_GOTO(GF_NFS3, fh, out); - exp = __nfs3_get_export_by_exportid (nfs3, fh->exportid); - if (!exp) - goto out; + exp = __nfs3_get_export_by_exportid(nfs3, fh->exportid); + if (!exp) + goto out; - vol = exp->subvol; + vol = exp->subvol; out: - return vol; + return vol; } - int -nfs3_is_root_looked_up (struct nfs3_state *nfs3, struct nfs3_fh *rootfh) +nfs3_is_root_looked_up(struct nfs3_state *nfs3, struct nfs3_fh *rootfh) { - struct nfs3_export *exp = NULL; - int ret = 0; + struct nfs3_export *exp = NULL; + int ret = 0; - GF_VALIDATE_OR_GOTO (GF_NFS3, nfs3, out); - GF_VALIDATE_OR_GOTO (GF_NFS3, rootfh, out); + GF_VALIDATE_OR_GOTO(GF_NFS3, nfs3, out); + GF_VALIDATE_OR_GOTO(GF_NFS3, rootfh, out); - exp = __nfs3_get_export_by_exportid (nfs3, rootfh->exportid); - if (!exp) - goto out; + exp = __nfs3_get_export_by_exportid(nfs3, rootfh->exportid); + if (!exp) + goto out; - ret = exp->rootlookedup; + ret = exp->rootlookedup; out: - return ret; + return ret; } - int -nfs3_set_root_looked_up (struct nfs3_state *nfs3, struct nfs3_fh *rootfh) +nfs3_set_root_looked_up(struct nfs3_state *nfs3, struct nfs3_fh *rootfh) { - struct nfs3_export *exp = NULL; - int ret = 0; + struct nfs3_export *exp = NULL; + int ret = 0; - GF_VALIDATE_OR_GOTO (GF_NFS3, nfs3, out); - GF_VALIDATE_OR_GOTO (GF_NFS3, rootfh, out); + GF_VALIDATE_OR_GOTO(GF_NFS3, nfs3, out); + GF_VALIDATE_OR_GOTO(GF_NFS3, rootfh, out); - exp = __nfs3_get_export_by_exportid (nfs3, rootfh->exportid); - if (!exp) - goto out; + exp = __nfs3_get_export_by_exportid(nfs3, rootfh->exportid); + if (!exp) + goto out; - exp->rootlookedup = 1; + exp->rootlookedup = 1; out: - return ret; -} - - -#define nfs3_map_fh_to_volume(nfs3state, handle, req, volume, status, label) \ - do { \ - char exportid[256], gfid[256]; \ - rpc_transport_t *trans = NULL; \ - volume = nfs3_fh_to_xlator ((nfs3state), handle); \ - if (!volume) { \ - gf_uuid_unparse (handle->exportid, exportid); \ - gf_uuid_unparse (handle->gfid, gfid); \ - trans = rpcsvc_request_transport (req); \ - GF_LOG_OCCASIONALLY (nfs3state->occ_logger, \ - GF_NFS3, GF_LOG_ERROR, "Failed to map " \ - "FH to vol: client=%s, exportid=%s, " \ - "gfid=%s", trans->peerinfo.identifier, \ - exportid, gfid); \ - GF_LOG_OCCASIONALLY (nfs3state->occ_logger, \ - GF_NFS3, GF_LOG_ERROR, "Stale nfs " \ - "client %s must be trying to connect to"\ - " a deleted volume, please unmount it.",\ - trans->peerinfo.identifier); \ - status = NFS3ERR_STALE; \ - goto label; \ - } else { \ - gf_msg_trace (GF_NFS3, 0, "FH to Volume:" \ - "%s", volume->name); \ - rpcsvc_request_set_private (req, volume); \ - } \ - } while (0); \ - - -#define nfs3_validate_gluster_fh(handle, status, errlabel) \ - do { \ - if (!nfs3_fh_validate (handle)) { \ - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, \ - NFS_MSG_BAD_HANDLE, \ - "Bad Handle"); \ - status = NFS3ERR_BADHANDLE; \ - goto errlabel; \ - } \ - } while (0) \ - - -#define nfs3_check_fh_auth_status(cst, nfstat, is_write_op, erlabl) \ - do { \ - int auth_ret = 0; \ - int auth_errno = 0; \ - xlator_t *xlatorp = NULL; \ - char buf[256], gfid[GF_UUID_BUF_SIZE]; \ - rpc_transport_t *trans = NULL; \ - \ - auth_ret = auth_errno = \ - nfs3_fh_auth_nfsop (cst, is_write_op); \ - if (auth_ret < 0) { \ - trans = rpcsvc_request_transport (cst->req); \ - xlatorp = nfs3_fh_to_xlator (cst->nfs3state, \ - &cst->resolvefh); \ - gf_uuid_unparse (cst->resolvefh.gfid, gfid); \ - sprintf (buf, "(%s) %s : %s", \ - trans->peerinfo.identifier, \ - xlatorp ? xlatorp->name : "ERR", gfid); \ - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, \ - NFS_MSG_RESOLVE_FH_FAIL, "Unable to " \ - "resolve FH: %s", buf); \ - nfstat = nfs3_errno_to_nfsstat3 (-auth_errno); \ - goto erlabl; \ - } \ - } while (0) \ - -#define nfs3_check_fh_resolve_status(cst, nfstat, erlabl) \ - do { \ - xlator_t *xlatorp = NULL; \ - char buf[256], gfid[GF_UUID_BUF_SIZE]; \ - rpc_transport_t *trans = NULL; \ - if ((cst)->resolve_ret < 0) { \ - trans = rpcsvc_request_transport (cst->req); \ - xlatorp = nfs3_fh_to_xlator (cst->nfs3state, \ - &cst->resolvefh); \ - gf_uuid_unparse (cst->resolvefh.gfid, gfid); \ - snprintf (buf, sizeof (buf), "(%s) %s : %s", \ - trans->peerinfo.identifier, \ - xlatorp ? xlatorp->name : "ERR", \ - gfid); \ - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, \ - NFS_MSG_RESOLVE_STAT, \ - "%s: %s", strerror(cst->resolve_errno), \ - buf); \ - nfstat = nfs3_errno_to_nfsstat3 (cst->resolve_errno);\ - goto erlabl; \ - } \ - } while (0) \ - -#define nfs3_check_new_fh_resolve_status(cst, nfstat, erlabl) \ - do { \ - xlator_t *xlatorp = NULL; \ - char buf[256], gfid[GF_UUID_BUF_SIZE]; \ - rpc_transport_t *trans = NULL; \ - if (((cst)->resolve_ret < 0) && \ - ((cst)->resolve_errno != ENOENT)) { \ - trans = rpcsvc_request_transport (cst->req); \ - xlatorp = nfs3_fh_to_xlator (cst->nfs3state, \ - &cst->resolvefh); \ - gf_uuid_unparse (cst->resolvefh.gfid, gfid); \ - snprintf (buf, sizeof (buf), "(%s) %s : %s", \ - trans->peerinfo.identifier, \ - xlatorp ? xlatorp->name : "ERR", \ - gfid); \ - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, \ - NFS_MSG_RESOLVE_STAT, "%s: %s", \ - strerror(cst->resolve_errno), buf); \ - nfstat = nfs3_errno_to_nfsstat3 (cs->resolve_errno);\ - goto erlabl; \ - } \ - } while (0) \ - + return ret; +} + +#define nfs3_map_fh_to_volume(nfs3state, handle, req, volume, status, label) \ + do { \ + char exportid[256], gfid[256]; \ + rpc_transport_t *trans = NULL; \ + volume = nfs3_fh_to_xlator((nfs3state), handle); \ + if (!volume) { \ + gf_uuid_unparse(handle->exportid, exportid); \ + gf_uuid_unparse(handle->gfid, gfid); \ + trans = rpcsvc_request_transport(req); \ + GF_LOG_OCCASIONALLY(nfs3state->occ_logger, GF_NFS3, GF_LOG_ERROR, \ + "Failed to map " \ + "FH to vol: client=%s, exportid=%s, " \ + "gfid=%s", \ + trans->peerinfo.identifier, exportid, gfid); \ + GF_LOG_OCCASIONALLY(nfs3state->occ_logger, GF_NFS3, GF_LOG_ERROR, \ + "Stale nfs " \ + "client %s must be trying to connect to" \ + " a deleted volume, please unmount it.", \ + trans->peerinfo.identifier); \ + status = NFS3ERR_STALE; \ + goto label; \ + } else { \ + gf_msg_trace(GF_NFS3, 0, \ + "FH to Volume:" \ + "%s", \ + volume->name); \ + rpcsvc_request_set_private(req, volume); \ + } \ + } while (0); + +#define nfs3_validate_gluster_fh(handle, status, errlabel) \ + do { \ + if (!nfs3_fh_validate(handle)) { \ + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_BAD_HANDLE, \ + "Bad Handle"); \ + status = NFS3ERR_BADHANDLE; \ + goto errlabel; \ + } \ + } while (0) + +#define nfs3_check_fh_auth_status(cst, nfstat, is_write_op, erlabl) \ + do { \ + int auth_ret = 0; \ + int auth_errno = 0; \ + xlator_t *xlatorp = NULL; \ + char buf[256], gfid[GF_UUID_BUF_SIZE]; \ + rpc_transport_t *trans = NULL; \ + \ + auth_ret = auth_errno = nfs3_fh_auth_nfsop(cst, is_write_op); \ + if (auth_ret < 0) { \ + trans = rpcsvc_request_transport(cst->req); \ + xlatorp = nfs3_fh_to_xlator(cst->nfs3state, &cst->resolvefh); \ + gf_uuid_unparse(cst->resolvefh.gfid, gfid); \ + sprintf(buf, "(%s) %s : %s", trans->peerinfo.identifier, \ + xlatorp ? xlatorp->name : "ERR", gfid); \ + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_RESOLVE_FH_FAIL, \ + "Unable to " \ + "resolve FH: %s", \ + buf); \ + nfstat = nfs3_errno_to_nfsstat3(-auth_errno); \ + goto erlabl; \ + } \ + } while (0) + +#define nfs3_check_fh_resolve_status(cst, nfstat, erlabl) \ + do { \ + xlator_t *xlatorp = NULL; \ + char buf[256], gfid[GF_UUID_BUF_SIZE]; \ + rpc_transport_t *trans = NULL; \ + if ((cst)->resolve_ret < 0) { \ + trans = rpcsvc_request_transport(cst->req); \ + xlatorp = nfs3_fh_to_xlator(cst->nfs3state, &cst->resolvefh); \ + gf_uuid_unparse(cst->resolvefh.gfid, gfid); \ + snprintf(buf, sizeof(buf), "(%s) %s : %s", \ + trans->peerinfo.identifier, \ + xlatorp ? xlatorp->name : "ERR", gfid); \ + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_RESOLVE_STAT, "%s: %s", \ + strerror(cst->resolve_errno), buf); \ + nfstat = nfs3_errno_to_nfsstat3(cst->resolve_errno); \ + goto erlabl; \ + } \ + } while (0) + +#define nfs3_check_new_fh_resolve_status(cst, nfstat, erlabl) \ + do { \ + xlator_t *xlatorp = NULL; \ + char buf[256], gfid[GF_UUID_BUF_SIZE]; \ + rpc_transport_t *trans = NULL; \ + if (((cst)->resolve_ret < 0) && ((cst)->resolve_errno != ENOENT)) { \ + trans = rpcsvc_request_transport(cst->req); \ + xlatorp = nfs3_fh_to_xlator(cst->nfs3state, &cst->resolvefh); \ + gf_uuid_unparse(cst->resolvefh.gfid, gfid); \ + snprintf(buf, sizeof(buf), "(%s) %s : %s", \ + trans->peerinfo.identifier, \ + xlatorp ? xlatorp->name : "ERR", gfid); \ + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_RESOLVE_STAT, "%s: %s", \ + strerror(cst->resolve_errno), buf); \ + nfstat = nfs3_errno_to_nfsstat3(cs->resolve_errno); \ + goto erlabl; \ + } \ + } while (0) int -__nfs3_get_volume_id (struct nfs3_state *nfs3, xlator_t *xl, - uuid_t volumeid) +__nfs3_get_volume_id(struct nfs3_state *nfs3, xlator_t *xl, uuid_t volumeid) { - int ret = -1; - struct nfs3_export *exp = NULL; + int ret = -1; + struct nfs3_export *exp = NULL; - GF_VALIDATE_OR_GOTO (GF_NFS3, nfs3, out); - GF_VALIDATE_OR_GOTO (GF_NFS3, xl, out); + GF_VALIDATE_OR_GOTO(GF_NFS3, nfs3, out); + GF_VALIDATE_OR_GOTO(GF_NFS3, xl, out); - list_for_each_entry (exp, &nfs3->exports, explist) { - if (exp->subvol == xl) { - gf_uuid_copy (volumeid, exp->volumeid); - ret = 0; - goto out; - } + list_for_each_entry(exp, &nfs3->exports, explist) + { + if (exp->subvol == xl) { + gf_uuid_copy(volumeid, exp->volumeid); + ret = 0; + goto out; } + } out: - return ret; + return ret; } - static int -nfs3_funge_webnfs_zerolen_fh (rpcsvc_request_t *req, struct nfs3_state *nfs3st, - struct nfs3_fh *fhd, char *name) -{ - xlator_t *fungexl = NULL; - struct nfs_state *nfs = NULL; - glfs_t *fs = NULL; - loc_t loc = { 0, }; - int ret = -1; - char *subdir = NULL; - char volname[NAME_MAX] = { 0, }; - - fungexl = nfs_mntpath_to_xlator (nfs3st->exportslist, name); - if (!fungexl) { - gf_msg_trace (GF_NFS3, 0, "failed to find xlator for volume"); - ret = -ENOENT; - goto out; - } - /* fungexl is valid, set for nfs3_request_xlator_deviceid() */ - rpcsvc_request_set_private (req, fungexl); - - /* Permission checks are done through mnt3_parse_dir_exports(). The - * "nfs.export-dir" option gets checked as well. */ - nfs = nfs_state (nfs3st->nfsx); - ret = mnt3_parse_dir_exports (req, nfs->mstate, name, _gf_false); - if (ret) { - gf_msg_trace (GF_NFS3, -ret, "mounting not possible"); - goto out; - } - - /* glfs_resolve_at copied from UDP MNT support */ - fs = glfs_new_from_ctx (fungexl->ctx); - if (!fs) { - gf_msg_trace (GF_NFS3, 0, "failed to create glfs instance"); - ret = -ENOENT; - goto out; - } - - /* split name "volname/sub/dir/s" into pieces */ - subdir = mnt3_get_volume_subdir (name, (char**) &volname); - - ret = glfs_resolve_at (fs, fungexl, NULL, subdir, &loc, NULL, 1, 0); - if (ret != 0) { - gf_msg_trace (GF_NFS3, 0, "failed to resolve %s", subdir); - ret = -ENOENT; - goto out; - } - - /* resolved subdir, copy gfid for the fh */ - gf_uuid_copy (fhd->gfid, loc.gfid); - loc_wipe (&loc); - - if (gf_nfs_dvm_off (nfs_state (nfs3st->nfsx))) - fhd->exportid[15] = nfs_xlator_to_xlid (nfs3st->exportslist, - fungexl); - else { - if (__nfs3_get_volume_id (nfs3st, fungexl, fhd->exportid) < 0) { - ret = -ESTALE; - goto out; - } - } - - ret = 0; +nfs3_funge_webnfs_zerolen_fh(rpcsvc_request_t *req, struct nfs3_state *nfs3st, + struct nfs3_fh *fhd, char *name) +{ + xlator_t *fungexl = NULL; + struct nfs_state *nfs = NULL; + glfs_t *fs = NULL; + loc_t loc = { + 0, + }; + int ret = -1; + char *subdir = NULL; + char volname[NAME_MAX] = { + 0, + }; + + fungexl = nfs_mntpath_to_xlator(nfs3st->exportslist, name); + if (!fungexl) { + gf_msg_trace(GF_NFS3, 0, "failed to find xlator for volume"); + ret = -ENOENT; + goto out; + } + /* fungexl is valid, set for nfs3_request_xlator_deviceid() */ + rpcsvc_request_set_private(req, fungexl); + + /* Permission checks are done through mnt3_parse_dir_exports(). The + * "nfs.export-dir" option gets checked as well. */ + nfs = nfs_state(nfs3st->nfsx); + ret = mnt3_parse_dir_exports(req, nfs->mstate, name, _gf_false); + if (ret) { + gf_msg_trace(GF_NFS3, -ret, "mounting not possible"); + goto out; + } + + /* glfs_resolve_at copied from UDP MNT support */ + fs = glfs_new_from_ctx(fungexl->ctx); + if (!fs) { + gf_msg_trace(GF_NFS3, 0, "failed to create glfs instance"); + ret = -ENOENT; + goto out; + } + + /* split name "volname/sub/dir/s" into pieces */ + subdir = mnt3_get_volume_subdir(name, (char **)&volname); + + ret = glfs_resolve_at(fs, fungexl, NULL, subdir, &loc, NULL, 1, 0); + if (ret != 0) { + gf_msg_trace(GF_NFS3, 0, "failed to resolve %s", subdir); + ret = -ENOENT; + goto out; + } + + /* resolved subdir, copy gfid for the fh */ + gf_uuid_copy(fhd->gfid, loc.gfid); + loc_wipe(&loc); + + if (gf_nfs_dvm_off(nfs_state(nfs3st->nfsx))) + fhd->exportid[15] = nfs_xlator_to_xlid(nfs3st->exportslist, fungexl); + else { + if (__nfs3_get_volume_id(nfs3st, fungexl, fhd->exportid) < 0) { + ret = -ESTALE; + goto out; + } + } + + ret = 0; out: - if (fs) - glfs_free_from_ctx (fs); + if (fs) + glfs_free_from_ctx(fs); - return ret; + return ret; } - /* * This macro checks if the volume is started or not. * If it is not started, it closes the client connection & logs it. @@ -442,1802 +421,1758 @@ out: * */ -#define nfs3_volume_started_check(nf3stt, vlm, rtval, erlbl) \ - do { \ - if ((!nfs_subvolume_started (nfs_state (nf3stt->nfsx), vlm))){\ - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, \ - NFS_MSG_VOL_DISABLE, \ - "Volume is disabled: %s", \ - vlm->name); \ - nfs3_disconnect_transport (req->trans); \ - rtval = RPCSVC_ACTOR_IGNORE; \ - goto erlbl; \ - } \ - } while (0) \ +#define nfs3_volume_started_check(nf3stt, vlm, rtval, erlbl) \ + do { \ + if ((!nfs_subvolume_started(nfs_state(nf3stt->nfsx), vlm))) { \ + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_VOL_DISABLE, \ + "Volume is disabled: %s", vlm->name); \ + nfs3_disconnect_transport(req->trans); \ + rtval = RPCSVC_ACTOR_IGNORE; \ + goto erlbl; \ + } \ + } while (0) void -nfs3_disconnect_transport (rpc_transport_t *transport) +nfs3_disconnect_transport(rpc_transport_t *transport) { - int ret = 0; + int ret = 0; - GF_VALIDATE_OR_GOTO (GF_NFS3, transport, out); + GF_VALIDATE_OR_GOTO(GF_NFS3, transport, out); - ret = rpc_transport_disconnect (transport, _gf_false); - if (ret != 0) { - gf_log (GF_NFS3, GF_LOG_WARNING, - "Unable to close client connection to %s.", - transport->peerinfo.identifier); - } else { - gf_log (GF_NFS3, GF_LOG_WARNING, - "Closed client connection to %s.", - transport->peerinfo.identifier); - } + ret = rpc_transport_disconnect(transport, _gf_false); + if (ret != 0) { + gf_log(GF_NFS3, GF_LOG_WARNING, + "Unable to close client connection to %s.", + transport->peerinfo.identifier); + } else { + gf_log(GF_NFS3, GF_LOG_WARNING, "Closed client connection to %s.", + transport->peerinfo.identifier); + } out: - return; + return; } int -nfs3_export_sync_trusted (struct nfs3_state *nfs3, uuid_t exportid) +nfs3_export_sync_trusted(struct nfs3_state *nfs3, uuid_t exportid) { - struct nfs3_export *exp = NULL; - int ret = 0; + struct nfs3_export *exp = NULL; + int ret = 0; - GF_VALIDATE_OR_GOTO (GF_NFS3, nfs3, err); + GF_VALIDATE_OR_GOTO(GF_NFS3, nfs3, err); - exp = __nfs3_get_export_by_exportid (nfs3, exportid); - if (!exp) - goto err; + exp = __nfs3_get_export_by_exportid(nfs3, exportid); + if (!exp) + goto err; - ret = exp->trusted_sync; + ret = exp->trusted_sync; err: - return ret; + return ret; } - int -nfs3_export_write_trusted (struct nfs3_state *nfs3, uuid_t exportid) +nfs3_export_write_trusted(struct nfs3_state *nfs3, uuid_t exportid) { - struct nfs3_export *exp = NULL; - int ret = 0; + struct nfs3_export *exp = NULL; + int ret = 0; - GF_VALIDATE_OR_GOTO (GF_NFS3, nfs3, err); + GF_VALIDATE_OR_GOTO(GF_NFS3, nfs3, err); - exp = __nfs3_get_export_by_exportid (nfs3, exportid); - if (!exp) - goto err; + exp = __nfs3_get_export_by_exportid(nfs3, exportid); + if (!exp) + goto err; - ret = exp->trusted_write; + ret = exp->trusted_write; err: - return ret; + return ret; } int -nfs3_solaris_zerolen_fh (struct nfs3_fh *fh, int fhlen) +nfs3_solaris_zerolen_fh(struct nfs3_fh *fh, int fhlen) { - if (!fh) - return 0; + if (!fh) + return 0; - if (nfs3_fh_validate (fh)) - return 0; + if (nfs3_fh_validate(fh)) + return 0; - if (fhlen == 0) { - gf_msg_trace (GF_NFS3, 0, "received WebNFS request"); - return 1; - } + if (fhlen == 0) { + gf_msg_trace(GF_NFS3, 0, "received WebNFS request"); + return 1; + } - return 0; + return 0; } - /* Function pointer that represents the generic prototypes of functions used * to serialize NFS3 message structures into the XDR format. * For usage, see the nfs3svc_XXX_cbk functions. */ -typedef ssize_t (*nfs3_serializer) (struct iovec outmsg, void *args); +typedef ssize_t (*nfs3_serializer)(struct iovec outmsg, void *args); static void -__nfs3_call_state_wipe (nfs3_call_state_t *cs) +__nfs3_call_state_wipe(nfs3_call_state_t *cs) { - if (cs->fd) { - gf_msg_trace (GF_NFS3, 0, "fd 0x%lx ref: %"PRId64, - (long)cs->fd, GF_ATOMIC_GET (cs->fd->refcount)); - fd_unref (cs->fd); - } + if (cs->fd) { + gf_msg_trace(GF_NFS3, 0, "fd 0x%lx ref: %" PRId64, (long)cs->fd, + GF_ATOMIC_GET(cs->fd->refcount)); + fd_unref(cs->fd); + } - GF_FREE (cs->resolventry); + GF_FREE(cs->resolventry); - GF_FREE (cs->pathname); + GF_FREE(cs->pathname); - if (!list_empty (&cs->entries.list)) - gf_dirent_free (&cs->entries); + if (!list_empty(&cs->entries.list)) + gf_dirent_free(&cs->entries); - nfs_loc_wipe (&cs->oploc); - nfs_loc_wipe (&cs->resolvedloc); - if (cs->iob) - iobuf_unref (cs->iob); - if (cs->iobref) - iobref_unref (cs->iobref); - if (cs->trans) - rpc_transport_unref (cs->trans); - memset (cs, 0, sizeof (*cs)); - mem_put (cs); - /* Already refd by fd_lookup, so no need to ref again. */ + nfs_loc_wipe(&cs->oploc); + nfs_loc_wipe(&cs->resolvedloc); + if (cs->iob) + iobuf_unref(cs->iob); + if (cs->iobref) + iobref_unref(cs->iobref); + if (cs->trans) + rpc_transport_unref(cs->trans); + memset(cs, 0, sizeof(*cs)); + mem_put(cs); + /* Already refd by fd_lookup, so no need to ref again. */ } nfs3_call_state_t * -nfs3_call_state_init (struct nfs3_state *s, rpcsvc_request_t *req, xlator_t *v) -{ - nfs3_call_state_t *cs = NULL; - - GF_VALIDATE_OR_GOTO (GF_NFS3, s, err); - GF_VALIDATE_OR_GOTO (GF_NFS3, req, err); - /* GF_VALIDATE_OR_GOTO (GF_NFS3, v, err); NLM sets this later */ - - cs = (nfs3_call_state_t *) mem_get (s->localpool); - if (!cs) { - gf_msg (GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "out of memory"); - return NULL; - } - - memset (cs, 0, sizeof (*cs)); - GF_REF_INIT (cs, __nfs3_call_state_wipe); - INIT_LIST_HEAD (&cs->entries.list); - INIT_LIST_HEAD (&cs->openwait_q); - cs->operrno = EINVAL; - cs->req = req; - cs->vol = v; - cs->nfsx = s->nfsx; - cs->nfs3state = s; +nfs3_call_state_init(struct nfs3_state *s, rpcsvc_request_t *req, xlator_t *v) +{ + nfs3_call_state_t *cs = NULL; + + GF_VALIDATE_OR_GOTO(GF_NFS3, s, err); + GF_VALIDATE_OR_GOTO(GF_NFS3, req, err); + /* GF_VALIDATE_OR_GOTO (GF_NFS3, v, err); NLM sets this later */ + + cs = (nfs3_call_state_t *)mem_get(s->localpool); + if (!cs) { + gf_msg(GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "out of memory"); + return NULL; + } + + memset(cs, 0, sizeof(*cs)); + GF_REF_INIT(cs, __nfs3_call_state_wipe); + INIT_LIST_HEAD(&cs->entries.list); + INIT_LIST_HEAD(&cs->openwait_q); + cs->operrno = EINVAL; + cs->req = req; + cs->vol = v; + cs->nfsx = s->nfsx; + cs->nfs3state = s; err: - return cs; + return cs; } void -nfs3_call_state_wipe (nfs3_call_state_t *cs) +nfs3_call_state_wipe(nfs3_call_state_t *cs) { - if (!cs) { - gf_log_callingfn ("nfs", GF_LOG_WARNING, "nfs calling state NULL"); - return; - } - GF_REF_PUT (cs); -} - - -#define nfs3_handle_call_state_init(nfs3state, calls, rq, vl ,opstat, errlabel)\ - do { \ - calls = nfs3_call_state_init ((nfs3state), (rq), (vl)); \ - if (!calls) { \ - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, \ - NFS_MSG_INIT_CALL_STAT_FAIL, "Failed to"\ - " init call state"); \ - opstat = NFS3ERR_SERVERFAULT; \ - goto errlabel; \ - } \ - } while (0) \ - - + if (!cs) { + gf_log_callingfn("nfs", GF_LOG_WARNING, "nfs calling state NULL"); + return; + } + GF_REF_PUT(cs); +} + +#define nfs3_handle_call_state_init(nfs3state, calls, rq, vl, opstat, \ + errlabel) \ + do { \ + calls = nfs3_call_state_init((nfs3state), (rq), (vl)); \ + if (!calls) { \ + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_INIT_CALL_STAT_FAIL, \ + "Failed to" \ + " init call state"); \ + opstat = NFS3ERR_SERVERFAULT; \ + goto errlabel; \ + } \ + } while (0) struct iobuf * -nfs3_serialize_reply (rpcsvc_request_t *req, void *arg, nfs3_serializer sfunc, - struct iovec *outmsg) -{ - struct nfs3_state *nfs3 = NULL; - struct iobuf *iob = NULL; - ssize_t retlen = -1; - - nfs3 = (struct nfs3_state *)rpcsvc_request_program_private (req); - if (!nfs3) { - gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_STATE_MISSING, - "NFSv3 state not found in RPC request"); - goto ret; - } - - /* First, get the io buffer into which the reply in arg will - * be serialized. - */ - /* TODO: get rid of 'sfunc' and use 'xdrproc_t' so we - can have 'xdr_sizeof' */ - iob = iobuf_get (nfs3->iobpool); - if (!iob) { - gf_msg (GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to get iobuf"); - goto ret; - } - - iobuf_to_iovec (iob, outmsg); - /* Use the given serializer to translate the give C structure in arg - * to XDR format which will be written into the buffer in outmsg. - */ - /* retlen is used to received the error since size_t is unsigned and we - * need -1 for error notification during encoding. - */ - retlen = sfunc (*outmsg, arg); - if (retlen == -1) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ENCODE_FAIL, - "Failed to encode message"); - goto ret; - } - - outmsg->iov_len = retlen; +nfs3_serialize_reply(rpcsvc_request_t *req, void *arg, nfs3_serializer sfunc, + struct iovec *outmsg) +{ + struct nfs3_state *nfs3 = NULL; + struct iobuf *iob = NULL; + ssize_t retlen = -1; + + nfs3 = (struct nfs3_state *)rpcsvc_request_program_private(req); + if (!nfs3) { + gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_STATE_MISSING, + "NFSv3 state not found in RPC request"); + goto ret; + } + + /* First, get the io buffer into which the reply in arg will + * be serialized. + */ + /* TODO: get rid of 'sfunc' and use 'xdrproc_t' so we + can have 'xdr_sizeof' */ + iob = iobuf_get(nfs3->iobpool); + if (!iob) { + gf_msg(GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to get iobuf"); + goto ret; + } + + iobuf_to_iovec(iob, outmsg); + /* Use the given serializer to translate the give C structure in arg + * to XDR format which will be written into the buffer in outmsg. + */ + /* retlen is used to received the error since size_t is unsigned and we + * need -1 for error notification during encoding. + */ + retlen = sfunc(*outmsg, arg); + if (retlen == -1) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ENCODE_FAIL, + "Failed to encode message"); + goto ret; + } + + outmsg->iov_len = retlen; ret: - if (retlen == -1) { - iobuf_unref (iob); - iob = NULL; - } + if (retlen == -1) { + iobuf_unref(iob); + iob = NULL; + } - return iob; + return iob; } - - /* Generic reply function for NFSv3 specific replies. */ int -nfs3svc_submit_reply (rpcsvc_request_t *req, void *arg, nfs3_serializer sfunc) -{ - struct iovec outmsg = {0, }; - struct iobuf *iob = NULL; - int ret = -1; - struct iobref *iobref = NULL; - - if (!req) - return -1; - - iob = nfs3_serialize_reply (req, arg, sfunc, &outmsg); - if (!iob) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SERIALIZE_REPLY_FAIL, - "Failed to serialize reply"); - goto ret; - } - - iobref = iobref_new (); - if (!iobref) { - gf_msg (GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "failed on iobref_new()"); - goto ret; - } - - ret = iobref_add (iobref, iob); - if (ret) { - gf_msg (GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to add iob to iobref"); - goto ret; - } - - /* Then, submit the message for transmission. */ - ret = rpcsvc_submit_message (req, &outmsg, 1, NULL, 0, iobref); - if (ret == -1) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SUBMIT_REPLY_FAIL, - "Reply submission failed"); - goto ret; - } - - ret = 0; +nfs3svc_submit_reply(rpcsvc_request_t *req, void *arg, nfs3_serializer sfunc) +{ + struct iovec outmsg = { + 0, + }; + struct iobuf *iob = NULL; + int ret = -1; + struct iobref *iobref = NULL; + + if (!req) + return -1; + + iob = nfs3_serialize_reply(req, arg, sfunc, &outmsg); + if (!iob) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SERIALIZE_REPLY_FAIL, + "Failed to serialize reply"); + goto ret; + } + + iobref = iobref_new(); + if (!iobref) { + gf_msg(GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "failed on iobref_new()"); + goto ret; + } + + ret = iobref_add(iobref, iob); + if (ret) { + gf_msg(GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to add iob to iobref"); + goto ret; + } + + /* Then, submit the message for transmission. */ + ret = rpcsvc_submit_message(req, &outmsg, 1, NULL, 0, iobref); + if (ret == -1) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SUBMIT_REPLY_FAIL, + "Reply submission failed"); + goto ret; + } + + ret = 0; ret: - /* Now that we've done our job of handing the message to the RPC layer - * we can safely unref the iob in the hope that RPC layer must have - * ref'ed the iob on receiving into the txlist. - */ - if (NULL != iob) - iobuf_unref (iob); - if (NULL != iobref) - iobref_unref (iobref); - return ret; + /* Now that we've done our job of handing the message to the RPC layer + * we can safely unref the iob in the hope that RPC layer must have + * ref'ed the iob on receiving into the txlist. + */ + if (NULL != iob) + iobuf_unref(iob); + if (NULL != iobref) + iobref_unref(iobref); + return ret; } - int -nfs3svc_submit_vector_reply (rpcsvc_request_t *req, void *arg, - nfs3_serializer sfunc, struct iovec *payload, - int vcount, struct iobref *iobref) -{ - struct iovec outmsg = {0, }; - struct iobuf *iob = NULL; - int ret = -1; - int new_iobref = 0; - - if (!req) - return -1; - - iob = nfs3_serialize_reply (req, arg, sfunc, &outmsg); - if (!iob) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SERIALIZE_REPLY_FAIL, - "Failed to serialize reply"); - goto ret; - } - if (iobref == NULL) { - iobref = iobref_new (); - if (!iobref) { - gf_msg (GF_NFS3, GF_LOG_ERROR, ENOMEM, - NFS_MSG_NO_MEMORY, "failed on iobref_new"); - goto ret; - } - new_iobref = 1; - } - - ret = iobref_add (iobref, iob); - if (ret) { - gf_msg (GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to add iob to iobref"); - goto ret; - } - - /* Then, submit the message for transmission. */ - ret = rpcsvc_submit_message (req, &outmsg, 1, payload, vcount, iobref); - if (ret == -1) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SUBMIT_REPLY_FAIL, - "Reply submission failed"); - goto ret; - } - - ret = 0; +nfs3svc_submit_vector_reply(rpcsvc_request_t *req, void *arg, + nfs3_serializer sfunc, struct iovec *payload, + int vcount, struct iobref *iobref) +{ + struct iovec outmsg = { + 0, + }; + struct iobuf *iob = NULL; + int ret = -1; + int new_iobref = 0; + + if (!req) + return -1; + + iob = nfs3_serialize_reply(req, arg, sfunc, &outmsg); + if (!iob) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SERIALIZE_REPLY_FAIL, + "Failed to serialize reply"); + goto ret; + } + if (iobref == NULL) { + iobref = iobref_new(); + if (!iobref) { + gf_msg(GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "failed on iobref_new"); + goto ret; + } + new_iobref = 1; + } + + ret = iobref_add(iobref, iob); + if (ret) { + gf_msg(GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to add iob to iobref"); + goto ret; + } + + /* Then, submit the message for transmission. */ + ret = rpcsvc_submit_message(req, &outmsg, 1, payload, vcount, iobref); + if (ret == -1) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SUBMIT_REPLY_FAIL, + "Reply submission failed"); + goto ret; + } + + ret = 0; ret: - /* Now that we've done our job of handing the message to the RPC layer - * we can safely unref the iob in the hope that RPC layer must have - * ref'ed the iob on receiving into the txlist. - */ - if (NULL != iob) - iobuf_unref (iob); - if (new_iobref) - iobref_unref (iobref); - return ret; + /* Now that we've done our job of handing the message to the RPC layer + * we can safely unref the iob in the hope that RPC layer must have + * ref'ed the iob on receiving into the txlist. + */ + if (NULL != iob) + iobuf_unref(iob); + if (new_iobref) + iobref_unref(iobref); + return ret; } uint64_t -nfs3_request_xlator_deviceid (rpcsvc_request_t *rq) -{ - struct nfs3_state *nfs3 = NULL; - xlator_t *xl = NULL; - uint64_t devid = 0; - uuid_t volumeid = {0, }; - - if (!rq) - return 0; - - xl = rpcsvc_request_private (rq); - nfs3 = rpcsvc_request_program_private (rq); - if (gf_nfs_dvm_off (nfs_state (nfs3->nfsx))) - devid = (uint64_t)nfs_xlator_to_xlid (nfs3->exportslist, xl); - else { - __nfs3_get_volume_id (nfs3, xl, volumeid); - memcpy (&devid, &volumeid[8], sizeof (devid)); - } +nfs3_request_xlator_deviceid(rpcsvc_request_t *rq) +{ + struct nfs3_state *nfs3 = NULL; + xlator_t *xl = NULL; + uint64_t devid = 0; + uuid_t volumeid = { + 0, + }; - return devid; -} + if (!rq) + return 0; + + xl = rpcsvc_request_private(rq); + nfs3 = rpcsvc_request_program_private(rq); + if (gf_nfs_dvm_off(nfs_state(nfs3->nfsx))) + devid = (uint64_t)nfs_xlator_to_xlid(nfs3->exportslist, xl); + else { + __nfs3_get_volume_id(nfs3, xl, volumeid); + memcpy(&devid, &volumeid[8], sizeof(devid)); + } + return devid; +} int -nfs3svc_null (rpcsvc_request_t *req) +nfs3svc_null(rpcsvc_request_t *req) { - struct iovec dummyvec = {0, }; - if (!req) - return RPCSVC_ACTOR_ERROR; - rpcsvc_submit_generic (req, &dummyvec, 1, NULL, 0, NULL); - return RPCSVC_ACTOR_SUCCESS; + struct iovec dummyvec = { + 0, + }; + if (!req) + return RPCSVC_ACTOR_ERROR; + rpcsvc_submit_generic(req, &dummyvec, 1, NULL, 0, NULL); + return RPCSVC_ACTOR_SUCCESS; } - int -nfs3_getattr_reply (rpcsvc_request_t *req, nfsstat3 status, struct iatt *buf) +nfs3_getattr_reply(rpcsvc_request_t *req, nfsstat3 status, struct iatt *buf) { - getattr3res res; - uint64_t deviceid = 0; + getattr3res res; + uint64_t deviceid = 0; - deviceid = nfs3_request_xlator_deviceid (req); - nfs3_fill_getattr3res (&res, status, buf, deviceid); - nfs3svc_submit_reply (req, &res, - (nfs3_serializer)xdr_serialize_getattr3res); + deviceid = nfs3_request_xlator_deviceid(req); + nfs3_fill_getattr3res(&res, status, buf, deviceid); + nfs3svc_submit_reply(req, &res, (nfs3_serializer)xdr_serialize_getattr3res); - return 0; + return 0; } - int32_t -nfs3svc_getattr_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, dict_t *xattr, - struct iatt *postparent) +nfs3svc_getattr_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, dict_t *xattr, + struct iatt *postparent) { - nfsstat3 status = NFS3_OK; - nfs3_call_state_t *cs = NULL; + nfsstat3 status = NFS3_OK; + nfs3_call_state_t *cs = NULL; - cs = frame->local; + cs = frame->local; - /* - * Somewhat counter-intuitively, we don't need to look for sh-failed - * here. Failing this getattr will generate a new lookup from the - * client, and nfs_fop_lookup_cbk will detect any self-heal failures. - */ + /* + * Somewhat counter-intuitively, we don't need to look for sh-failed + * here. Failing this getattr will generate a new lookup from the + * client, and nfs_fop_lookup_cbk will detect any self-heal failures. + */ - if (op_ret == -1) { - status = nfs3_cbk_errno_status (op_ret, op_errno); - } - else { - nfs_fix_generation(this,inode); - } + if (op_ret == -1) { + status = nfs3_cbk_errno_status(op_ret, op_errno); + } else { + nfs_fix_generation(this, inode); + } - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_GETATTR, status, op_errno, - cs->resolvedloc.path); + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_GETATTR, status, + op_errno, cs->resolvedloc.path); - nfs3_getattr_reply (cs->req, status, buf); - nfs3_call_state_wipe (cs); + nfs3_getattr_reply(cs->req, status, buf); + nfs3_call_state_wipe(cs); - return 0; + return 0; } - int32_t -nfs3svc_getattr_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, - dict_t *xdata) +nfs3svc_getattr_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *buf, + dict_t *xdata) { - nfsstat3 status = NFS3_OK; - nfs3_call_state_t *cs = NULL; + nfsstat3 status = NFS3_OK; + nfs3_call_state_t *cs = NULL; - cs = frame->local; + cs = frame->local; - if (op_ret == -1) { - /* Prevent crashes for the case where this call fails - * and buf is left in a NULL state, yet the op_errno == 0. - */ - if (!buf && op_errno == 0) { - op_errno = EIO; - } - status = nfs3_cbk_errno_status (op_ret, op_errno); + if (op_ret == -1) { + /* Prevent crashes for the case where this call fails + * and buf is left in a NULL state, yet the op_errno == 0. + */ + if (!buf && op_errno == 0) { + op_errno = EIO; } + status = nfs3_cbk_errno_status(op_ret, op_errno); + } - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_GETATTR, status, op_errno, - cs->resolvedloc.path); + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_GETATTR, status, + op_errno, cs->resolvedloc.path); - nfs3_getattr_reply (cs->req, status, buf); - nfs3_call_state_wipe (cs); + nfs3_getattr_reply(cs->req, status, buf); + nfs3_call_state_wipe(cs); - return 0; + return 0; } - int -nfs3_getattr_resume (void *carg) -{ - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - nfs3_call_state_t *cs = NULL; - uint64_t raw_ctx = 0; - struct nfs_inode_ctx *ictx = NULL; - struct nfs_state *priv = NULL; - - if (!carg) - return ret; - - cs = (nfs3_call_state_t *)carg; - nfs3_check_fh_auth_status (cs, stat, _gf_false, nfs3err); - nfs3_check_fh_resolve_status (cs, stat, nfs3err); - nfs_request_user_init (&nfu, cs->req); - /* If inode which is to be getattr'd is the root, we need to do a - * lookup instead because after a server reboot, it is not necessary - * for the root to have been looked up when the getattr on the root is - * sent. AND, this causes a problem for stat-prefetch in that it - * expects even the root inode to have been looked up. - - if (__is_root_gfid (cs->resolvedloc.inode->gfid)) - ret = nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - nfs3svc_getattr_lookup_cbk, cs); - else - ret = nfs_stat (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - */ - - if (cs->hardresolved) { - ret = -EFAULT; - stat = NFS3_OK; - goto nfs3err; - } - - /* - * If brick state changed, we need to force a proper lookup cycle (as - * would happen in native protocol) to do self-heal checks. We detect - * this by comparing the generation number for the last successful - * creation/lookup on the inode to the current number, so inodes that - * haven't been validated since the state change are affected. - */ - if (inode_ctx_get(cs->resolvedloc.inode,cs->nfsx,&raw_ctx) == 0) { - ictx = (struct nfs_inode_ctx *)raw_ctx; - priv = cs->nfsx->private; - if (ictx->generation != priv->generation) { - ret = nfs_lookup (cs->nfsx, cs->vol, &nfu, - &cs->resolvedloc, - nfs3svc_getattr_lookup_cbk, cs); - goto check_err; - } - } +nfs3_getattr_resume(void *carg) +{ + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + nfs3_call_state_t *cs = NULL; + uint64_t raw_ctx = 0; + struct nfs_inode_ctx *ictx = NULL; + struct nfs_state *priv = NULL; + + if (!carg) + return ret; - ret = nfs_stat (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - nfs3svc_getattr_stat_cbk, cs); + cs = (nfs3_call_state_t *)carg; + nfs3_check_fh_auth_status(cs, stat, _gf_false, nfs3err); + nfs3_check_fh_resolve_status(cs, stat, nfs3err); + nfs_request_user_init(&nfu, cs->req); + /* If inode which is to be getattr'd is the root, we need to do a + * lookup instead because after a server reboot, it is not necessary + * for the root to have been looked up when the getattr on the root is + * sent. AND, this causes a problem for stat-prefetch in that it + * expects even the root inode to have been looked up. + + if (__is_root_gfid (cs->resolvedloc.inode->gfid)) + ret = nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + nfs3svc_getattr_lookup_cbk, cs); + else + ret = nfs_stat (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + */ + + if (cs->hardresolved) { + ret = -EFAULT; + stat = NFS3_OK; + goto nfs3err; + } + + /* + * If brick state changed, we need to force a proper lookup cycle (as + * would happen in native protocol) to do self-heal checks. We detect + * this by comparing the generation number for the last successful + * creation/lookup on the inode to the current number, so inodes that + * haven't been validated since the state change are affected. + */ + if (inode_ctx_get(cs->resolvedloc.inode, cs->nfsx, &raw_ctx) == 0) { + ictx = (struct nfs_inode_ctx *)raw_ctx; + priv = cs->nfsx->private; + if (ictx->generation != priv->generation) { + ret = nfs_lookup(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + nfs3svc_getattr_lookup_cbk, cs); + goto check_err; + } + } + + ret = nfs_stat(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + nfs3svc_getattr_stat_cbk, cs); check_err: - if (ret < 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_STAT_FOP_FAIL, - "Stat fop failed: %s: %s", cs->oploc.path, - strerror (-ret)); - stat = nfs3_errno_to_nfsstat3 (-ret); - } + if (ret < 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_STAT_FOP_FAIL, + "Stat fop failed: %s: %s", cs->oploc.path, strerror(-ret)); + stat = nfs3_errno_to_nfsstat3(-ret); + } nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_GETATTR, stat, -ret, - cs->resolvedloc.path); - nfs3_getattr_reply (cs->req, stat, &cs->stbuf); - nfs3_call_state_wipe (cs); - ret = 0; - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_GETATTR, stat, + -ret, cs->resolvedloc.path); + nfs3_getattr_reply(cs->req, stat, &cs->stbuf); + nfs3_call_state_wipe(cs); + ret = 0; + } - return ret; + return ret; } - int -nfs3_getattr (rpcsvc_request_t *req, struct nfs3_fh *fh) +nfs3_getattr(rpcsvc_request_t *req, struct nfs3_fh *fh) { - xlator_t *vol = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - struct nfs3_state *nfs3 = NULL; - nfs3_call_state_t *cstate = NULL; + xlator_t *vol = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + struct nfs3_state *nfs3 = NULL; + nfs3_call_state_t *cstate = NULL; - GF_VALIDATE_OR_GOTO (GF_NFS3, req, out); - GF_VALIDATE_OR_GOTO (GF_NFS3, fh, out); + GF_VALIDATE_OR_GOTO(GF_NFS3, req, out); + GF_VALIDATE_OR_GOTO(GF_NFS3, fh, out); - nfs3_log_common_call (rpcsvc_request_xid (req), "GETATTR", fh); - nfs3_validate_gluster_fh (fh, stat, nfs3err); - nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret); - nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err); - nfs3_volume_started_check (nfs3, vol, ret, out); - nfs3_handle_call_state_init (nfs3, cstate, req, vol, stat, nfs3err); + nfs3_log_common_call(rpcsvc_request_xid(req), "GETATTR", fh); + nfs3_validate_gluster_fh(fh, stat, nfs3err); + nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret); + nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err); + nfs3_volume_started_check(nfs3, vol, ret, out); + nfs3_handle_call_state_init(nfs3, cstate, req, vol, stat, nfs3err); - ret = nfs3_fh_resolve_and_resume (cstate, fh, NULL,nfs3_getattr_resume); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + ret = nfs3_fh_resolve_and_resume(cstate, fh, NULL, nfs3_getattr_resume); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (req), - NFS3_GETATTR, stat, -ret, - NULL); - nfs3_getattr_reply (req, stat, NULL); - ret = 0; - nfs3_call_state_wipe (cstate); - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_GETATTR, stat, -ret, + NULL); + nfs3_getattr_reply(req, stat, NULL); + ret = 0; + nfs3_call_state_wipe(cstate); + } out: - return ret; + return ret; } - int -nfs3svc_getattr (rpcsvc_request_t *req) +nfs3svc_getattr(rpcsvc_request_t *req) { - struct nfs3_fh fh = {{0}, }; - getattr3args args; - int ret = RPCSVC_ACTOR_ERROR; + struct nfs3_fh fh = { + {0}, + }; + getattr3args args; + int ret = RPCSVC_ACTOR_ERROR; - if (!req) - return ret; + if (!req) + return ret; - nfs3_prep_getattr3args (&args, &fh); - if (xdr_to_getattr3args (req->msg[0], &args) <= 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } - - ret = nfs3_getattr (req, &fh); - if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_GETATTR_FAIL, - "GETATTR procedure failed"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = RPCSVC_ACTOR_ERROR; - } + nfs3_prep_getattr3args(&args, &fh); + if (xdr_to_getattr3args(req->msg[0], &args) <= 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + ret = nfs3_getattr(req, &fh); + if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_GETATTR_FAIL, + "GETATTR procedure failed"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = RPCSVC_ACTOR_ERROR; + } rpcerr: - return ret; + return ret; } - int -nfs3_setattr_reply (rpcsvc_request_t *req, nfsstat3 stat, struct iatt *preop, - struct iatt *postop) +nfs3_setattr_reply(rpcsvc_request_t *req, nfsstat3 stat, struct iatt *preop, + struct iatt *postop) { - setattr3res res = {0, }; - uint64_t deviceid = 0; + setattr3res res = { + 0, + }; + uint64_t deviceid = 0; - deviceid = nfs3_request_xlator_deviceid (req); - nfs3_fill_setattr3res (&res, stat, preop, postop, deviceid); - nfs3svc_submit_reply (req, (void *)&res, - (nfs3_serializer) xdr_serialize_setattr3res); - return 0; + deviceid = nfs3_request_xlator_deviceid(req); + nfs3_fill_setattr3res(&res, stat, preop, postop, deviceid); + nfs3svc_submit_reply(req, (void *)&res, + (nfs3_serializer)xdr_serialize_setattr3res); + return 0; } - int32_t -nfs3svc_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf, dict_t *xdata) -{ - nfsstat3 stat = NFS3ERR_SERVERFAULT; - struct iatt *prestat = NULL; - nfs3_call_state_t *cs = NULL; - - cs = frame->local; - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - goto nfs3err; - } - - /* If the first stat was got from the guarded setattr callback, or - * from an earlier setattr call then we'll need to use that stat - * instead of the preop returned here. - */ - if (cs->preparent.ia_ino != 0) - prestat = &cs->preparent; - else - prestat = prebuf; - - stat = NFS3_OK; +nfs3svc_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) +{ + nfsstat3 stat = NFS3ERR_SERVERFAULT; + struct iatt *prestat = NULL; + nfs3_call_state_t *cs = NULL; + + cs = frame->local; + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + goto nfs3err; + } + + /* If the first stat was got from the guarded setattr callback, or + * from an earlier setattr call then we'll need to use that stat + * instead of the preop returned here. + */ + if (cs->preparent.ia_ino != 0) + prestat = &cs->preparent; + else + prestat = prebuf; + + stat = NFS3_OK; nfs3err: - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_SETATTR, stat, op_errno, - cs->resolvedloc.path); - nfs3_setattr_reply (cs->req, stat, prestat, postbuf); - nfs3_call_state_wipe (cs); + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_SETATTR, stat, + op_errno, cs->resolvedloc.path); + nfs3_setattr_reply(cs->req, stat, prestat, postbuf); + nfs3_call_state_wipe(cs); - return 0; + return 0; } - int32_t -nfs3svc_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *preop, - struct iatt *postop, dict_t *xdata) -{ - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -1; - struct iatt *prebuf = NULL; - nfs_user_t nfu = {0, }; - nfs3_call_state_t *cs = NULL; - - cs = frame->local; - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - goto nfs3err; - } - - prebuf = preop; - /* Store the current preop in case we need to send a truncate, - * in which case the preop to be returned will be this one. - */ - cs->preparent = *preop; +nfs3svc_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *preop, + struct iatt *postop, dict_t *xdata) +{ + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -1; + struct iatt *prebuf = NULL; + nfs_user_t nfu = { + 0, + }; + nfs3_call_state_t *cs = NULL; + + cs = frame->local; + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + goto nfs3err; + } + + prebuf = preop; + /* Store the current preop in case we need to send a truncate, + * in which case the preop to be returned will be this one. + */ + cs->preparent = *preop; + + /* Only truncate if the size is not already same as the requested + * truncation and also only if this is not a directory. + */ + if ((gf_attr_size_set(cs->setattr_valid)) && (!IA_ISDIR(postop->ia_type)) && + (preop->ia_size != cs->attr_in.ia_size)) { + nfs_request_user_init(&nfu, cs->req); + ret = nfs_truncate(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + cs->attr_in.ia_size, nfs3svc_truncate_cbk, cs); - /* Only truncate if the size is not already same as the requested - * truncation and also only if this is not a directory. - */ - if ((gf_attr_size_set (cs->setattr_valid)) && - (!IA_ISDIR (postop->ia_type)) && - (preop->ia_size != cs->attr_in.ia_size)) { - nfs_request_user_init (&nfu, cs->req); - ret = nfs_truncate (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - cs->attr_in.ia_size, nfs3svc_truncate_cbk, - cs); - - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); - } else { - ret = -1; /* Force a reply in the branch below. */ - stat = NFS3_OK; - } + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); + } else { + ret = -1; /* Force a reply in the branch below. */ + stat = NFS3_OK; + } nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_SETATTR, stat, op_errno, - cs->resolvedloc.path); - nfs3_setattr_reply (cs->req, stat, prebuf, postop); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_SETATTR, stat, + op_errno, cs->resolvedloc.path); + nfs3_setattr_reply(cs->req, stat, prebuf, postop); + nfs3_call_state_wipe(cs); + } - return 0; + return 0; } - - int32_t -nfs3svc_setattr_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, - dict_t *xdata) +nfs3svc_setattr_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *buf, + dict_t *xdata) { - - int ret = -EFAULT; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - nfs_user_t nfu = {0, }; - nfs3_call_state_t *cs = NULL; - - cs = frame->local; - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - goto nfs3err; - } - - if (buf->ia_ctime != cs->timestamp.seconds) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_TIMESTAMP_NO_SYNC, - "Timestamps not in sync"); - stat = NFS3ERR_NOT_SYNC; - goto nfs3err; - } - - /* Not a clean way but no motivation to add a new member to local. */ - cs->preparent = *buf; - nfs_request_user_init (&nfu, cs->req); - ret = nfs_setattr (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,&cs->stbuf, - cs->setattr_valid, nfs3svc_setattr_cbk, cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + int ret = -EFAULT; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + nfs_user_t nfu = { + 0, + }; + nfs3_call_state_t *cs = NULL; + + cs = frame->local; + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + goto nfs3err; + } + + if (buf->ia_ctime != cs->timestamp.seconds) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_TIMESTAMP_NO_SYNC, + "Timestamps not in sync"); + stat = NFS3ERR_NOT_SYNC; + goto nfs3err; + } + + /* Not a clean way but no motivation to add a new member to local. */ + cs->preparent = *buf; + nfs_request_user_init(&nfu, cs->req); + ret = nfs_setattr(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, &cs->stbuf, + cs->setattr_valid, nfs3svc_setattr_cbk, cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_SETATTR, stat, op_errno, - cs->resolvedloc.path); - nfs3_setattr_reply (cs->req, stat, NULL, NULL); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_SETATTR, stat, + op_errno, cs->resolvedloc.path); + nfs3_setattr_reply(cs->req, stat, NULL, NULL); + nfs3_call_state_wipe(cs); + } - return 0; + return 0; } - int -nfs3_setattr_resume (void *carg) +nfs3_setattr_resume(void *carg) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + nfs3_call_state_t *cs = NULL; - if (!carg) - return ret; + if (!carg) + return ret; - cs = (nfs3_call_state_t *)carg; - nfs3_check_fh_resolve_status (cs, stat, nfs3err); - nfs_request_user_init (&nfu, cs->req); - ret = nfs_setattr (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - &cs->attr_in, cs->setattr_valid, - nfs3svc_setattr_cbk, cs); + cs = (nfs3_call_state_t *)carg; + nfs3_check_fh_resolve_status(cs, stat, nfs3err); + nfs_request_user_init(&nfu, cs->req); + ret = nfs_setattr(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, &cs->attr_in, + cs->setattr_valid, nfs3svc_setattr_cbk, cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_SETATTR, stat, -ret, - cs->resolvedloc.path); - nfs3_setattr_reply (cs->req, stat, NULL, NULL); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_SETATTR, stat, + -ret, cs->resolvedloc.path); + nfs3_setattr_reply(cs->req, stat, NULL, NULL); + nfs3_call_state_wipe(cs); + } - return ret; + return ret; } - int -nfs3_setattr (rpcsvc_request_t *req, struct nfs3_fh *fh, sattr3 *sattr, - sattrguard3 *guard) -{ - xlator_t *vol = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - struct nfs3_state *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - - GF_VALIDATE_OR_GOTO (GF_NFS3, req, out); - GF_VALIDATE_OR_GOTO (GF_NFS3, fh, out); - GF_VALIDATE_OR_GOTO (GF_NFS3, sattr, out); - GF_VALIDATE_OR_GOTO (GF_NFS3, guard, out); - - nfs3_log_common_call (rpcsvc_request_xid (req), "SETATTR", fh); - nfs3_validate_gluster_fh (fh, stat, nfs3err); - nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret); - nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err); - nfs3_volume_started_check (nfs3, vol, ret, out); - nfs3_check_rw_volaccess (nfs3, fh->exportid, stat, nfs3err); - nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err); - - cs->setattr_valid = nfs3_sattr3_to_setattr_valid (sattr, &cs->attr_in, - NULL); - if (guard->check) { - gf_msg_trace (GF_NFS3, 0, "Guard check required"); - cs->timestamp = guard->sattrguard3_u.obj_ctime; - cs->sattrguardcheck = 1; - } else { - gf_msg_trace (GF_NFS3, 0, "Guard check not required"); - cs->sattrguardcheck = 0; - } - - if (!cs->setattr_valid) { - ret = -EINVAL; /* Force a reply */ - stat = NFS3_OK; - gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_SETATTR_INVALID, - "cs->setattr_valid is invalid"); - goto nfs3err; - } +nfs3_setattr(rpcsvc_request_t *req, struct nfs3_fh *fh, sattr3 *sattr, + sattrguard3 *guard) +{ + xlator_t *vol = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + struct nfs3_state *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + + GF_VALIDATE_OR_GOTO(GF_NFS3, req, out); + GF_VALIDATE_OR_GOTO(GF_NFS3, fh, out); + GF_VALIDATE_OR_GOTO(GF_NFS3, sattr, out); + GF_VALIDATE_OR_GOTO(GF_NFS3, guard, out); + + nfs3_log_common_call(rpcsvc_request_xid(req), "SETATTR", fh); + nfs3_validate_gluster_fh(fh, stat, nfs3err); + nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret); + nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err); + nfs3_volume_started_check(nfs3, vol, ret, out); + nfs3_check_rw_volaccess(nfs3, fh->exportid, stat, nfs3err); + nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err); + + cs->setattr_valid = nfs3_sattr3_to_setattr_valid(sattr, &cs->attr_in, NULL); + if (guard->check) { + gf_msg_trace(GF_NFS3, 0, "Guard check required"); + cs->timestamp = guard->sattrguard3_u.obj_ctime; + cs->sattrguardcheck = 1; + } else { + gf_msg_trace(GF_NFS3, 0, "Guard check not required"); + cs->sattrguardcheck = 0; + } + + if (!cs->setattr_valid) { + ret = -EINVAL; /* Force a reply */ + stat = NFS3_OK; + gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_SETATTR_INVALID, + "cs->setattr_valid is invalid"); + goto nfs3err; + } - ret = nfs3_fh_resolve_and_resume (cs, fh, NULL, nfs3_setattr_resume); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + ret = nfs3_fh_resolve_and_resume(cs, fh, NULL, nfs3_setattr_resume); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (req), - NFS3_SETATTR, stat, -ret, - cs ? cs->resolvedloc.path : NULL); - nfs3_setattr_reply (req, stat, NULL, NULL); - nfs3_call_state_wipe (cs); - /* Ret must be 0 after this so that the caller does not - * also send an RPC reply. - */ - ret = 0; - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_SETATTR, stat, -ret, + cs ? cs->resolvedloc.path : NULL); + nfs3_setattr_reply(req, stat, NULL, NULL); + nfs3_call_state_wipe(cs); + /* Ret must be 0 after this so that the caller does not + * also send an RPC reply. + */ + ret = 0; + } out: - return ret; + return ret; } - - int -nfs3svc_setattr (rpcsvc_request_t *req) -{ - struct nfs3_fh fh = {{0}, }; - setattr3args args; - int ret = RPCSVC_ACTOR_ERROR; - - GF_VALIDATE_OR_GOTO (GF_NFS3, req, rpcerr); - - nfs3_prep_setattr3args (&args, &fh); - if (xdr_to_setattr3args (req->msg[0], &args) <= 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, - NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } - - ret = nfs3_setattr (req, &fh, &args.new_attributes, &args.guard); - if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_SETATTR_FAIL, - "SETATTR procedure failed"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = RPCSVC_ACTOR_ERROR; - } +nfs3svc_setattr(rpcsvc_request_t *req) +{ + struct nfs3_fh fh = { + {0}, + }; + setattr3args args; + int ret = RPCSVC_ACTOR_ERROR; + + GF_VALIDATE_OR_GOTO(GF_NFS3, req, rpcerr); + + nfs3_prep_setattr3args(&args, &fh); + if (xdr_to_setattr3args(req->msg[0], &args) <= 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + ret = nfs3_setattr(req, &fh, &args.new_attributes, &args.guard); + if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_SETATTR_FAIL, + "SETATTR procedure failed"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = RPCSVC_ACTOR_ERROR; + } rpcerr: - return ret; - + return ret; } - int -nfs3_lookup_reply (rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *newfh, - struct iatt *stbuf, struct iatt *postparent) +nfs3_lookup_reply(rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *newfh, + struct iatt *stbuf, struct iatt *postparent) { - lookup3res res = {0, }; - uint64_t deviceid = 0; + lookup3res res = { + 0, + }; + uint64_t deviceid = 0; - deviceid = nfs3_request_xlator_deviceid (req); - nfs3_fill_lookup3res (&res, stat, newfh, stbuf, postparent, deviceid); - return nfs3svc_submit_reply (req, &res, - (nfs3_serializer)xdr_serialize_lookup3res); + deviceid = nfs3_request_xlator_deviceid(req); + nfs3_fill_lookup3res(&res, stat, newfh, stbuf, postparent, deviceid); + return nfs3svc_submit_reply(req, &res, + (nfs3_serializer)xdr_serialize_lookup3res); } int -nfs3_lookup_resume (void *carg); - +nfs3_lookup_resume(void *carg); int -nfs3_fresh_lookup (nfs3_call_state_t *cs) -{ - int ret = -EFAULT; - char *oldresolventry = NULL; - - GF_VALIDATE_OR_GOTO (GF_NFS3, cs, err); - gf_msg_debug (GF_NFS3, 0, "inode needs fresh lookup"); - inode_unlink (cs->resolvedloc.inode, cs->resolvedloc.parent, - cs->resolventry); - nfs_loc_wipe (&cs->resolvedloc); - - /* Store pointer to currently allocated resolventry because it gets over - * written in fh_resolve_and_resume. - */ - oldresolventry = cs->resolventry; - cs->lookuptype = GF_NFS3_FRESH; - ret = nfs3_fh_resolve_and_resume (cs, &cs->resolvefh, cs->resolventry, - nfs3_lookup_resume); - /* Allocated in the previous call to fh_resolve_and_resume using the - * same call_state. - */ - GF_FREE (oldresolventry); +nfs3_fresh_lookup(nfs3_call_state_t *cs) +{ + int ret = -EFAULT; + char *oldresolventry = NULL; + + GF_VALIDATE_OR_GOTO(GF_NFS3, cs, err); + gf_msg_debug(GF_NFS3, 0, "inode needs fresh lookup"); + inode_unlink(cs->resolvedloc.inode, cs->resolvedloc.parent, + cs->resolventry); + nfs_loc_wipe(&cs->resolvedloc); + + /* Store pointer to currently allocated resolventry because it gets over + * written in fh_resolve_and_resume. + */ + oldresolventry = cs->resolventry; + cs->lookuptype = GF_NFS3_FRESH; + ret = nfs3_fh_resolve_and_resume(cs, &cs->resolvefh, cs->resolventry, + nfs3_lookup_resume); + /* Allocated in the previous call to fh_resolve_and_resume using the + * same call_state. + */ + GF_FREE(oldresolventry); err: - return ret; + return ret; } int -nfs3svc_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, dict_t *xattr, struct iatt *postparent) -{ - struct nfs3_fh newfh = {{0}, }; - nfsstat3 status = NFS3_OK; - nfs3_call_state_t *cs = NULL; - inode_t *oldinode = NULL; - - cs = frame->local; - if (op_ret == -1) { - status = nfs3_cbk_errno_status (op_ret, op_errno); - goto xmit_res; - } - - nfs3_fh_build_child_fh (&cs->parent, buf, &newfh); - oldinode = inode_link (inode, cs->resolvedloc.parent, - cs->resolvedloc.name, buf); +nfs3svc_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, dict_t *xattr, struct iatt *postparent) +{ + struct nfs3_fh newfh = { + {0}, + }; + nfsstat3 status = NFS3_OK; + nfs3_call_state_t *cs = NULL; + inode_t *oldinode = NULL; + + cs = frame->local; + if (op_ret == -1) { + status = nfs3_cbk_errno_status(op_ret, op_errno); + goto xmit_res; + } + + nfs3_fh_build_child_fh(&cs->parent, buf, &newfh); + oldinode = inode_link(inode, cs->resolvedloc.parent, cs->resolvedloc.name, + buf); xmit_res: - /* Only send fresh lookup if it was a revalidate that failed. */ - if ((op_ret == -1) && (nfs3_is_revalidate_lookup (cs))) { - op_ret = nfs3_fresh_lookup (cs); - goto out; - } - - nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), NFS3_LOOKUP, - status, op_errno, &newfh, - cs->resolvedloc.path); - nfs3_lookup_reply (cs->req, status, &newfh, buf, postparent); - nfs3_call_state_wipe (cs); + /* Only send fresh lookup if it was a revalidate that failed. */ + if ((op_ret == -1) && (nfs3_is_revalidate_lookup(cs))) { + op_ret = nfs3_fresh_lookup(cs); + goto out; + } + + nfs3_log_newfh_res(rpcsvc_request_xid(cs->req), NFS3_LOOKUP, status, + op_errno, &newfh, cs->resolvedloc.path); + nfs3_lookup_reply(cs->req, status, &newfh, buf, postparent); + nfs3_call_state_wipe(cs); out: - if (oldinode) { - inode_lookup (oldinode); - inode_unref (oldinode); - } - return 0; + if (oldinode) { + inode_lookup(oldinode); + inode_unref(oldinode); + } + return 0; } - int -nfs3svc_lookup_parentdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, dict_t *xattr, - struct iatt *postparent) -{ - struct nfs3_fh newfh = {{0}, }; - nfsstat3 status = NFS3_OK; - nfs3_call_state_t *cs = NULL; - uuid_t volumeid = {0, }; - uuid_t mountid = {1, }; - struct nfs3_state *nfs3 = NULL; - - cs = frame->local; - if (op_ret == -1) { - status = nfs3_cbk_errno_status (op_ret, op_errno); - goto xmit_res; - } - - nfs3 = cs->nfs3state; - /* If the buf inode shows that this is a root dir's buf, then the file - * handle needs to be specially crafted, in all other cases, we'll just - * create the handle normally using the buffer of the parent dir. - */ - if (buf->ia_ino != 1) { - nfs3_fh_build_parent_fh (&cs->fh, buf, &newfh); - goto xmit_res; - } - - if (gf_nfs_dvm_off (nfs_state (nfs3->nfsx))) - newfh = nfs3_fh_build_indexed_root_fh (nfs3->exportslist, - cs->vol); - else { - __nfs3_get_volume_id (nfs3, cs->vol, volumeid); - newfh = nfs3_fh_build_uuid_root_fh (volumeid, mountid); - } +nfs3svc_lookup_parentdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, dict_t *xattr, + struct iatt *postparent) +{ + struct nfs3_fh newfh = { + {0}, + }; + nfsstat3 status = NFS3_OK; + nfs3_call_state_t *cs = NULL; + uuid_t volumeid = { + 0, + }; + uuid_t mountid = { + 1, + }; + struct nfs3_state *nfs3 = NULL; + + cs = frame->local; + if (op_ret == -1) { + status = nfs3_cbk_errno_status(op_ret, op_errno); + goto xmit_res; + } + + nfs3 = cs->nfs3state; + /* If the buf inode shows that this is a root dir's buf, then the file + * handle needs to be specially crafted, in all other cases, we'll just + * create the handle normally using the buffer of the parent dir. + */ + if (buf->ia_ino != 1) { + nfs3_fh_build_parent_fh(&cs->fh, buf, &newfh); + goto xmit_res; + } + + if (gf_nfs_dvm_off(nfs_state(nfs3->nfsx))) + newfh = nfs3_fh_build_indexed_root_fh(nfs3->exportslist, cs->vol); + else { + __nfs3_get_volume_id(nfs3, cs->vol, volumeid); + newfh = nfs3_fh_build_uuid_root_fh(volumeid, mountid); + } xmit_res: - nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), NFS3_LOOKUP, - status, op_errno, &newfh, - cs->resolvedloc.path); - nfs3_lookup_reply (cs->req, status, &newfh, buf, postparent); - nfs3_call_state_wipe (cs); + nfs3_log_newfh_res(rpcsvc_request_xid(cs->req), NFS3_LOOKUP, status, + op_errno, &newfh, cs->resolvedloc.path); + nfs3_lookup_reply(cs->req, status, &newfh, buf, postparent); + nfs3_call_state_wipe(cs); - return 0; + return 0; } - - int -nfs3_lookup_parentdir_resume (void *carg) -{ - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - nfs3_call_state_t *cs = NULL; - inode_t *parent = NULL; - - if (!carg) { - gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Invalid argument, carg value NULL"); - return EINVAL; - } +nfs3_lookup_parentdir_resume(void *carg) +{ + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + nfs3_call_state_t *cs = NULL; + inode_t *parent = NULL; + + if (!carg) { + gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Invalid argument, carg value NULL"); + return EINVAL; + } + + cs = (nfs3_call_state_t *)carg; + nfs3_check_fh_auth_status(cs, stat, _gf_false, nfs3err); + nfs3_check_fh_resolve_status(cs, stat, nfs3err); + + /* At this point now, the loc in cs is for the directory file handle + * sent by the client. This loc needs to be transformed into a loc that + * represents the parent dir of cs->resolvedloc.inode. + * + * EXCEPT in the case where the .. is a parent of the root directory. + * In this case we'll be returning the file handle and attributes of the + * root itself. + */ + nfs_request_user_init(&nfu, cs->req); + + /* Save the file handle from the LOOKUP request. We'll use this to + * build the file handle of the parent directory in case the parent is + * not root dir. + */ + cs->fh = cs->resolvefh; + + /* If fh is that of the root, the resolvedloc will already contain + * the loc for root. After that, we'll send lookup for the root dir + * itself since we cannot send the lookup on the parent of root. + * + * For all other cases, we'll send the lookup on the parent of the + * given directory file handle. + */ + if (!nfs3_fh_is_root_fh(&cs->fh)) { + parent = inode_ref(cs->resolvedloc.parent); + nfs_loc_wipe(&cs->resolvedloc); + ret = nfs_inode_loc_fill(parent, &cs->resolvedloc, NFS_RESOLVE_CREATE); - cs = (nfs3_call_state_t *)carg; - nfs3_check_fh_auth_status (cs, stat, _gf_false, nfs3err); - nfs3_check_fh_resolve_status (cs, stat, nfs3err); - - /* At this point now, the loc in cs is for the directory file handle - * sent by the client. This loc needs to be transformed into a loc that - * represents the parent dir of cs->resolvedloc.inode. - * - * EXCEPT in the case where the .. is a parent of the root directory. - * In this case we'll be returning the file handle and attributes of the - * root itself. - */ - nfs_request_user_init (&nfu, cs->req); - - /* Save the file handle from the LOOKUP request. We'll use this to - * build the file handle of the parent directory in case the parent is - * not root dir. - */ - cs->fh = cs->resolvefh; - - /* If fh is that of the root, the resolvedloc will already contain - * the loc for root. After that, we'll send lookup for the root dir - * itself since we cannot send the lookup on the parent of root. - * - * For all other cases, we'll send the lookup on the parent of the - * given directory file handle. - */ - if (!nfs3_fh_is_root_fh (&cs->fh)) { - parent = inode_ref (cs->resolvedloc.parent); - nfs_loc_wipe (&cs->resolvedloc); - ret = nfs_inode_loc_fill (parent, &cs->resolvedloc, - NFS_RESOLVE_CREATE); - - if (ret < 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, - NFS_MSG_INODE_LOC_FILL_ERROR, - "nfs_inode_loc_fill" - " error"); - goto errtostat; - } + if (ret < 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_INODE_LOC_FILL_ERROR, + "nfs_inode_loc_fill" + " error"); + goto errtostat; } + } - ret = nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - nfs3svc_lookup_parentdir_cbk, cs); + ret = nfs_lookup(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + nfs3svc_lookup_parentdir_cbk, cs); errtostat: - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_LOOKUP, stat, -ret, - cs->resolvedloc.path); - nfs3_lookup_reply (cs->req, stat, NULL, NULL, NULL); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_LOOKUP, stat, + -ret, cs->resolvedloc.path); + nfs3_lookup_reply(cs->req, stat, NULL, NULL, NULL); + nfs3_call_state_wipe(cs); + } - if (parent) - inode_unref (parent); + if (parent) + inode_unref(parent); - return ret; + return ret; } - int -nfs3_lookup_resume (void *carg) -{ - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - nfs3_call_state_t *cs = NULL; - struct nfs3_fh newfh = {{0},}; - - if (!carg) { - gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Invalid argument, carg value NULL"); - return EINVAL; - } - - cs = (nfs3_call_state_t *)carg; - nfs3_check_fh_auth_status (cs, stat, _gf_false, nfs3err); - nfs3_check_fh_resolve_status (cs, stat, nfs3err); - cs->parent = cs->resolvefh; - - if (cs->hardresolved) { - stat = NFS3_OK; - nfs3_fh_build_child_fh (&cs->parent, &cs->stbuf, &newfh); - goto nfs3err; - } +nfs3_lookup_resume(void *carg) +{ + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + nfs3_call_state_t *cs = NULL; + struct nfs3_fh newfh = { + {0}, + }; + + if (!carg) { + gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Invalid argument, carg value NULL"); + return EINVAL; + } + + cs = (nfs3_call_state_t *)carg; + nfs3_check_fh_auth_status(cs, stat, _gf_false, nfs3err); + nfs3_check_fh_resolve_status(cs, stat, nfs3err); + cs->parent = cs->resolvefh; + + if (cs->hardresolved) { + stat = NFS3_OK; + nfs3_fh_build_child_fh(&cs->parent, &cs->stbuf, &newfh); + goto nfs3err; + } - nfs_request_user_init (&nfu, cs->req); - ret = nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - nfs3svc_lookup_cbk, cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + nfs_request_user_init(&nfu, cs->req); + ret = nfs_lookup(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + nfs3svc_lookup_cbk, cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_LOOKUP, stat, -ret, - cs->resolvedloc.path); - nfs3_lookup_reply (cs->req, stat, &newfh, &cs->stbuf, - &cs->postparent); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_LOOKUP, stat, + -ret, cs->resolvedloc.path); + nfs3_lookup_reply(cs->req, stat, &newfh, &cs->stbuf, &cs->postparent); + nfs3_call_state_wipe(cs); + } - return ret; + return ret; } - int -nfs3_lookup (rpcsvc_request_t *req, struct nfs3_fh *fh, int fhlen, char *name) -{ - xlator_t *vol = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - struct nfs3_state *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - - GF_VALIDATE_OR_GOTO (GF_NFS3, req, out); - GF_VALIDATE_OR_GOTO (GF_NFS3, fh, out); - GF_VALIDATE_OR_GOTO (GF_NFS3, name, out); - - nfs3_log_fh_entry_call (rpcsvc_request_xid (req), "LOOKUP", fh, - name); - nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret); - if (nfs3_solaris_zerolen_fh (fh, fhlen)) { - ret = nfs3_funge_webnfs_zerolen_fh (req, nfs3, fh, name); - if (ret < 0) - goto nfs3err; - - /* this fh means we're doing a mount, name is no more useful */ - name = NULL; - } else - nfs3_validate_gluster_fh (fh, stat, nfs3err); - nfs3_validate_strlen_or_goto (name, NFS_NAME_MAX, nfs3err, stat, ret); - nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err); - nfs3_volume_started_check (nfs3, vol, ret, out); - nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err); +nfs3_lookup(rpcsvc_request_t *req, struct nfs3_fh *fh, int fhlen, char *name) +{ + xlator_t *vol = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + struct nfs3_state *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + + GF_VALIDATE_OR_GOTO(GF_NFS3, req, out); + GF_VALIDATE_OR_GOTO(GF_NFS3, fh, out); + GF_VALIDATE_OR_GOTO(GF_NFS3, name, out); + + nfs3_log_fh_entry_call(rpcsvc_request_xid(req), "LOOKUP", fh, name); + nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret); + if (nfs3_solaris_zerolen_fh(fh, fhlen)) { + ret = nfs3_funge_webnfs_zerolen_fh(req, nfs3, fh, name); + if (ret < 0) + goto nfs3err; - cs->lookuptype = GF_NFS3_REVALIDATE; - ret = nfs3_fh_resolve_and_resume (cs, fh, name, - nfs3_lookup_resume); + /* this fh means we're doing a mount, name is no more useful */ + name = NULL; + } else + nfs3_validate_gluster_fh(fh, stat, nfs3err); + nfs3_validate_strlen_or_goto(name, NFS_NAME_MAX, nfs3err, stat, ret); + nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err); + nfs3_volume_started_check(nfs3, vol, ret, out); + nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err); - if (ret < 0) { - gf_msg (GF_NFS, GF_LOG_ERROR, -ret, - NFS_MSG_HARD_RESOLVE_FAIL, - "failed to start hard resolve"); - } + cs->lookuptype = GF_NFS3_REVALIDATE; + ret = nfs3_fh_resolve_and_resume(cs, fh, name, nfs3_lookup_resume); + + if (ret < 0) { + gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_HARD_RESOLVE_FAIL, + "failed to start hard resolve"); + } nfs3err: - if (ret < 0) { - stat = nfs3_errno_to_nfsstat3 (-ret); - nfs3_log_common_res (rpcsvc_request_xid (req), - NFS3_LOOKUP, stat, -ret, - cs ? cs->resolvedloc.path : NULL); - nfs3_lookup_reply (req, stat, NULL, NULL, NULL); - if (cs) - nfs3_call_state_wipe (cs); - /* Ret must be 0 after this so that the caller does not - * also send an RPC reply. - */ - ret = 0; - } + if (ret < 0) { + stat = nfs3_errno_to_nfsstat3(-ret); + nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_LOOKUP, stat, -ret, + cs ? cs->resolvedloc.path : NULL); + nfs3_lookup_reply(req, stat, NULL, NULL, NULL); + if (cs) + nfs3_call_state_wipe(cs); + /* Ret must be 0 after this so that the caller does not + * also send an RPC reply. + */ + ret = 0; + } out: - return ret; + return ret; } - int -nfs3svc_lookup (rpcsvc_request_t *req) -{ - char name[NFS_PATH_MAX]; - struct nfs3_fh fh = {{0}, }; - lookup3args args; - int ret = RPCSVC_ACTOR_ERROR; - - GF_VALIDATE_OR_GOTO (GF_NFS, req, rpcerr); - - nfs3_prep_lookup3args (&args, &fh, name); - if (xdr_to_lookup3args (req->msg[0], &args) <= 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } - - ret = nfs3_lookup (req, &fh, args.what.dir.data.data_len, name); - if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, - NFS_MSG_LOOKUP_PROC_FAIL, - "LOOKUP procedure failed"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = RPCSVC_ACTOR_ERROR; - } +nfs3svc_lookup(rpcsvc_request_t *req) +{ + char name[NFS_PATH_MAX]; + struct nfs3_fh fh = { + {0}, + }; + lookup3args args; + int ret = RPCSVC_ACTOR_ERROR; + + GF_VALIDATE_OR_GOTO(GF_NFS, req, rpcerr); + + nfs3_prep_lookup3args(&args, &fh, name); + if (xdr_to_lookup3args(req->msg[0], &args) <= 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + ret = nfs3_lookup(req, &fh, args.what.dir.data.data_len, name); + if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_LOOKUP_PROC_FAIL, + "LOOKUP procedure failed"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = RPCSVC_ACTOR_ERROR; + } rpcerr: - return ret; + return ret; } - int -nfs3_access_reply (rpcsvc_request_t *req, nfsstat3 status, int32_t accbits, - int32_t reqaccbits) +nfs3_access_reply(rpcsvc_request_t *req, nfsstat3 status, int32_t accbits, + int32_t reqaccbits) { - access3res res; + access3res res; - nfs3_fill_access3res (&res, status, accbits, reqaccbits); - nfs3svc_submit_reply (req, &res, - (nfs3_serializer)xdr_serialize_access3res); - return 0; + nfs3_fill_access3res(&res, status, accbits, reqaccbits); + nfs3svc_submit_reply(req, &res, (nfs3_serializer)xdr_serialize_access3res); + return 0; } - int32_t -nfs3svc_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +nfs3svc_access_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - nfsstat3 status = NFS3_OK; - nfs3_call_state_t *cs = NULL; + nfsstat3 status = NFS3_OK; + nfs3_call_state_t *cs = NULL; - cs = frame->local; + cs = frame->local; - if (op_ret == -1) { - status = nfs3_cbk_errno_status (op_ret, op_errno); - } + if (op_ret == -1) { + status = nfs3_cbk_errno_status(op_ret, op_errno); + } - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_ACCESS, status, op_errno, - cs->resolvedloc.path); - nfs3_access_reply (cs->req, status, op_errno, cs->accessbits); - nfs3_call_state_wipe (cs); + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_ACCESS, status, + op_errno, cs->resolvedloc.path); + nfs3_access_reply(cs->req, status, op_errno, cs->accessbits); + nfs3_call_state_wipe(cs); - return 0; + return 0; } int -nfs3_access_resume (void *carg) -{ - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - nfs3_call_state_t *cs = NULL; - - if (!carg) { - gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Invalid argument, carg value NULL"); - return EINVAL; - } - - cs = (nfs3_call_state_t *)carg; - - /* Additional checks on the NFS file handle - * go here. The path for an NFS ACCESS call - * goes like this: - * nfs3_access -> nfs3_fh_resolve_and_resume -> nfs3_resolve_resume -> - * nfs3_access_resume -> <macro/function performs check on FH> -> - * <continue or return from function based on check.> ('goto nfs3err' - * terminates this function and writes the appropriate response to the - * client). It is important that you do NOT stick any sort of check - * on the file handle outside of the nfs3_##OP_resume functions. - */ - nfs3_check_fh_auth_status (cs, stat, _gf_false, nfs3err); - nfs3_check_fh_resolve_status (cs, stat, nfs3err); - cs->fh = cs->resolvefh; - nfs_request_user_init (&nfu, cs->req); - ret = nfs_access (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - cs->accessbits, nfs3svc_access_cbk, cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); +nfs3_access_resume(void *carg) +{ + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + nfs3_call_state_t *cs = NULL; + + if (!carg) { + gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Invalid argument, carg value NULL"); + return EINVAL; + } + + cs = (nfs3_call_state_t *)carg; + + /* Additional checks on the NFS file handle + * go here. The path for an NFS ACCESS call + * goes like this: + * nfs3_access -> nfs3_fh_resolve_and_resume -> nfs3_resolve_resume -> + * nfs3_access_resume -> <macro/function performs check on FH> -> + * <continue or return from function based on check.> ('goto nfs3err' + * terminates this function and writes the appropriate response to the + * client). It is important that you do NOT stick any sort of check + * on the file handle outside of the nfs3_##OP_resume functions. + */ + nfs3_check_fh_auth_status(cs, stat, _gf_false, nfs3err); + nfs3_check_fh_resolve_status(cs, stat, nfs3err); + cs->fh = cs->resolvefh; + nfs_request_user_init(&nfu, cs->req); + ret = nfs_access(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, cs->accessbits, + nfs3svc_access_cbk, cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_ACCESS, stat, -ret, - cs->resolvedloc.path); - nfs3_access_reply (cs->req, stat, 0, 0); - nfs3_call_state_wipe (cs); - ret = 0; - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_ACCESS, stat, + -ret, cs->resolvedloc.path); + nfs3_access_reply(cs->req, stat, 0, 0); + nfs3_call_state_wipe(cs); + ret = 0; + } - return ret; + return ret; } - int -nfs3_access (rpcsvc_request_t *req, struct nfs3_fh *fh, uint32_t accbits) -{ - xlator_t *vol = NULL; - struct nfs3_state *nfs3 = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs3_call_state_t *cs = NULL; - - GF_VALIDATE_OR_GOTO (GF_NFS, req, out); - GF_VALIDATE_OR_GOTO (GF_NFS, fh, out); - nfs3_log_common_call (rpcsvc_request_xid (req), "ACCESS", fh); - nfs3_validate_gluster_fh (fh, stat, nfs3err); - nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret); - nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err); - nfs3_volume_started_check (nfs3, vol, ret, out); - nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err); - cs->accessbits = accbits; - - ret = nfs3_fh_resolve_and_resume (cs, fh, NULL, nfs3_access_resume); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); +nfs3_access(rpcsvc_request_t *req, struct nfs3_fh *fh, uint32_t accbits) +{ + xlator_t *vol = NULL; + struct nfs3_state *nfs3 = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs3_call_state_t *cs = NULL; + + GF_VALIDATE_OR_GOTO(GF_NFS, req, out); + GF_VALIDATE_OR_GOTO(GF_NFS, fh, out); + nfs3_log_common_call(rpcsvc_request_xid(req), "ACCESS", fh); + nfs3_validate_gluster_fh(fh, stat, nfs3err); + nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret); + nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err); + nfs3_volume_started_check(nfs3, vol, ret, out); + nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err); + cs->accessbits = accbits; + + ret = nfs3_fh_resolve_and_resume(cs, fh, NULL, nfs3_access_resume); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (req), - NFS3_ACCESS, stat, -ret, - cs ? cs->resolvedloc.path : NULL); - nfs3_access_reply (req, stat, 0, 0); - nfs3_call_state_wipe (cs); - ret = 0; - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_ACCESS, stat, -ret, + cs ? cs->resolvedloc.path : NULL); + nfs3_access_reply(req, stat, 0, 0); + nfs3_call_state_wipe(cs); + ret = 0; + } out: - return ret; + return ret; } - int -nfs3svc_access (rpcsvc_request_t *req) +nfs3svc_access(rpcsvc_request_t *req) { - struct nfs3_fh fh = {{0}, }; - access3args args; - int ret = RPCSVC_ACTOR_ERROR; + struct nfs3_fh fh = { + {0}, + }; + access3args args; + int ret = RPCSVC_ACTOR_ERROR; - if (!req) - return ret; - - nfs3_prep_access3args (&args, &fh); - if (xdr_to_access3args (req->msg[0], &args) <= 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } + if (!req) + return ret; - ret = nfs3_access (req, &fh, args.access); - if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, - NFS_MSG_ACCESS_PROC_FAIL, - "ACCESS procedure failed"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = RPCSVC_ACTOR_ERROR; - } + nfs3_prep_access3args(&args, &fh); + if (xdr_to_access3args(req->msg[0], &args) <= 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + ret = nfs3_access(req, &fh, args.access); + if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_ACCESS_PROC_FAIL, + "ACCESS procedure failed"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = RPCSVC_ACTOR_ERROR; + } rpcerr: - return ret; + return ret; } - int -nfs3_readlink_reply (rpcsvc_request_t *req, nfsstat3 stat, char *path, - struct iatt *buf) +nfs3_readlink_reply(rpcsvc_request_t *req, nfsstat3 stat, char *path, + struct iatt *buf) { - readlink3res res = {0, }; - uint64_t deviceid = 0; + readlink3res res = { + 0, + }; + uint64_t deviceid = 0; - deviceid = nfs3_request_xlator_deviceid (req); - nfs3_fill_readlink3res (&res, stat, path, buf, deviceid); - nfs3svc_submit_reply (req, (void *)&res, - (nfs3_serializer)xdr_serialize_readlink3res); + deviceid = nfs3_request_xlator_deviceid(req); + nfs3_fill_readlink3res(&res, stat, path, buf, deviceid); + nfs3svc_submit_reply(req, (void *)&res, + (nfs3_serializer)xdr_serialize_readlink3res); - return 0; + return 0; } - int32_t -nfs3svc_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, const char *path, - struct iatt *buf, dict_t *xdata) +nfs3svc_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, const char *path, + struct iatt *buf, dict_t *xdata) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + nfs3_call_state_t *cs = NULL; - cs = frame->local; - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - goto nfs3err; - } + cs = frame->local; + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + goto nfs3err; + } - stat = NFS3_OK; + stat = NFS3_OK; nfs3err: - nfs3_log_readlink_res (rpcsvc_request_xid (cs->req), - stat, op_errno, (char *)path, - cs->resolvedloc.path); - nfs3_readlink_reply (cs->req, stat, (char *)path, buf); - nfs3_call_state_wipe (cs); + nfs3_log_readlink_res(rpcsvc_request_xid(cs->req), stat, op_errno, + (char *)path, cs->resolvedloc.path); + nfs3_readlink_reply(cs->req, stat, (char *)path, buf); + nfs3_call_state_wipe(cs); - return 0; + return 0; } - int -nfs3_readlink_resume (void *carg) -{ - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs3_call_state_t *cs = NULL; - nfs_user_t nfu = {0, }; - - if (!carg) - return ret; - - cs = (nfs3_call_state_t *)carg; - nfs3_check_fh_auth_status (cs, stat, _gf_false, nfs3err); - nfs3_check_fh_resolve_status (cs, stat, nfs3err); - nfs_request_user_init (&nfu, cs->req); - ret = nfs_readlink (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - nfs3svc_readlink_cbk, cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); - -nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_READLINK, stat, -ret, - cs->resolvedloc.path); - nfs3_readlink_reply (cs->req, stat, NULL, NULL); - nfs3_call_state_wipe (cs); - } +nfs3_readlink_resume(void *carg) +{ + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs3_call_state_t *cs = NULL; + nfs_user_t nfu = { + 0, + }; + if (!carg) return ret; -} + cs = (nfs3_call_state_t *)carg; + nfs3_check_fh_auth_status(cs, stat, _gf_false, nfs3err); + nfs3_check_fh_resolve_status(cs, stat, nfs3err); + nfs_request_user_init(&nfu, cs->req); + ret = nfs_readlink(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + nfs3svc_readlink_cbk, cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); -int -nfs3_readlink (rpcsvc_request_t *req, struct nfs3_fh *fh) -{ - xlator_t *vol = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - struct nfs3_state *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - - if ((!req) || (!fh)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Bad arguments"); - return -1; - } +nfs3err: + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_READLINK, stat, + -ret, cs->resolvedloc.path); + nfs3_readlink_reply(cs->req, stat, NULL, NULL); + nfs3_call_state_wipe(cs); + } - nfs3_log_common_call (rpcsvc_request_xid (req), "READLINK", fh); - nfs3_validate_gluster_fh (fh, stat, nfs3err); - nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret); - nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err); - nfs3_volume_started_check (nfs3, vol, ret, out); - nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err); + return ret; +} - ret = nfs3_fh_resolve_and_resume (cs, fh, NULL, nfs3_readlink_resume); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); +int +nfs3_readlink(rpcsvc_request_t *req, struct nfs3_fh *fh) +{ + xlator_t *vol = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + struct nfs3_state *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + + if ((!req) || (!fh)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Bad arguments"); + return -1; + } + + nfs3_log_common_call(rpcsvc_request_xid(req), "READLINK", fh); + nfs3_validate_gluster_fh(fh, stat, nfs3err); + nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret); + nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err); + nfs3_volume_started_check(nfs3, vol, ret, out); + nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err); + + ret = nfs3_fh_resolve_and_resume(cs, fh, NULL, nfs3_readlink_resume); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (req), - NFS3_READLINK, stat, -ret, - cs ? cs->resolvedloc.path : NULL); - nfs3_readlink_reply (req, stat, NULL, NULL); - nfs3_call_state_wipe (cs); - /* Ret must be 0 after this so that the caller does not - * also send an RPC reply. - */ - ret = 0; - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_READLINK, stat, -ret, + cs ? cs->resolvedloc.path : NULL); + nfs3_readlink_reply(req, stat, NULL, NULL); + nfs3_call_state_wipe(cs); + /* Ret must be 0 after this so that the caller does not + * also send an RPC reply. + */ + ret = 0; + } out: - return ret; + return ret; } - int -nfs3svc_readlink (rpcsvc_request_t *req) +nfs3svc_readlink(rpcsvc_request_t *req) { - struct nfs3_fh fh = {{0}, }; - readlink3args args; - int ret = RPCSVC_ACTOR_ERROR; + struct nfs3_fh fh = { + {0}, + }; + readlink3args args; + int ret = RPCSVC_ACTOR_ERROR; - if (!req) - return ret; - - nfs3_prep_readlink3args (&args, &fh); - if (xdr_to_readlink3args (req->msg[0], &args) <= 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } + if (!req) + return ret; - ret = nfs3_readlink (req, &fh); - if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, - NFS_MSG_READLINK_PROC_FAIL, - "READLINK procedure failed"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = RPCSVC_ACTOR_ERROR; - } + nfs3_prep_readlink3args(&args, &fh); + if (xdr_to_readlink3args(req->msg[0], &args) <= 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + ret = nfs3_readlink(req, &fh); + if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_READLINK_PROC_FAIL, + "READLINK procedure failed"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = RPCSVC_ACTOR_ERROR; + } rpcerr: - return ret; + return ret; } - int -nfs3_read_reply (rpcsvc_request_t *req, nfsstat3 stat, count3 count, - struct iovec *vec, int vcount, struct iobref *iobref, - struct iatt *poststat, int is_eof) -{ - read3res res = {0, }; - uint64_t deviceid = 0; - - deviceid = nfs3_request_xlator_deviceid (req); - nfs3_fill_read3res (&res, stat, count, poststat, is_eof, deviceid); - if (stat == NFS3_OK) { - xdr_vector_round_up (vec, vcount, count); - /* iob can be zero if the file size was zero. If so, op_ret - * would be 0 and count = 0. - */ - - if (count != 0) { - nfs3svc_submit_vector_reply (req, (void *)&res, - (nfs3_serializer) - xdr_serialize_read3res_nocopy, - vec, vcount, iobref); - } else - - nfs3svc_submit_reply (req, (void *)&res, - (nfs3_serializer) - xdr_serialize_read3res_nocopy); +nfs3_read_reply(rpcsvc_request_t *req, nfsstat3 stat, count3 count, + struct iovec *vec, int vcount, struct iobref *iobref, + struct iatt *poststat, int is_eof) +{ + read3res res = { + 0, + }; + uint64_t deviceid = 0; + + deviceid = nfs3_request_xlator_deviceid(req); + nfs3_fill_read3res(&res, stat, count, poststat, is_eof, deviceid); + if (stat == NFS3_OK) { + xdr_vector_round_up(vec, vcount, count); + /* iob can be zero if the file size was zero. If so, op_ret + * would be 0 and count = 0. + */ + + if (count != 0) { + nfs3svc_submit_vector_reply( + req, (void *)&res, + (nfs3_serializer)xdr_serialize_read3res_nocopy, vec, vcount, + iobref); } else - nfs3svc_submit_reply (req, (void *)&res, - (nfs3_serializer) - xdr_serialize_read3res_nocopy); - return 0; -} + nfs3svc_submit_reply( + req, (void *)&res, + (nfs3_serializer)xdr_serialize_read3res_nocopy); + } else + nfs3svc_submit_reply(req, (void *)&res, + (nfs3_serializer)xdr_serialize_read3res_nocopy); + return 0; +} int32_t -nfs3svc_read_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iovec *vector, - int32_t count, struct iatt *stbuf, struct iobref *iobref, - dict_t *xdata) -{ - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int is_eof = 0; - nfs3_call_state_t *cs = NULL; - - cs = frame->local; - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - goto err; - } else - stat = NFS3_OK; +nfs3svc_read_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iovec *vector, + int32_t count, struct iatt *stbuf, struct iobref *iobref, + dict_t *xdata) +{ + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int is_eof = 0; + nfs3_call_state_t *cs = NULL; + + cs = frame->local; + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + goto err; + } else + stat = NFS3_OK; - if (op_errno == ENOENT) - is_eof = 1; + if (op_errno == ENOENT) + is_eof = 1; err: - nfs3_log_read_res (rpcsvc_request_xid (cs->req), - stat, op_errno, - op_ret, is_eof, vector, count, - cs->resolvedloc.path); - nfs3_read_reply (cs->req, stat, op_ret, vector, count, iobref, stbuf, - is_eof); - nfs3_call_state_wipe (cs); + nfs3_log_read_res(rpcsvc_request_xid(cs->req), stat, op_errno, op_ret, + is_eof, vector, count, cs->resolvedloc.path); + nfs3_read_reply(cs->req, stat, op_ret, vector, count, iobref, stbuf, + is_eof); + nfs3_call_state_wipe(cs); - return 0; + return 0; } - int -nfs3_read_fd_resume (void *carg) +nfs3_read_fd_resume(void *carg) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + nfs3_call_state_t *cs = NULL; - if (!carg) - return ret; + if (!carg) + return ret; - cs = (nfs3_call_state_t *)carg; - nfs3_check_fh_resolve_status (cs, stat, nfs3err); - nfs_request_user_init (&nfu, cs->req); - ret = nfs_read (cs->nfsx, cs->vol, &nfu, cs->fd, cs->datacount, - cs->dataoffset, nfs3svc_read_cbk, cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + cs = (nfs3_call_state_t *)carg; + nfs3_check_fh_resolve_status(cs, stat, nfs3err); + nfs_request_user_init(&nfu, cs->req); + ret = nfs_read(cs->nfsx, cs->vol, &nfu, cs->fd, cs->datacount, + cs->dataoffset, nfs3svc_read_cbk, cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_READ, stat, -ret, - cs->resolvedloc.path); - nfs3_read_reply (cs->req, stat, 0, NULL, 0, NULL, NULL, 0); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_READ, stat, -ret, + cs->resolvedloc.path); + nfs3_read_reply(cs->req, stat, 0, NULL, 0, NULL, NULL, 0); + nfs3_call_state_wipe(cs); + } - return ret; + return ret; } - int -nfs3_read_resume (void *carg) -{ - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs3_call_state_t *cs = NULL; - fd_t *fd = NULL; - - if (!carg) - return ret; - - cs = (nfs3_call_state_t *)carg; - nfs3_check_fh_auth_status (cs, stat, _gf_false, nfs3err); - nfs3_check_fh_resolve_status (cs, stat, nfs3err); - fd = fd_anonymous (cs->resolvedloc.inode); - if (!fd) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ANONYMOUS_FD_FAIL, - "Failed to create anonymous fd"); - goto nfs3err; - } +nfs3_read_resume(void *carg) +{ + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs3_call_state_t *cs = NULL; + fd_t *fd = NULL; - cs->fd = fd; - nfs3_read_fd_resume (cs); - ret = 0; + if (!carg) + return ret; + + cs = (nfs3_call_state_t *)carg; + nfs3_check_fh_auth_status(cs, stat, _gf_false, nfs3err); + nfs3_check_fh_resolve_status(cs, stat, nfs3err); + fd = fd_anonymous(cs->resolvedloc.inode); + if (!fd) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ANONYMOUS_FD_FAIL, + "Failed to create anonymous fd"); + goto nfs3err; + } + + cs->fd = fd; + nfs3_read_fd_resume(cs); + ret = 0; nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_READ, stat, -ret, - cs->resolvedloc.path); - nfs3_read_reply (cs->req, stat, 0, NULL,0, NULL, NULL, 0); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_READ, stat, -ret, + cs->resolvedloc.path); + nfs3_read_reply(cs->req, stat, 0, NULL, 0, NULL, NULL, 0); + nfs3_call_state_wipe(cs); + } - return ret; + return ret; } int -nfs3_read (rpcsvc_request_t *req, struct nfs3_fh *fh, offset3 offset, - count3 count) -{ - xlator_t *vol = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - struct nfs3_state *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - - if ((!req) || (!fh)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Bad arguments"); - return -1; - } - - nfs3_log_rw_call (rpcsvc_request_xid (req), "READ", fh, offset, - count, -1); - nfs3_validate_gluster_fh (fh, stat, nfs3err); - nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret); - nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err); - nfs3_volume_started_check (nfs3, vol, ret, out); - nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err); - - cs->datacount = count; - cs->dataoffset = offset; - ret = nfs3_fh_resolve_and_resume (cs, fh, NULL, nfs3_read_resume); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); +nfs3_read(rpcsvc_request_t *req, struct nfs3_fh *fh, offset3 offset, + count3 count) +{ + xlator_t *vol = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + struct nfs3_state *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + + if ((!req) || (!fh)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Bad arguments"); + return -1; + } + + nfs3_log_rw_call(rpcsvc_request_xid(req), "READ", fh, offset, count, -1); + nfs3_validate_gluster_fh(fh, stat, nfs3err); + nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret); + nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err); + nfs3_volume_started_check(nfs3, vol, ret, out); + nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err); + + cs->datacount = count; + cs->dataoffset = offset; + ret = nfs3_fh_resolve_and_resume(cs, fh, NULL, nfs3_read_resume); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (req), - NFS3_READ, stat, -ret, - cs ? cs->resolvedloc.path : NULL); - nfs3_read_reply (req, stat, 0, NULL,0, NULL, NULL, 0); - nfs3_call_state_wipe (cs); - ret = 0; - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_READ, stat, -ret, + cs ? cs->resolvedloc.path : NULL); + nfs3_read_reply(req, stat, 0, NULL, 0, NULL, NULL, 0); + nfs3_call_state_wipe(cs); + ret = 0; + } out: - return ret; + return ret; } - int -nfs3svc_read (rpcsvc_request_t *req) +nfs3svc_read(rpcsvc_request_t *req) { - struct nfs3_fh fh = {{0}, }; - read3args args; - int ret = RPCSVC_ACTOR_ERROR; + struct nfs3_fh fh = { + {0}, + }; + read3args args; + int ret = RPCSVC_ACTOR_ERROR; - if (!req) - return ret; - - nfs3_prep_read3args (&args, &fh); - if (xdr_to_read3args (req->msg[0], &args) <= 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } + if (!req) + return ret; - ret = nfs3_read (req, &fh, args.offset, args.count); - if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, - NFS_MSG_READ_FAIL, - "READ procedure failed"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = RPCSVC_ACTOR_ERROR; - } + nfs3_prep_read3args(&args, &fh); + if (xdr_to_read3args(req->msg[0], &args) <= 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + ret = nfs3_read(req, &fh, args.offset, args.count); + if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_READ_FAIL, + "READ procedure failed"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = RPCSVC_ACTOR_ERROR; + } rpcerr: - return ret; + return ret; } - int -nfs3_write_reply (rpcsvc_request_t *req, nfsstat3 stat, count3 count, - stable_how stable, uint64_t wverf, struct iatt *prestat, - struct iatt *poststat) +nfs3_write_reply(rpcsvc_request_t *req, nfsstat3 stat, count3 count, + stable_how stable, uint64_t wverf, struct iatt *prestat, + struct iatt *poststat) { - write3res res = {0, }; - uint64_t deviceid = 0; + write3res res = { + 0, + }; + uint64_t deviceid = 0; - deviceid = nfs3_request_xlator_deviceid (req); - nfs3_fill_write3res (&res, stat, count, stable, wverf, prestat, - poststat, deviceid); - nfs3svc_submit_reply (req, (void *)&res, - (nfs3_serializer)xdr_serialize_write3res); + deviceid = nfs3_request_xlator_deviceid(req); + nfs3_fill_write3res(&res, stat, count, stable, wverf, prestat, poststat, + deviceid); + nfs3svc_submit_reply(req, (void *)&res, + (nfs3_serializer)xdr_serialize_write3res); - return 0; + return 0; } int32_t -nfs3svc_write_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf, dict_t *xdata) +nfs3svc_write_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - struct nfs3_state *nfs3 = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - nfs3_call_state_t *cs = NULL; + struct nfs3_state *nfs3 = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + nfs3_call_state_t *cs = NULL; - cs = frame->local; - nfs3 = rpcsvc_request_program_private (cs->req); + cs = frame->local; + nfs3 = rpcsvc_request_program_private(cs->req); - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - } else - stat = NFS3_OK; + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + } else + stat = NFS3_OK; - nfs3_log_write_res (rpcsvc_request_xid (cs->req), - stat, op_errno, - cs->maxcount, cs->writetype, nfs3->serverstart, - cs->resolvedloc.path); - nfs3_write_reply (cs->req, stat, cs->maxcount, cs->writetype, - nfs3->serverstart, &cs->stbuf, postbuf); - nfs3_call_state_wipe (cs); - return 0; + nfs3_log_write_res(rpcsvc_request_xid(cs->req), stat, op_errno, + cs->maxcount, cs->writetype, nfs3->serverstart, + cs->resolvedloc.path); + nfs3_write_reply(cs->req, stat, cs->maxcount, cs->writetype, + nfs3->serverstart, &cs->stbuf, postbuf); + nfs3_call_state_wipe(cs); + return 0; } - - /* * Before going into the write reply logic, here is a matrix that shows the * requirements for a write reply as given by RFC1813. @@ -2270,3118 +2205,3028 @@ nfs3svc_write_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this, * */ int32_t -nfs3svc_write_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf, dict_t *xdata) -{ - nfsstat3 stat = NFS3ERR_SERVERFAULT; - nfs3_call_state_t *cs = NULL; - struct nfs3_state *nfs3 = NULL; - - cs = frame->local; - nfs3 = rpcsvc_request_program_private (cs->req); - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - goto err; - } +nfs3svc_write_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) +{ + nfsstat3 stat = NFS3ERR_SERVERFAULT; + nfs3_call_state_t *cs = NULL; + struct nfs3_state *nfs3 = NULL; - stat = NFS3_OK; - cs->maxcount = op_ret; + cs = frame->local; + nfs3 = rpcsvc_request_program_private(cs->req); + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + goto err; + } + + stat = NFS3_OK; + cs->maxcount = op_ret; err: - nfs3_log_write_res (rpcsvc_request_xid (cs->req), - stat, op_errno, cs->maxcount, cs->writetype, - nfs3->serverstart, cs->resolvedloc.path); - nfs3_write_reply (cs->req, stat, cs->maxcount, - cs->writetype, nfs3->serverstart, prebuf, - postbuf); - nfs3_call_state_wipe (cs); + nfs3_log_write_res(rpcsvc_request_xid(cs->req), stat, op_errno, + cs->maxcount, cs->writetype, nfs3->serverstart, + cs->resolvedloc.path); + nfs3_write_reply(cs->req, stat, cs->maxcount, cs->writetype, + nfs3->serverstart, prebuf, postbuf); + nfs3_call_state_wipe(cs); - return 0; + return 0; } - int -__nfs3_write_resume (nfs3_call_state_t *cs) -{ - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - - if (!cs) - return ret; - - nfs_request_user_init (&nfu, cs->req); - /* It is possible that the RPC record contains more bytes than - * than the size of write requested in this request. This means, - * that in the RPC message buffer, there could be more bytes - * beyind the @count bytes. Since @payload is referring to the write - * data directly inside the RPC request buffer(..since we performed a - * no-copy deXDRing..), we might end up writing more data than - * requested, because till now payload.iov_len accounts for all the - * bytes not just the write request bytes. These extra bytes are present - * as a requirement of the XDR encoding to round up the all string and - * opaque data buffers to multiples of 4 bytes. - */ - cs->datavec.iov_len = cs->datacount; - ret = nfs_write (cs->nfsx, cs->vol, &nfu, cs->fd, cs->iobref, - &cs->datavec, 1, cs->dataoffset, nfs3svc_write_cbk, - cs); +__nfs3_write_resume(nfs3_call_state_t *cs) +{ + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + if (!cs) return ret; -} + nfs_request_user_init(&nfu, cs->req); + /* It is possible that the RPC record contains more bytes than + * than the size of write requested in this request. This means, + * that in the RPC message buffer, there could be more bytes + * beyind the @count bytes. Since @payload is referring to the write + * data directly inside the RPC request buffer(..since we performed a + * no-copy deXDRing..), we might end up writing more data than + * requested, because till now payload.iov_len accounts for all the + * bytes not just the write request bytes. These extra bytes are present + * as a requirement of the XDR encoding to round up the all string and + * opaque data buffers to multiples of 4 bytes. + */ + cs->datavec.iov_len = cs->datacount; + ret = nfs_write(cs->nfsx, cs->vol, &nfu, cs->fd, cs->iobref, &cs->datavec, + 1, cs->dataoffset, nfs3svc_write_cbk, cs); + + return ret; +} int -nfs3_write_resume (void *carg) -{ - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs3_call_state_t *cs = NULL; - fd_t *fd = NULL; - - if (!carg) - return ret; - - cs = (nfs3_call_state_t *)carg; - nfs3_check_fh_auth_status (cs, stat, _gf_true, nfs3err); - nfs3_check_fh_resolve_status (cs, stat, nfs3err); - fd = fd_anonymous (cs->resolvedloc.inode); - if (!fd) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ANONYMOUS_FD_FAIL, - "Failed to create anonymous fd"); - goto nfs3err; - } +nfs3_write_resume(void *carg) +{ + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs3_call_state_t *cs = NULL; + fd_t *fd = NULL; - cs->fd = fd; /* Gets unrefd when the call state is wiped. */ + if (!carg) + return ret; - ret = __nfs3_write_resume (cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + cs = (nfs3_call_state_t *)carg; + nfs3_check_fh_auth_status(cs, stat, _gf_true, nfs3err); + nfs3_check_fh_resolve_status(cs, stat, nfs3err); + fd = fd_anonymous(cs->resolvedloc.inode); + if (!fd) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ANONYMOUS_FD_FAIL, + "Failed to create anonymous fd"); + goto nfs3err; + } + + cs->fd = fd; /* Gets unrefd when the call state is wiped. */ + + ret = __nfs3_write_resume(cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_WRITE, stat, -ret, - cs->resolvedloc.path); - nfs3_write_reply (cs->req, stat, 0, cs->writetype, 0, NULL, - NULL); - nfs3_call_state_wipe (cs); - } - return ret; + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_WRITE, stat, -ret, + cs->resolvedloc.path); + nfs3_write_reply(cs->req, stat, 0, cs->writetype, 0, NULL, NULL); + nfs3_call_state_wipe(cs); + } + return ret; } - int -nfs3_write (rpcsvc_request_t *req, struct nfs3_fh *fh, offset3 offset, - count3 count, stable_how stable, struct iovec payload, - struct iobref *iobref) -{ - xlator_t *vol = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - struct nfs3_state *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - - if ((!req) || (!fh) || (!payload.iov_base)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Bad arguments"); - return -1; - } - - nfs3_log_rw_call (rpcsvc_request_xid (req), "WRITE", fh, offset, - count, stable); - nfs3_validate_gluster_fh (fh, stat, nfs3err); - nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret); - nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err); - nfs3_volume_started_check (nfs3, vol, ret, out); - nfs3_check_rw_volaccess (nfs3, fh->exportid, stat, nfs3err); - nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err); - cs->datacount = count; - cs->dataoffset = offset; - cs->writetype = stable; - cs->iobref = iobref; - cs->datavec = payload; - - ret = nfs3_fh_resolve_and_resume (cs, fh, NULL, nfs3_write_resume); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); +nfs3_write(rpcsvc_request_t *req, struct nfs3_fh *fh, offset3 offset, + count3 count, stable_how stable, struct iovec payload, + struct iobref *iobref) +{ + xlator_t *vol = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + struct nfs3_state *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + + if ((!req) || (!fh) || (!payload.iov_base)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Bad arguments"); + return -1; + } + + nfs3_log_rw_call(rpcsvc_request_xid(req), "WRITE", fh, offset, count, + stable); + nfs3_validate_gluster_fh(fh, stat, nfs3err); + nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret); + nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err); + nfs3_volume_started_check(nfs3, vol, ret, out); + nfs3_check_rw_volaccess(nfs3, fh->exportid, stat, nfs3err); + nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err); + cs->datacount = count; + cs->dataoffset = offset; + cs->writetype = stable; + cs->iobref = iobref; + cs->datavec = payload; + + ret = nfs3_fh_resolve_and_resume(cs, fh, NULL, nfs3_write_resume); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (req), - NFS3_WRITE, stat, -ret, - cs ? cs->resolvedloc.path : NULL); - nfs3_write_reply (req, stat, 0, stable, 0, NULL, NULL); - nfs3_call_state_wipe (cs); - ret = 0; - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_WRITE, stat, -ret, + cs ? cs->resolvedloc.path : NULL); + nfs3_write_reply(req, stat, 0, stable, 0, NULL, NULL); + nfs3_call_state_wipe(cs); + ret = 0; + } out: - return ret; + return ret; } -#define NFS3_VECWRITE_READFHLEN 1 -#define NFS3_VECWRITE_READFH 2 -#define NFS3_VECWRITE_READREST 3 - -#define NFS3_WRITE_POSTFH_SIZE 20 +#define NFS3_VECWRITE_READFHLEN 1 +#define NFS3_VECWRITE_READFH 2 +#define NFS3_VECWRITE_READREST 3 +#define NFS3_WRITE_POSTFH_SIZE 20 int -nfs3svc_write_vecsizer (int state, ssize_t *readsize, char *base_addr, - char *curr_addr) -{ - int ret = 0; - uint32_t fhlen = 0; - uint32_t fhlen_n = 0; - - if (state == 0) { - ret = NFS3_VECWRITE_READFHLEN; - *readsize = 4; - } else if (state == NFS3_VECWRITE_READFHLEN) { - fhlen_n = *(uint32_t *)(curr_addr - 4); - fhlen = ntohl (fhlen_n); - *readsize = xdr_length_round_up (fhlen, NFS3_FHSIZE); - ret = NFS3_VECWRITE_READFH; - } else if (state == NFS3_VECWRITE_READFH) { - *readsize = NFS3_WRITE_POSTFH_SIZE; - ret = NFS3_VECWRITE_READREST; - } else if (state == NFS3_VECWRITE_READREST) { - ret = 0; - *readsize = 0; - } else - gf_msg ("nfs", GF_LOG_ERROR, 0, NFS_MSG_STATE_WRONG, - "state wrong"); +nfs3svc_write_vecsizer(int state, ssize_t *readsize, char *base_addr, + char *curr_addr) +{ + int ret = 0; + uint32_t fhlen = 0; + uint32_t fhlen_n = 0; + + if (state == 0) { + ret = NFS3_VECWRITE_READFHLEN; + *readsize = 4; + } else if (state == NFS3_VECWRITE_READFHLEN) { + fhlen_n = *(uint32_t *)(curr_addr - 4); + fhlen = ntohl(fhlen_n); + *readsize = xdr_length_round_up(fhlen, NFS3_FHSIZE); + ret = NFS3_VECWRITE_READFH; + } else if (state == NFS3_VECWRITE_READFH) { + *readsize = NFS3_WRITE_POSTFH_SIZE; + ret = NFS3_VECWRITE_READREST; + } else if (state == NFS3_VECWRITE_READREST) { + ret = 0; + *readsize = 0; + } else + gf_msg("nfs", GF_LOG_ERROR, 0, NFS_MSG_STATE_WRONG, "state wrong"); - return ret; + return ret; } - int -nfs3svc_write (rpcsvc_request_t *req) -{ - struct nfs3_fh fh = {{0}, }; - write3args args; - int ret = RPCSVC_ACTOR_ERROR; - - if (!req) - return ret; - nfs3_prep_write3args (&args, &fh); - if (xdr_to_write3args (req->msg[0], &args) <= 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } - - /* To ensure that the iobuf for the current record does not - * get returned to the iobpool, we need to keep a reference for - * ourselves because the RPC call handler who called us will unref its - * own ref of the record's iobuf when it is done handling the request. - */ +nfs3svc_write(rpcsvc_request_t *req) +{ + struct nfs3_fh fh = { + {0}, + }; + write3args args; + int ret = RPCSVC_ACTOR_ERROR; - ret = nfs3_write (req, &fh, args.offset, args.count, args.stable, - req->msg[1], rpcsvc_request_iobref_ref (req)); - if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, - NFS_MSG_WRITE_FAIL, - "WRITE procedure failed"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = RPCSVC_ACTOR_ERROR; - } + if (!req) + return ret; + nfs3_prep_write3args(&args, &fh); + if (xdr_to_write3args(req->msg[0], &args) <= 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + /* To ensure that the iobuf for the current record does not + * get returned to the iobpool, we need to keep a reference for + * ourselves because the RPC call handler who called us will unref its + * own ref of the record's iobuf when it is done handling the request. + */ + + ret = nfs3_write(req, &fh, args.offset, args.count, args.stable, + req->msg[1], rpcsvc_request_iobref_ref(req)); + if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_WRITE_FAIL, + "WRITE procedure failed"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = RPCSVC_ACTOR_ERROR; + } rpcerr: - return ret; + return ret; } - int -nfs3_create_reply (rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *newfh, - struct iatt *newbuf, struct iatt *preparent, - struct iatt *postparent) +nfs3_create_reply(rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *newfh, + struct iatt *newbuf, struct iatt *preparent, + struct iatt *postparent) { - create3res res = {0, }; - uint64_t deviceid = 0; + create3res res = { + 0, + }; + uint64_t deviceid = 0; - deviceid = nfs3_request_xlator_deviceid (req); - nfs3_fill_create3res (&res, stat, newfh, newbuf, preparent, postparent, - deviceid); - nfs3svc_submit_reply (req, (void *)&res, - (nfs3_serializer)xdr_serialize_create3res); - return 0; + deviceid = nfs3_request_xlator_deviceid(req); + nfs3_fill_create3res(&res, stat, newfh, newbuf, preparent, postparent, + deviceid); + nfs3svc_submit_reply(req, (void *)&res, + (nfs3_serializer)xdr_serialize_create3res); + return 0; } - int32_t -nfs3svc_create_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct iatt *preop, struct iatt *postop, dict_t *xdata) +nfs3svc_create_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *preop, + struct iatt *postop, dict_t *xdata) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + nfs3_call_state_t *cs = NULL; - cs = frame->local; - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - goto nfs3err; - } + cs = frame->local; + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + goto nfs3err; + } - stat = NFS3_OK; + stat = NFS3_OK; nfs3err: - nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), - NFS3_CREATE, stat, op_errno, - &cs->fh, cs->resolvedloc.path); - nfs3_create_reply (cs->req, stat, &cs->fh, postop, &cs->preparent, - &cs->postparent); - nfs3_call_state_wipe (cs); + nfs3_log_newfh_res(rpcsvc_request_xid(cs->req), NFS3_CREATE, stat, op_errno, + &cs->fh, cs->resolvedloc.path); + nfs3_create_reply(cs->req, stat, &cs->fh, postop, &cs->preparent, + &cs->postparent); + nfs3_call_state_wipe(cs); - return 0; + return 0; } - int32_t -nfs3svc_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +nfs3svc_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - nfs3_call_state_t *cs = NULL; - inode_t *oldinode = NULL; - - cs = frame->local; - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - goto nfs3err; - } - - nfs3_fh_build_child_fh (&cs->parent, buf, &cs->fh); - oldinode = inode_link (inode, cs->resolvedloc.parent, - cs->resolvedloc.name, buf); - - /* Means no attributes were required to be set. */ - if (!cs->setattr_valid) { - stat = NFS3_OK; - ret = -1; - goto nfs3err; - } - - cs->preparent = *preparent; - cs->postparent = *postparent; - nfs_request_user_init (&nfu, cs->req); - gf_uuid_copy (cs->resolvedloc.gfid, oldinode->gfid); - ret = nfs_setattr (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,&cs->stbuf, - cs->setattr_valid, nfs3svc_create_setattr_cbk, cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + nfs3_call_state_t *cs = NULL; + inode_t *oldinode = NULL; + + cs = frame->local; + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + goto nfs3err; + } + + nfs3_fh_build_child_fh(&cs->parent, buf, &cs->fh); + oldinode = inode_link(inode, cs->resolvedloc.parent, cs->resolvedloc.name, + buf); + + /* Means no attributes were required to be set. */ + if (!cs->setattr_valid) { + stat = NFS3_OK; + ret = -1; + goto nfs3err; + } + + cs->preparent = *preparent; + cs->postparent = *postparent; + nfs_request_user_init(&nfu, cs->req); + gf_uuid_copy(cs->resolvedloc.gfid, oldinode->gfid); + ret = nfs_setattr(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, &cs->stbuf, + cs->setattr_valid, nfs3svc_create_setattr_cbk, cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (oldinode) { - inode_lookup (oldinode); - inode_unref (oldinode); - } + if (oldinode) { + inode_lookup(oldinode); + inode_unref(oldinode); + } - if (ret < 0) { - nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), - NFS3_CREATE, stat, op_errno, &cs->fh, - cs->resolvedloc.path); - nfs3_create_reply (cs->req, stat, &cs->fh, buf, preparent, - postparent); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_newfh_res(rpcsvc_request_xid(cs->req), NFS3_CREATE, stat, + op_errno, &cs->fh, cs->resolvedloc.path); + nfs3_create_reply(cs->req, stat, &cs->fh, buf, preparent, postparent); + nfs3_call_state_wipe(cs); + } - return 0; + return 0; } int -nfs3_create_common (nfs3_call_state_t *cs) +nfs3_create_common(nfs3_call_state_t *cs) { - int ret = -EFAULT; - int flags = 0; - nfs_user_t nfu = {0, }; - uid_t uid = 0; - gid_t gid = 0; - - if (!cs) - return ret; - - if (cs->createmode == GUARDED) - flags = (O_RDWR | O_EXCL); - else - flags = O_RDWR; - - if (gf_attr_uid_set (cs->setattr_valid)) { - uid = cs->stbuf.ia_uid; - cs->setattr_valid &= ~GF_SET_ATTR_UID; - } else - uid = rpcsvc_request_uid (cs->req); - - if (gf_attr_gid_set (cs->setattr_valid)) { - gid = cs->stbuf.ia_gid; - cs->setattr_valid &= ~GF_SET_ATTR_GID; - } else - gid = rpcsvc_request_gid (cs->req); - - nfs_request_primary_user_init (&nfu, cs->req, uid, gid); - /* We can avoid sending the setattr call later if only the mode is - * required to be set. This is possible because the create fop allows - * us to specify a mode arg. - */ - if (cs->setattr_valid & GF_SET_ATTR_MODE) { - cs->setattr_valid &= ~GF_SET_ATTR_MODE; - ret = nfs_create (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - flags, cs->mode, nfs3svc_create_cbk, cs); - } else - ret = nfs_create (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - flags, NFS_DEFAULT_CREATE_MODE, - nfs3svc_create_cbk, cs); + int ret = -EFAULT; + int flags = 0; + nfs_user_t nfu = { + 0, + }; + uid_t uid = 0; + gid_t gid = 0; + if (!cs) return ret; -} + if (cs->createmode == GUARDED) + flags = (O_RDWR | O_EXCL); + else + flags = O_RDWR; + + if (gf_attr_uid_set(cs->setattr_valid)) { + uid = cs->stbuf.ia_uid; + cs->setattr_valid &= ~GF_SET_ATTR_UID; + } else + uid = rpcsvc_request_uid(cs->req); + + if (gf_attr_gid_set(cs->setattr_valid)) { + gid = cs->stbuf.ia_gid; + cs->setattr_valid &= ~GF_SET_ATTR_GID; + } else + gid = rpcsvc_request_gid(cs->req); + + nfs_request_primary_user_init(&nfu, cs->req, uid, gid); + /* We can avoid sending the setattr call later if only the mode is + * required to be set. This is possible because the create fop allows + * us to specify a mode arg. + */ + if (cs->setattr_valid & GF_SET_ATTR_MODE) { + cs->setattr_valid &= ~GF_SET_ATTR_MODE; + ret = nfs_create(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, flags, + cs->mode, nfs3svc_create_cbk, cs); + } else + ret = nfs_create(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, flags, + NFS_DEFAULT_CREATE_MODE, nfs3svc_create_cbk, cs); + + return ret; +} int32_t -nfs3svc_create_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, - dict_t *xdata) +nfs3svc_create_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *buf, + dict_t *xdata) { - int ret = -EFAULT; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - nfs_user_t nfu = {0, }; - nfs3_call_state_t *cs = NULL; - - cs = frame->local; - nfs_request_user_init (&nfu, cs->req); - if (op_ret == -1) { - ret = -op_errno; - stat = nfs3_cbk_errno_status (op_ret, op_errno); - goto nfs3err; - } - - if ((cs->stbuf.ia_mtime == buf->ia_mtime) && - (cs->stbuf.ia_atime == buf->ia_atime)) { - gf_msg_debug (GF_NFS3, 0, - "Create req retransmitted verf %ld %ld", - cs->stbuf.ia_mtime, cs->stbuf.ia_atime); - stat = NFS3_OK; - nfs3_fh_build_child_fh (&cs->parent, buf, &cs->fh); - } else { - gf_msg_debug (GF_NFS3, 0, - "File already exist new_verf %ld %ld" - "old_verf %ld %ld", cs->stbuf.ia_mtime, - cs->stbuf.ia_atime, - buf->ia_mtime, buf->ia_atime); - stat = NFS3ERR_EXIST; - } + int ret = -EFAULT; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + nfs_user_t nfu = { + 0, + }; + nfs3_call_state_t *cs = NULL; + + cs = frame->local; + nfs_request_user_init(&nfu, cs->req); + if (op_ret == -1) { + ret = -op_errno; + stat = nfs3_cbk_errno_status(op_ret, op_errno); + goto nfs3err; + } + + if ((cs->stbuf.ia_mtime == buf->ia_mtime) && + (cs->stbuf.ia_atime == buf->ia_atime)) { + gf_msg_debug(GF_NFS3, 0, "Create req retransmitted verf %ld %ld", + cs->stbuf.ia_mtime, cs->stbuf.ia_atime); + stat = NFS3_OK; + nfs3_fh_build_child_fh(&cs->parent, buf, &cs->fh); + } else { + gf_msg_debug(GF_NFS3, 0, + "File already exist new_verf %ld %ld" + "old_verf %ld %ld", + cs->stbuf.ia_mtime, cs->stbuf.ia_atime, buf->ia_mtime, + buf->ia_atime); + stat = NFS3ERR_EXIST; + } nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_CREATE, stat, op_errno, - cs->resolvedloc.path); - nfs3_create_reply (cs->req, stat, &cs->fh, buf, NULL, NULL); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_CREATE, stat, + op_errno, cs->resolvedloc.path); + nfs3_create_reply(cs->req, stat, &cs->fh, buf, NULL, NULL); + nfs3_call_state_wipe(cs); + } - return 0; + return 0; } - int -nfs3_create_exclusive (nfs3_call_state_t *cs) -{ - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - - if (!cs) - return ret; - - /* Storing verifier as a mtime and atime attribute, to store it - * in stable storage */ - memcpy (&cs->stbuf.ia_atime, &cs->cookieverf, - sizeof (cs->stbuf.ia_atime)); - memcpy (&cs->stbuf.ia_mtime, - ((char *) &cs->cookieverf) + sizeof (cs->stbuf.ia_atime), - sizeof (cs->stbuf.ia_mtime)); - cs->setattr_valid |= GF_SET_ATTR_ATIME; - cs->setattr_valid |= GF_SET_ATTR_MTIME; - nfs_request_user_init (&nfu, cs->req); - - /* If the file already existed we need to get that attributes so we can - * compare and check whether a previous create operation was - * interrupted due to server failure or dropped packets. - */ - if ((cs->resolve_ret == 0) || - ((cs->resolve_ret == -1) && (cs->resolve_errno != ENOENT))) { - ret = nfs_stat (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - nfs3svc_create_stat_cbk, cs); - goto nfs3err; - } +nfs3_create_exclusive(nfs3_call_state_t *cs) +{ + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; - ret = nfs3_create_common (cs); -nfs3err: + if (!cs) return ret; -} + /* Storing verifier as a mtime and atime attribute, to store it + * in stable storage */ + memcpy(&cs->stbuf.ia_atime, &cs->cookieverf, sizeof(cs->stbuf.ia_atime)); + memcpy(&cs->stbuf.ia_mtime, + ((char *)&cs->cookieverf) + sizeof(cs->stbuf.ia_atime), + sizeof(cs->stbuf.ia_mtime)); + cs->setattr_valid |= GF_SET_ATTR_ATIME; + cs->setattr_valid |= GF_SET_ATTR_MTIME; + nfs_request_user_init(&nfu, cs->req); + + /* If the file already existed we need to get that attributes so we can + * compare and check whether a previous create operation was + * interrupted due to server failure or dropped packets. + */ + if ((cs->resolve_ret == 0) || + ((cs->resolve_ret == -1) && (cs->resolve_errno != ENOENT))) { + ret = nfs_stat(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + nfs3svc_create_stat_cbk, cs); + goto nfs3err; + } + + ret = nfs3_create_common(cs); +nfs3err: + return ret; +} int -nfs3_create_resume (void *carg) +nfs3_create_resume(void *carg) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs3_call_state_t *cs = NULL; - if (!carg) - return ret; + if (!carg) + return ret; - cs = (nfs3_call_state_t *)carg; - nfs3_check_fh_auth_status (cs, stat, _gf_true, nfs3err); - nfs3_check_new_fh_resolve_status (cs, stat, nfs3err); - if (cs->createmode == EXCLUSIVE) - ret = nfs3_create_exclusive (cs); - else - ret = nfs3_create_common (cs); + cs = (nfs3_call_state_t *)carg; + nfs3_check_fh_auth_status(cs, stat, _gf_true, nfs3err); + nfs3_check_new_fh_resolve_status(cs, stat, nfs3err); + if (cs->createmode == EXCLUSIVE) + ret = nfs3_create_exclusive(cs); + else + ret = nfs3_create_common(cs); - /* Handle a failure return from either of the create functions above. */ - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + /* Handle a failure return from either of the create functions above. */ + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_CREATE, stat, -ret, - cs->resolvedloc.path); - nfs3_create_reply (cs->req, stat, NULL, NULL, NULL, NULL); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_CREATE, stat, + -ret, cs->resolvedloc.path); + nfs3_create_reply(cs->req, stat, NULL, NULL, NULL, NULL); + nfs3_call_state_wipe(cs); + } - return ret; + return ret; } int -nfs3_create (rpcsvc_request_t *req, struct nfs3_fh *dirfh, char *name, - createmode3 mode, sattr3 *sattr, uint64_t cverf) -{ - xlator_t *vol = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - struct nfs3_state *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - - if ((!req) || (!dirfh) || (!name) || (!sattr)) - return -1; - - nfs3_log_create_call (rpcsvc_request_xid (req), dirfh, name, mode); - nfs3_validate_gluster_fh (dirfh, stat, nfs3err); - nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret); - nfs3_validate_strlen_or_goto (name, NFS_NAME_MAX, nfs3err, stat, ret); - nfs3_map_fh_to_volume (nfs3, dirfh, req, vol, stat, nfs3err); - nfs3_volume_started_check (nfs3, vol, ret, out); - nfs3_check_rw_volaccess (nfs3, dirfh->exportid, stat, nfs3err); - nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err); - - cs->cookieverf = cverf; - /*In Exclusive create client is supposed to send cverf instead of - * sattr*/ - if (mode != EXCLUSIVE) - cs->setattr_valid = nfs3_sattr3_to_setattr_valid (sattr, - &cs->stbuf, - &cs->mode); - cs->createmode = mode; - cs->parent = *dirfh; - - ret = nfs3_fh_resolve_and_resume (cs, dirfh, name, nfs3_create_resume); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); +nfs3_create(rpcsvc_request_t *req, struct nfs3_fh *dirfh, char *name, + createmode3 mode, sattr3 *sattr, uint64_t cverf) +{ + xlator_t *vol = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + struct nfs3_state *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + + if ((!req) || (!dirfh) || (!name) || (!sattr)) + return -1; + + nfs3_log_create_call(rpcsvc_request_xid(req), dirfh, name, mode); + nfs3_validate_gluster_fh(dirfh, stat, nfs3err); + nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret); + nfs3_validate_strlen_or_goto(name, NFS_NAME_MAX, nfs3err, stat, ret); + nfs3_map_fh_to_volume(nfs3, dirfh, req, vol, stat, nfs3err); + nfs3_volume_started_check(nfs3, vol, ret, out); + nfs3_check_rw_volaccess(nfs3, dirfh->exportid, stat, nfs3err); + nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err); + + cs->cookieverf = cverf; + /*In Exclusive create client is supposed to send cverf instead of + * sattr*/ + if (mode != EXCLUSIVE) + cs->setattr_valid = nfs3_sattr3_to_setattr_valid(sattr, &cs->stbuf, + &cs->mode); + cs->createmode = mode; + cs->parent = *dirfh; + + ret = nfs3_fh_resolve_and_resume(cs, dirfh, name, nfs3_create_resume); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (req), - NFS3_CREATE, stat, -ret, - cs ? cs->resolvedloc.path : NULL); - nfs3_create_reply (req, stat, NULL, NULL, NULL, NULL); - nfs3_call_state_wipe (cs); - ret = 0; - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_CREATE, stat, -ret, + cs ? cs->resolvedloc.path : NULL); + nfs3_create_reply(req, stat, NULL, NULL, NULL, NULL); + nfs3_call_state_wipe(cs); + ret = 0; + } out: - return ret; + return ret; } - int -nfs3svc_create (rpcsvc_request_t *req) -{ - char name[NFS_PATH_MAX]; - struct nfs3_fh dirfh = {{0}, }; - create3args args; - int ret = RPCSVC_ACTOR_ERROR; - uint64_t cverf = 0; - uint64_t *cval; - - if (!req) - return ret; - - nfs3_prep_create3args (&args, &dirfh, name); - if (xdr_to_create3args (req->msg[0], &args) <= 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } - - cval = (uint64_t *)args.how.createhow3_u.verf; - cverf = *cval; +nfs3svc_create(rpcsvc_request_t *req) +{ + char name[NFS_PATH_MAX]; + struct nfs3_fh dirfh = { + {0}, + }; + create3args args; + int ret = RPCSVC_ACTOR_ERROR; + uint64_t cverf = 0; + uint64_t *cval; + + if (!req) + return ret; - ret = nfs3_create (req, &dirfh, name, args.how.mode, - &args.how.createhow3_u.obj_attributes, cverf); - if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_CREATE_FAIL, - "CREATE procedure failed"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = RPCSVC_ACTOR_ERROR; - } + nfs3_prep_create3args(&args, &dirfh, name); + if (xdr_to_create3args(req->msg[0], &args) <= 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + cval = (uint64_t *)args.how.createhow3_u.verf; + cverf = *cval; + + ret = nfs3_create(req, &dirfh, name, args.how.mode, + &args.how.createhow3_u.obj_attributes, cverf); + if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_CREATE_FAIL, + "CREATE procedure failed"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = RPCSVC_ACTOR_ERROR; + } rpcerr: - return ret; + return ret; } - int -nfs3_mkdir_reply (rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *fh, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent) +nfs3_mkdir_reply(rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *fh, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent) { - mkdir3res res = {0, }; - uint64_t deviceid = 0; + mkdir3res res = { + 0, + }; + uint64_t deviceid = 0; - deviceid = nfs3_request_xlator_deviceid (req); - nfs3_fill_mkdir3res (&res, stat, fh, buf, preparent, postparent, - deviceid); - nfs3svc_submit_reply (req, &res, - (nfs3_serializer)xdr_serialize_mkdir3res); - return 0; + deviceid = nfs3_request_xlator_deviceid(req); + nfs3_fill_mkdir3res(&res, stat, fh, buf, preparent, postparent, deviceid); + nfs3svc_submit_reply(req, &res, (nfs3_serializer)xdr_serialize_mkdir3res); + return 0; } int32_t -nfs3svc_mkdir_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct iatt *preop, struct iatt *postop, dict_t *xdata) +nfs3svc_mkdir_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *preop, + struct iatt *postop, dict_t *xdata) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + nfs3_call_state_t *cs = NULL; - cs = frame->local; - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - goto nfs3err; - } + cs = frame->local; + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + goto nfs3err; + } - stat = NFS3_OK; + stat = NFS3_OK; nfs3err: - nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), - NFS3_MKDIR, stat, op_errno, &cs->fh, - cs->resolvedloc.path); - nfs3_mkdir_reply (cs->req, stat, &cs->fh, postop, &cs->preparent, - &cs->postparent); - nfs3_call_state_wipe (cs); + nfs3_log_newfh_res(rpcsvc_request_xid(cs->req), NFS3_MKDIR, stat, op_errno, + &cs->fh, cs->resolvedloc.path); + nfs3_mkdir_reply(cs->req, stat, &cs->fh, postop, &cs->preparent, + &cs->postparent); + nfs3_call_state_wipe(cs); - return 0; + return 0; } - int32_t -nfs3svc_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +nfs3svc_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + nfs3_call_state_t *cs = NULL; - cs = frame->local; - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - goto nfs3err; - } + cs = frame->local; + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + goto nfs3err; + } - nfs3_fh_build_child_fh (&cs->parent, buf, &cs->fh); + nfs3_fh_build_child_fh(&cs->parent, buf, &cs->fh); - /* Means no attributes were required to be set. */ - if (!cs->setattr_valid) { - stat = NFS3_OK; - goto nfs3err; - } + /* Means no attributes were required to be set. */ + if (!cs->setattr_valid) { + stat = NFS3_OK; + goto nfs3err; + } - cs->preparent = *preparent; - cs->postparent = *postparent; - nfs_request_user_init (&nfu, cs->req); - ret = nfs_setattr (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,&cs->stbuf, - cs->setattr_valid, nfs3svc_mkdir_setattr_cbk, cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + cs->preparent = *preparent; + cs->postparent = *postparent; + nfs_request_user_init(&nfu, cs->req); + ret = nfs_setattr(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, &cs->stbuf, + cs->setattr_valid, nfs3svc_mkdir_setattr_cbk, cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), - NFS3_MKDIR, stat, op_errno, &cs->fh, - cs->resolvedloc.path); - nfs3_mkdir_reply (cs->req, stat, &cs->fh, buf, preparent, - postparent); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_newfh_res(rpcsvc_request_xid(cs->req), NFS3_MKDIR, stat, + op_errno, &cs->fh, cs->resolvedloc.path); + nfs3_mkdir_reply(cs->req, stat, &cs->fh, buf, preparent, postparent); + nfs3_call_state_wipe(cs); + } - return 0; + return 0; } - int -nfs3_mkdir_resume (void *carg) +nfs3_mkdir_resume(void *carg) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + nfs3_call_state_t *cs = NULL; - if (!carg) - return ret; + if (!carg) + return ret; - cs = (nfs3_call_state_t *)carg; - nfs3_check_new_fh_resolve_status (cs, stat, nfs3err); - nfs_request_user_init (&nfu, cs->req); + cs = (nfs3_call_state_t *)carg; + nfs3_check_new_fh_resolve_status(cs, stat, nfs3err); + nfs_request_user_init(&nfu, cs->req); - if (gf_attr_mode_set (cs->setattr_valid)) { - cs->setattr_valid &= ~GF_SET_ATTR_MODE; - ret = nfs_mkdir (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - cs->mode, nfs3svc_mkdir_cbk, cs); - } else - ret = nfs_mkdir (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - cs->mode, nfs3svc_mkdir_cbk, cs); + if (gf_attr_mode_set(cs->setattr_valid)) { + cs->setattr_valid &= ~GF_SET_ATTR_MODE; + ret = nfs_mkdir(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, cs->mode, + nfs3svc_mkdir_cbk, cs); + } else + ret = nfs_mkdir(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, cs->mode, + nfs3svc_mkdir_cbk, cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_MKDIR, stat, -ret, - cs->resolvedloc.path); - nfs3_mkdir_reply (cs->req, stat, NULL, NULL, NULL, NULL); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_MKDIR, stat, -ret, + cs->resolvedloc.path); + nfs3_mkdir_reply(cs->req, stat, NULL, NULL, NULL, NULL); + nfs3_call_state_wipe(cs); + } - return 0; + return 0; } - - int -nfs3_mkdir (rpcsvc_request_t *req, struct nfs3_fh *dirfh, char *name, - sattr3 *sattr) -{ - xlator_t *vol = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - struct nfs3_state *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - - if ((!req) || (!dirfh) || (!name) || (!sattr)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Bad arguments"); - return -1; - } - - nfs3_log_fh_entry_call (rpcsvc_request_xid (req), "MKDIR", dirfh, - name); - nfs3_validate_gluster_fh (dirfh, stat, nfs3err); - nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret); - nfs3_validate_strlen_or_goto (name, NFS_NAME_MAX, nfs3err, stat, ret); - nfs3_map_fh_to_volume (nfs3, dirfh, req, vol, stat, nfs3err); - nfs3_volume_started_check (nfs3, vol, ret, out); - nfs3_check_rw_volaccess (nfs3, dirfh->exportid, stat, nfs3err); - nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err); - - cs->parent = *dirfh; - cs->setattr_valid = nfs3_sattr3_to_setattr_valid (sattr, &cs->stbuf, - &cs->mode); - ret = nfs3_fh_resolve_and_resume (cs, dirfh, name, nfs3_mkdir_resume); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); +nfs3_mkdir(rpcsvc_request_t *req, struct nfs3_fh *dirfh, char *name, + sattr3 *sattr) +{ + xlator_t *vol = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + struct nfs3_state *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + + if ((!req) || (!dirfh) || (!name) || (!sattr)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Bad arguments"); + return -1; + } + + nfs3_log_fh_entry_call(rpcsvc_request_xid(req), "MKDIR", dirfh, name); + nfs3_validate_gluster_fh(dirfh, stat, nfs3err); + nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret); + nfs3_validate_strlen_or_goto(name, NFS_NAME_MAX, nfs3err, stat, ret); + nfs3_map_fh_to_volume(nfs3, dirfh, req, vol, stat, nfs3err); + nfs3_volume_started_check(nfs3, vol, ret, out); + nfs3_check_rw_volaccess(nfs3, dirfh->exportid, stat, nfs3err); + nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err); + + cs->parent = *dirfh; + cs->setattr_valid = nfs3_sattr3_to_setattr_valid(sattr, &cs->stbuf, + &cs->mode); + ret = nfs3_fh_resolve_and_resume(cs, dirfh, name, nfs3_mkdir_resume); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (req), - NFS3_MKDIR, stat, -ret, - cs ? cs->resolvedloc.path : NULL); - nfs3_mkdir_reply (req, stat, NULL, NULL, NULL, NULL); - nfs3_call_state_wipe (cs); - ret = 0; - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_MKDIR, stat, -ret, + cs ? cs->resolvedloc.path : NULL); + nfs3_mkdir_reply(req, stat, NULL, NULL, NULL, NULL); + nfs3_call_state_wipe(cs); + ret = 0; + } out: - return ret; + return ret; } - int -nfs3svc_mkdir (rpcsvc_request_t *req) -{ - char name[NFS_PATH_MAX]; - struct nfs3_fh dirfh = {{0}, }; - mkdir3args args; - int ret = RPCSVC_ACTOR_ERROR; - - if (!req) - return ret; - nfs3_prep_mkdir3args (&args, &dirfh, name); - if (xdr_to_mkdir3args (req->msg[0], &args) <= 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } +nfs3svc_mkdir(rpcsvc_request_t *req) +{ + char name[NFS_PATH_MAX]; + struct nfs3_fh dirfh = { + {0}, + }; + mkdir3args args; + int ret = RPCSVC_ACTOR_ERROR; - ret = nfs3_mkdir (req, &dirfh, name, &args.attributes); - if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_DIR_OP_FAIL, - "MKDIR procedure failed"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = RPCSVC_ACTOR_ERROR; - } + if (!req) + return ret; + nfs3_prep_mkdir3args(&args, &dirfh, name); + if (xdr_to_mkdir3args(req->msg[0], &args) <= 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + ret = nfs3_mkdir(req, &dirfh, name, &args.attributes); + if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_DIR_OP_FAIL, + "MKDIR procedure failed"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = RPCSVC_ACTOR_ERROR; + } rpcerr: - return ret; + return ret; } - int -nfs3_symlink_reply (rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *fh, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent) +nfs3_symlink_reply(rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *fh, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent) { - symlink3res res = {0, }; - uint64_t deviceid = 0; + symlink3res res = { + 0, + }; + uint64_t deviceid = 0; - deviceid = nfs3_request_xlator_deviceid (req); - nfs3_fill_symlink3res (&res, stat, fh, buf, preparent, postparent, - deviceid); - nfs3svc_submit_reply (req, (void *)&res, - (nfs3_serializer)xdr_serialize_symlink3res); + deviceid = nfs3_request_xlator_deviceid(req); + nfs3_fill_symlink3res(&res, stat, fh, buf, preparent, postparent, deviceid); + nfs3svc_submit_reply(req, (void *)&res, + (nfs3_serializer)xdr_serialize_symlink3res); - return 0; + return 0; } - int32_t -nfs3svc_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) -{ - nfsstat3 stat = NFS3ERR_SERVERFAULT; - nfs3_call_state_t *cs = NULL; - - cs = frame->local; - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - goto nfs3err; - } +nfs3svc_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) +{ + nfsstat3 stat = NFS3ERR_SERVERFAULT; + nfs3_call_state_t *cs = NULL; - nfs3_fh_build_child_fh (&cs->parent, buf, &cs->fh); - stat = NFS3_OK; + cs = frame->local; + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + goto nfs3err; + } + + nfs3_fh_build_child_fh(&cs->parent, buf, &cs->fh); + stat = NFS3_OK; nfs3err: - nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), - NFS3_SYMLINK, stat, op_errno, &cs->fh, - cs->resolvedloc.path); - nfs3_symlink_reply (cs->req, stat, &cs->fh, buf, preparent, - postparent); - nfs3_call_state_wipe (cs); - return 0; + nfs3_log_newfh_res(rpcsvc_request_xid(cs->req), NFS3_SYMLINK, stat, + op_errno, &cs->fh, cs->resolvedloc.path); + nfs3_symlink_reply(cs->req, stat, &cs->fh, buf, preparent, postparent); + nfs3_call_state_wipe(cs); + return 0; } - int -nfs3_symlink_resume (void *carg) +nfs3_symlink_resume(void *carg) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs3_call_state_t *cs = NULL; - nfs_user_t nfu = {0, }; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs3_call_state_t *cs = NULL; + nfs_user_t nfu = { + 0, + }; - if (!carg) - return ret; + if (!carg) + return ret; - cs = (nfs3_call_state_t *)carg; - nfs3_check_new_fh_resolve_status (cs, stat, nfs3err); - nfs_request_user_init (&nfu, cs->req); - ret = nfs_symlink (cs->nfsx, cs->vol, &nfu, cs->pathname, - &cs->resolvedloc, nfs3svc_symlink_cbk, cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + cs = (nfs3_call_state_t *)carg; + nfs3_check_new_fh_resolve_status(cs, stat, nfs3err); + nfs_request_user_init(&nfu, cs->req); + ret = nfs_symlink(cs->nfsx, cs->vol, &nfu, cs->pathname, &cs->resolvedloc, + nfs3svc_symlink_cbk, cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_SYMLINK, stat, -ret, - cs->resolvedloc.path); - nfs3_symlink_reply (cs->req, stat, NULL, NULL, NULL, NULL); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_SYMLINK, stat, + -ret, cs->resolvedloc.path); + nfs3_symlink_reply(cs->req, stat, NULL, NULL, NULL, NULL); + nfs3_call_state_wipe(cs); + } - return ret; + return ret; } - int -nfs3_symlink (rpcsvc_request_t *req, struct nfs3_fh *dirfh, char *name, - char *target, sattr3 *sattr) -{ - xlator_t *vol = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - struct nfs3_state *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - - if ((!req) || (!dirfh) || (!name) || (!target) || (!sattr)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Bad arguments"); - return -1; - } - - nfs3_log_symlink_call (rpcsvc_request_xid (req), dirfh, name, - target); - nfs3_validate_gluster_fh (dirfh, stat, nfs3err); - nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret); - nfs3_validate_strlen_or_goto (name, NFS_NAME_MAX, nfs3err, stat, ret); - nfs3_map_fh_to_volume (nfs3, dirfh, req, vol, stat, nfs3err); - nfs3_volume_started_check (nfs3, vol, ret, out); - nfs3_check_rw_volaccess (nfs3, dirfh->exportid, stat, nfs3err); - nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err); - - cs->parent = *dirfh; - cs->pathname = gf_strdup (target); - if (!cs->pathname) { - ret = -1; - stat = NFS3ERR_SERVERFAULT; - goto nfs3err; - } - - ret = nfs3_fh_resolve_and_resume (cs, dirfh, name, nfs3_symlink_resume); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); +nfs3_symlink(rpcsvc_request_t *req, struct nfs3_fh *dirfh, char *name, + char *target, sattr3 *sattr) +{ + xlator_t *vol = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + struct nfs3_state *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + + if ((!req) || (!dirfh) || (!name) || (!target) || (!sattr)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Bad arguments"); + return -1; + } + + nfs3_log_symlink_call(rpcsvc_request_xid(req), dirfh, name, target); + nfs3_validate_gluster_fh(dirfh, stat, nfs3err); + nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret); + nfs3_validate_strlen_or_goto(name, NFS_NAME_MAX, nfs3err, stat, ret); + nfs3_map_fh_to_volume(nfs3, dirfh, req, vol, stat, nfs3err); + nfs3_volume_started_check(nfs3, vol, ret, out); + nfs3_check_rw_volaccess(nfs3, dirfh->exportid, stat, nfs3err); + nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err); + + cs->parent = *dirfh; + cs->pathname = gf_strdup(target); + if (!cs->pathname) { + ret = -1; + stat = NFS3ERR_SERVERFAULT; + goto nfs3err; + } + + ret = nfs3_fh_resolve_and_resume(cs, dirfh, name, nfs3_symlink_resume); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (req), - NFS3_SYMLINK, stat, -ret, - cs ? cs->resolvedloc.path : NULL); - nfs3_symlink_reply (req, stat, NULL, NULL, NULL, NULL); - nfs3_call_state_wipe (cs); - /* Ret must be 0 after this so that the caller does not - * also send an RPC reply. - */ - ret = 0; - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_SYMLINK, stat, -ret, + cs ? cs->resolvedloc.path : NULL); + nfs3_symlink_reply(req, stat, NULL, NULL, NULL, NULL); + nfs3_call_state_wipe(cs); + /* Ret must be 0 after this so that the caller does not + * also send an RPC reply. + */ + ret = 0; + } out: - return ret; + return ret; } - int -nfs3svc_symlink (rpcsvc_request_t *req) -{ - char name[NFS_PATH_MAX]; - struct nfs3_fh dirfh = {{0}, }; - char target[NFS_PATH_MAX]; - symlink3args args; - int ret = RPCSVC_ACTOR_ERROR; - - if (!req) - return ret; - nfs3_prep_symlink3args (&args, &dirfh, name, target); - if (xdr_to_symlink3args (req->msg[0], &args) <= 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } +nfs3svc_symlink(rpcsvc_request_t *req) +{ + char name[NFS_PATH_MAX]; + struct nfs3_fh dirfh = { + {0}, + }; + char target[NFS_PATH_MAX]; + symlink3args args; + int ret = RPCSVC_ACTOR_ERROR; - ret = nfs3_symlink (req, &dirfh, name, target, - &args.symlink.symlink_attributes); - if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, EXDEV, NFS_MSG_SYMLINK_FAIL, - "SYMLINK procedure failed"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = RPCSVC_ACTOR_ERROR; - } + if (!req) + return ret; + nfs3_prep_symlink3args(&args, &dirfh, name, target); + if (xdr_to_symlink3args(req->msg[0], &args) <= 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + ret = nfs3_symlink(req, &dirfh, name, target, + &args.symlink.symlink_attributes); + if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, EXDEV, NFS_MSG_SYMLINK_FAIL, + "SYMLINK procedure failed"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = RPCSVC_ACTOR_ERROR; + } rpcerr: - return ret; + return ret; } - static int -nfs3_mknod_reply (rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *fh, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent) +nfs3_mknod_reply(rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *fh, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent) { - mknod3res res = {0, }; - uint64_t deviceid = 0; + mknod3res res = { + 0, + }; + uint64_t deviceid = 0; - deviceid = nfs3_request_xlator_deviceid (req); - nfs3_fill_mknod3res (&res, stat, fh, buf, preparent, postparent, - deviceid); - nfs3svc_submit_reply (req, (void *)&res, - (nfs3_serializer)xdr_serialize_mknod3res); + deviceid = nfs3_request_xlator_deviceid(req); + nfs3_fill_mknod3res(&res, stat, fh, buf, preparent, postparent, deviceid); + nfs3svc_submit_reply(req, (void *)&res, + (nfs3_serializer)xdr_serialize_mknod3res); - return 0; + return 0; } int32_t -nfs3svc_mknod_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct iatt *preop, struct iatt *postop, dict_t *xdata) +nfs3svc_mknod_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *preop, + struct iatt *postop, dict_t *xdata) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + nfs3_call_state_t *cs = NULL; - cs = frame->local; - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - goto nfs3err; - } + cs = frame->local; + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + goto nfs3err; + } - stat = NFS3_OK; + stat = NFS3_OK; nfs3err: - nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), - NFS3_MKNOD, stat, op_errno, &cs->fh, - cs->resolvedloc.path); - nfs3_mknod_reply (cs->req, stat, &cs->fh, postop, &cs->preparent, - &cs->postparent); - nfs3_call_state_wipe (cs); - return 0; + nfs3_log_newfh_res(rpcsvc_request_xid(cs->req), NFS3_MKNOD, stat, op_errno, + &cs->fh, cs->resolvedloc.path); + nfs3_mknod_reply(cs->req, stat, &cs->fh, postop, &cs->preparent, + &cs->postparent); + nfs3_call_state_wipe(cs); + return 0; } - - int32_t -nfs3svc_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +nfs3svc_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -1; - nfs_user_t nfu = {0, }; - nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -1; + nfs_user_t nfu = { + 0, + }; + nfs3_call_state_t *cs = NULL; - cs = frame->local; - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - goto nfs3err; - } + cs = frame->local; + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + goto nfs3err; + } - nfs3_fh_build_child_fh (&cs->parent, buf, &cs->fh); + nfs3_fh_build_child_fh(&cs->parent, buf, &cs->fh); - /* Means no attributes were required to be set. */ - if (!cs->setattr_valid) { - stat = NFS3_OK; - ret = -1; - goto nfs3err; - } - - cs->preparent = *preparent; - cs->postparent = *postparent; - nfs_request_user_init (&nfu, cs->req); - ret = nfs_setattr (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,&cs->stbuf, - cs->setattr_valid, nfs3svc_mknod_setattr_cbk, cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + /* Means no attributes were required to be set. */ + if (!cs->setattr_valid) { + stat = NFS3_OK; + ret = -1; + goto nfs3err; + } + + cs->preparent = *preparent; + cs->postparent = *postparent; + nfs_request_user_init(&nfu, cs->req); + ret = nfs_setattr(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, &cs->stbuf, + cs->setattr_valid, nfs3svc_mknod_setattr_cbk, cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), - NFS3_MKNOD, stat, op_errno, &cs->fh, - cs->resolvedloc.path); - nfs3_mknod_reply (cs->req, stat, &cs->fh, buf, preparent, - postparent); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_newfh_res(rpcsvc_request_xid(cs->req), NFS3_MKNOD, stat, + op_errno, &cs->fh, cs->resolvedloc.path); + nfs3_mknod_reply(cs->req, stat, &cs->fh, buf, preparent, postparent); + nfs3_call_state_wipe(cs); + } - return 0; + return 0; } - static int -nfs3_mknod_device (nfs3_call_state_t *cs) -{ - int ret = -EFAULT; - dev_t devnum = 0; - mode_t mode = 0; - nfs_user_t nfu = {0, }; - - if (!cs) - return ret; - - devnum = makedev (cs->devnums.specdata1, cs->devnums.specdata2); - if (cs->mknodtype == NF3CHR) - mode = S_IFCHR; - else - mode = S_IFBLK; - - nfs_request_user_init (&nfu, cs->req); - if (gf_attr_mode_set (cs->setattr_valid)) { - cs->setattr_valid &= ~GF_SET_ATTR_MODE; - mode |= cs->mode; - ret = nfs_mknod (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - mode, devnum, nfs3svc_mknod_cbk, cs); - } else - ret = nfs_mknod (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - mode, devnum, nfs3svc_mknod_cbk, cs); +nfs3_mknod_device(nfs3_call_state_t *cs) +{ + int ret = -EFAULT; + dev_t devnum = 0; + mode_t mode = 0; + nfs_user_t nfu = { + 0, + }; + if (!cs) return ret; -} + devnum = makedev(cs->devnums.specdata1, cs->devnums.specdata2); + if (cs->mknodtype == NF3CHR) + mode = S_IFCHR; + else + mode = S_IFBLK; + + nfs_request_user_init(&nfu, cs->req); + if (gf_attr_mode_set(cs->setattr_valid)) { + cs->setattr_valid &= ~GF_SET_ATTR_MODE; + mode |= cs->mode; + ret = nfs_mknod(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, mode, devnum, + nfs3svc_mknod_cbk, cs); + } else + ret = nfs_mknod(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, mode, devnum, + nfs3svc_mknod_cbk, cs); + + return ret; +} static int -nfs3_mknod_fifo (nfs3_call_state_t *cs, mode_t mode) +nfs3_mknod_fifo(nfs3_call_state_t *cs, mode_t mode) { - int ret = -EFAULT; - nfs_user_t nfu = {0, }; + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; - if (!cs) - return ret; + if (!cs) + return ret; - nfs_request_user_init (&nfu, cs->req); - if (gf_attr_mode_set (cs->setattr_valid)) { - cs->setattr_valid &= ~GF_SET_ATTR_MODE; - mode |= cs->mode; - ret = nfs_mknod (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - mode, 0, nfs3svc_mknod_cbk, cs); - } else - ret = nfs_mknod (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - mode, 0, nfs3svc_mknod_cbk, cs); + nfs_request_user_init(&nfu, cs->req); + if (gf_attr_mode_set(cs->setattr_valid)) { + cs->setattr_valid &= ~GF_SET_ATTR_MODE; + mode |= cs->mode; + ret = nfs_mknod(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, mode, 0, + nfs3svc_mknod_cbk, cs); + } else + ret = nfs_mknod(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, mode, 0, + nfs3svc_mknod_cbk, cs); - return ret; + return ret; } - static int -nfs3_mknod_resume (void *carg) +nfs3_mknod_resume(void *carg) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs3_call_state_t *cs = NULL; - - if (!carg) - return ret; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs3_call_state_t *cs = NULL; - cs = (nfs3_call_state_t *)carg; - nfs3_check_new_fh_resolve_status (cs, stat, nfs3err); - switch (cs->mknodtype) { + if (!carg) + return ret; + cs = (nfs3_call_state_t *)carg; + nfs3_check_new_fh_resolve_status(cs, stat, nfs3err); + switch (cs->mknodtype) { case NF3CHR: case NF3BLK: - ret = nfs3_mknod_device (cs); - break; + ret = nfs3_mknod_device(cs); + break; case NF3SOCK: - ret = nfs3_mknod_fifo (cs, S_IFSOCK); - break; + ret = nfs3_mknod_fifo(cs, S_IFSOCK); + break; case NF3FIFO: - ret = nfs3_mknod_fifo (cs, S_IFIFO); - break; + ret = nfs3_mknod_fifo(cs, S_IFIFO); + break; default: - ret = -EBADF; - break; - } + ret = -EBADF; + break; + } - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_MKNOD, stat, -ret, - cs->resolvedloc.path); - nfs3_mknod_reply (cs->req, stat, NULL, NULL, NULL, NULL); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_MKNOD, stat, -ret, + cs->resolvedloc.path); + nfs3_mknod_reply(cs->req, stat, NULL, NULL, NULL, NULL); + nfs3_call_state_wipe(cs); + } - return ret; + return ret; } - - int -nfs3_mknod (rpcsvc_request_t *req, struct nfs3_fh *fh, char *name, - mknoddata3 *nodedata) -{ - xlator_t *vol = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - struct nfs3_state *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - sattr3 *sattr = NULL; - - if ((!req) || (!fh) || (!name) || (!nodedata)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Bad arguments"); - return -1; - } - - nfs3_log_mknod_call (rpcsvc_request_xid (req), fh, name, - nodedata->type); - nfs3_validate_gluster_fh (fh, stat, nfs3err); - nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret); - nfs3_validate_strlen_or_goto (name, NFS_NAME_MAX, nfs3err, stat, ret); - nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err); - nfs3_volume_started_check (nfs3, vol, ret, out); - nfs3_check_rw_volaccess (nfs3, fh->exportid, stat, nfs3err); - nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err); - - cs->mknodtype = nodedata->type; - switch (nodedata->type) { +nfs3_mknod(rpcsvc_request_t *req, struct nfs3_fh *fh, char *name, + mknoddata3 *nodedata) +{ + xlator_t *vol = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + struct nfs3_state *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + sattr3 *sattr = NULL; + + if ((!req) || (!fh) || (!name) || (!nodedata)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Bad arguments"); + return -1; + } + + nfs3_log_mknod_call(rpcsvc_request_xid(req), fh, name, nodedata->type); + nfs3_validate_gluster_fh(fh, stat, nfs3err); + nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret); + nfs3_validate_strlen_or_goto(name, NFS_NAME_MAX, nfs3err, stat, ret); + nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err); + nfs3_volume_started_check(nfs3, vol, ret, out); + nfs3_check_rw_volaccess(nfs3, fh->exportid, stat, nfs3err); + nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err); + + cs->mknodtype = nodedata->type; + switch (nodedata->type) { case NF3CHR: case NF3BLK: - cs->devnums = nodedata->mknoddata3_u.device.spec; - sattr = &nodedata->mknoddata3_u.device.dev_attributes; - cs->setattr_valid = nfs3_sattr3_to_setattr_valid (sattr, - &cs->stbuf, - &cs->mode); - break; + cs->devnums = nodedata->mknoddata3_u.device.spec; + sattr = &nodedata->mknoddata3_u.device.dev_attributes; + cs->setattr_valid = nfs3_sattr3_to_setattr_valid(sattr, &cs->stbuf, + &cs->mode); + break; case NF3SOCK: case NF3FIFO: - sattr = &nodedata->mknoddata3_u.pipe_attributes; - cs->setattr_valid = nfs3_sattr3_to_setattr_valid (sattr, - &cs->stbuf, - &cs->mode); - break; + sattr = &nodedata->mknoddata3_u.pipe_attributes; + cs->setattr_valid = nfs3_sattr3_to_setattr_valid(sattr, &cs->stbuf, + &cs->mode); + break; default: - ret = -EBADF; - break; - } + ret = -EBADF; + break; + } - cs->parent = *fh; - ret = nfs3_fh_resolve_and_resume (cs, fh, name, nfs3_mknod_resume); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + cs->parent = *fh; + ret = nfs3_fh_resolve_and_resume(cs, fh, name, nfs3_mknod_resume); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (req), - NFS3_MKNOD, stat, -ret, - cs ? cs->resolvedloc.path : NULL); - nfs3_mknod_reply (req, stat, NULL, NULL, NULL, NULL); - /* Ret must be 0 after this so that the caller does not - * also send an RPC reply. - */ - nfs3_call_state_wipe (cs); - ret = 0; - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_MKNOD, stat, -ret, + cs ? cs->resolvedloc.path : NULL); + nfs3_mknod_reply(req, stat, NULL, NULL, NULL, NULL); + /* Ret must be 0 after this so that the caller does not + * also send an RPC reply. + */ + nfs3_call_state_wipe(cs); + ret = 0; + } out: - return ret; + return ret; } - int -nfs3svc_mknod (rpcsvc_request_t *req) -{ - char name[NFS_PATH_MAX]; - struct nfs3_fh fh = {{0}, }; - mknod3args args; - int ret = RPCSVC_ACTOR_ERROR; - - if (!req) - return ret; - nfs3_prep_mknod3args (&args, &fh, name); - if (xdr_to_mknod3args (req->msg[0], &args) <= 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } +nfs3svc_mknod(rpcsvc_request_t *req) +{ + char name[NFS_PATH_MAX]; + struct nfs3_fh fh = { + {0}, + }; + mknod3args args; + int ret = RPCSVC_ACTOR_ERROR; - ret = nfs3_mknod (req, &fh, name, &args.what); - if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_MKNOD_FAIL, - "MKNOD procedure failed"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = RPCSVC_ACTOR_ERROR; - } + if (!req) + return ret; + nfs3_prep_mknod3args(&args, &fh, name); + if (xdr_to_mknod3args(req->msg[0], &args) <= 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + ret = nfs3_mknod(req, &fh, name, &args.what); + if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_MKNOD_FAIL, + "MKNOD procedure failed"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = RPCSVC_ACTOR_ERROR; + } rpcerr: - return ret; + return ret; } int -nfs3_remove_reply (rpcsvc_request_t *req, nfsstat3 stat, struct iatt *preparent - , struct iatt *postparent) +nfs3_remove_reply(rpcsvc_request_t *req, nfsstat3 stat, struct iatt *preparent, + struct iatt *postparent) { - remove3res res = {0, }; - uint64_t deviceid = 0; + remove3res res = { + 0, + }; + uint64_t deviceid = 0; - deviceid = nfs3_request_xlator_deviceid (req); - nfs3_fill_remove3res (&res, stat, preparent, postparent, deviceid); - nfs3svc_submit_reply (req, (void *)&res, - (nfs3_serializer)xdr_serialize_remove3res); - return 0; + deviceid = nfs3_request_xlator_deviceid(req); + nfs3_fill_remove3res(&res, stat, preparent, postparent, deviceid); + nfs3svc_submit_reply(req, (void *)&res, + (nfs3_serializer)xdr_serialize_remove3res); + return 0; } - - int32_t -nfs3svc_remove_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +nfs3svc_remove_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + nfs3_call_state_t *cs = NULL; - cs = frame->local; - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - } + cs = frame->local; + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + } - if (op_ret == 0) - stat = NFS3_OK; + if (op_ret == 0) + stat = NFS3_OK; - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_REMOVE, stat, op_errno, - cs->resolvedloc.path); - nfs3_remove_reply (cs->req, stat, preparent, postparent); - nfs3_call_state_wipe (cs); + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_REMOVE, stat, + op_errno, cs->resolvedloc.path); + nfs3_remove_reply(cs->req, stat, preparent, postparent); + nfs3_call_state_wipe(cs); - return 0; + return 0; } - int -__nfs3_remove (nfs3_call_state_t *cs) -{ - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - ia_type_t type = 0; - - if (!cs) - return ret; - type = cs->resolvedloc.inode->ia_type; - nfs_request_user_init (&nfu, cs->req); - if (IA_ISDIR (type)) - ret = nfs_rmdir (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - nfs3svc_remove_cbk, cs); - else - ret = nfs_unlink (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - nfs3svc_remove_cbk, cs); +__nfs3_remove(nfs3_call_state_t *cs) +{ + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + ia_type_t type = 0; + if (!cs) return ret; -} + type = cs->resolvedloc.inode->ia_type; + nfs_request_user_init(&nfu, cs->req); + if (IA_ISDIR(type)) + ret = nfs_rmdir(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + nfs3svc_remove_cbk, cs); + else + ret = nfs_unlink(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + nfs3svc_remove_cbk, cs); + return ret; +} int -nfs3_remove_resume (void *carg) +nfs3_remove_resume(void *carg) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs3_call_state_t *cs = NULL; - if (!carg) - return ret; + if (!carg) + return ret; - cs = (nfs3_call_state_t *)carg; - nfs3_check_fh_resolve_status (cs, stat, nfs3err); - ret = __nfs3_remove (cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + cs = (nfs3_call_state_t *)carg; + nfs3_check_fh_resolve_status(cs, stat, nfs3err); + ret = __nfs3_remove(cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_REMOVE, stat, -ret, - cs->resolvedloc.path); - nfs3_remove_reply (cs->req, stat, NULL, NULL); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_REMOVE, stat, + -ret, cs->resolvedloc.path); + nfs3_remove_reply(cs->req, stat, NULL, NULL); + nfs3_call_state_wipe(cs); + } - return ret; + return ret; } - int -nfs3_remove (rpcsvc_request_t *req, struct nfs3_fh *fh, char *name) -{ - xlator_t *vol = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - struct nfs3_state *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - - if ((!req) || (!fh) || (!name)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Bad arguments"); - return -1; - } - - nfs3_log_fh_entry_call (rpcsvc_request_xid (req), "REMOVE", fh, - name); - nfs3_validate_gluster_fh (fh, stat, nfs3err); - nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret); - nfs3_validate_strlen_or_goto (name, NFS_NAME_MAX, nfs3err, stat, ret); - nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err); - nfs3_volume_started_check (nfs3, vol, ret, out); - nfs3_check_rw_volaccess (nfs3, fh->exportid, stat, nfs3err); - nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err); - - ret = nfs3_fh_resolve_and_resume (cs, fh, name, nfs3_remove_resume); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); +nfs3_remove(rpcsvc_request_t *req, struct nfs3_fh *fh, char *name) +{ + xlator_t *vol = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + struct nfs3_state *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + + if ((!req) || (!fh) || (!name)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Bad arguments"); + return -1; + } + + nfs3_log_fh_entry_call(rpcsvc_request_xid(req), "REMOVE", fh, name); + nfs3_validate_gluster_fh(fh, stat, nfs3err); + nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret); + nfs3_validate_strlen_or_goto(name, NFS_NAME_MAX, nfs3err, stat, ret); + nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err); + nfs3_volume_started_check(nfs3, vol, ret, out); + nfs3_check_rw_volaccess(nfs3, fh->exportid, stat, nfs3err); + nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err); + + ret = nfs3_fh_resolve_and_resume(cs, fh, name, nfs3_remove_resume); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (req), - NFS3_REMOVE, stat, -ret, - cs ? cs->resolvedloc.path : NULL); - nfs3_remove_reply (req, stat, NULL, NULL); - nfs3_call_state_wipe (cs); - /* Ret must be 0 after this so that the caller does not - * also send an RPC reply. - */ - ret = 0; - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_REMOVE, stat, -ret, + cs ? cs->resolvedloc.path : NULL); + nfs3_remove_reply(req, stat, NULL, NULL); + nfs3_call_state_wipe(cs); + /* Ret must be 0 after this so that the caller does not + * also send an RPC reply. + */ + ret = 0; + } out: - return ret; + return ret; } - int -nfs3svc_remove (rpcsvc_request_t *req) -{ - char name[NFS_PATH_MAX]; - struct nfs3_fh fh = {{0}, }; - remove3args args; - int ret = RPCSVC_ACTOR_ERROR; - - if (!req) - return ret; - nfs3_prep_remove3args (&args, &fh, name); - if (xdr_to_remove3args (req->msg[0], &args) <= 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } +nfs3svc_remove(rpcsvc_request_t *req) +{ + char name[NFS_PATH_MAX]; + struct nfs3_fh fh = { + {0}, + }; + remove3args args; + int ret = RPCSVC_ACTOR_ERROR; - ret = nfs3_remove (req, &fh, name); - if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_REMOVE_FAIL, - "REMOVE procedure failed"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = RPCSVC_ACTOR_ERROR; - } + if (!req) + return ret; + nfs3_prep_remove3args(&args, &fh, name); + if (xdr_to_remove3args(req->msg[0], &args) <= 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + ret = nfs3_remove(req, &fh, name); + if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_REMOVE_FAIL, + "REMOVE procedure failed"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = RPCSVC_ACTOR_ERROR; + } rpcerr: - return ret; + return ret; } - int -nfs3_rmdir_reply (rpcsvc_request_t *req, nfsstat3 stat, struct iatt *preparent, - struct iatt *postparent) +nfs3_rmdir_reply(rpcsvc_request_t *req, nfsstat3 stat, struct iatt *preparent, + struct iatt *postparent) { - rmdir3res res = {0, }; - uint64_t deviceid = 0; + rmdir3res res = { + 0, + }; + uint64_t deviceid = 0; - deviceid = nfs3_request_xlator_deviceid (req); - nfs3_fill_rmdir3res (&res, stat, preparent, postparent, deviceid); - nfs3svc_submit_reply (req, (void *)&res, - (nfs3_serializer)xdr_serialize_rmdir3res); - return 0; + deviceid = nfs3_request_xlator_deviceid(req); + nfs3_fill_rmdir3res(&res, stat, preparent, postparent, deviceid); + nfs3svc_submit_reply(req, (void *)&res, + (nfs3_serializer)xdr_serialize_rmdir3res); + return 0; } - int32_t -nfs3svc_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +nfs3svc_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + nfs3_call_state_t *cs = NULL; - cs = frame->local; - if (op_ret == -1) { - gf_msg (GF_NFS, GF_LOG_WARNING, op_errno, NFS_MSG_RMDIR_CBK, - "%x: %s => -1 (%s)", rpcsvc_request_xid (cs->req), - cs->resolvedloc.path, strerror (op_errno)); - stat = nfs3_cbk_errno_status (op_ret, op_errno); - } else { - stat = NFS3_OK; - } + cs = frame->local; + if (op_ret == -1) { + gf_msg(GF_NFS, GF_LOG_WARNING, op_errno, NFS_MSG_RMDIR_CBK, + "%x: %s => -1 (%s)", rpcsvc_request_xid(cs->req), + cs->resolvedloc.path, strerror(op_errno)); + stat = nfs3_cbk_errno_status(op_ret, op_errno); + } else { + stat = NFS3_OK; + } - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_RMDIR, stat, op_errno, - cs->resolvedloc.path); - nfs3_rmdir_reply (cs->req, stat, preparent, postparent); - nfs3_call_state_wipe (cs); + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_RMDIR, stat, op_errno, + cs->resolvedloc.path); + nfs3_rmdir_reply(cs->req, stat, preparent, postparent); + nfs3_call_state_wipe(cs); - return 0; + return 0; } int -nfs3_rmdir_resume (void *carg) +nfs3_rmdir_resume(void *carg) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs3_call_state_t *cs = NULL; - nfs_user_t nfu = {0, }; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs3_call_state_t *cs = NULL; + nfs_user_t nfu = { + 0, + }; - if (!carg) - return ret; + if (!carg) + return ret; - cs = (nfs3_call_state_t *)carg; - nfs3_check_fh_resolve_status (cs, stat, nfs3err); - nfs_request_user_init (&nfu, cs->req); - ret = nfs_rmdir (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - nfs3svc_rmdir_cbk, cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + cs = (nfs3_call_state_t *)carg; + nfs3_check_fh_resolve_status(cs, stat, nfs3err); + nfs_request_user_init(&nfu, cs->req); + ret = nfs_rmdir(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + nfs3svc_rmdir_cbk, cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_RMDIR, stat, -ret, - cs->resolvedloc.path); - nfs3_rmdir_reply (cs->req, stat, NULL, NULL); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_RMDIR, stat, -ret, + cs->resolvedloc.path); + nfs3_rmdir_reply(cs->req, stat, NULL, NULL); + nfs3_call_state_wipe(cs); + } - return ret; + return ret; } - - int -nfs3_rmdir (rpcsvc_request_t *req, struct nfs3_fh *fh, char *name) -{ - xlator_t *vol = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - struct nfs3_state *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - - if ((!req) || (!fh) || (!name)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Bad arguments"); - return -1; - } - - nfs3_log_fh_entry_call (rpcsvc_request_xid (req), "RMDIR", fh, - name); - nfs3_validate_gluster_fh (fh, stat, nfs3err); - nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret); - nfs3_validate_strlen_or_goto (name, NFS_NAME_MAX, nfs3err, stat, ret); - nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err); - nfs3_volume_started_check (nfs3, vol, ret, out); - nfs3_check_rw_volaccess (nfs3, fh->exportid, stat, nfs3err); - nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err); - - ret = nfs3_fh_resolve_and_resume (cs, fh, name, nfs3_rmdir_resume); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); +nfs3_rmdir(rpcsvc_request_t *req, struct nfs3_fh *fh, char *name) +{ + xlator_t *vol = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + struct nfs3_state *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + + if ((!req) || (!fh) || (!name)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Bad arguments"); + return -1; + } + + nfs3_log_fh_entry_call(rpcsvc_request_xid(req), "RMDIR", fh, name); + nfs3_validate_gluster_fh(fh, stat, nfs3err); + nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret); + nfs3_validate_strlen_or_goto(name, NFS_NAME_MAX, nfs3err, stat, ret); + nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err); + nfs3_volume_started_check(nfs3, vol, ret, out); + nfs3_check_rw_volaccess(nfs3, fh->exportid, stat, nfs3err); + nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err); + + ret = nfs3_fh_resolve_and_resume(cs, fh, name, nfs3_rmdir_resume); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (req), - NFS3_RMDIR, stat, -ret, - cs ? cs->resolvedloc.path : NULL); - nfs3_rmdir_reply (req, stat, NULL, NULL); - nfs3_call_state_wipe (cs); - /* Ret must be 0 after this so that the caller does not - * also send an RPC reply. - */ - ret = 0; - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_RMDIR, stat, -ret, + cs ? cs->resolvedloc.path : NULL); + nfs3_rmdir_reply(req, stat, NULL, NULL); + nfs3_call_state_wipe(cs); + /* Ret must be 0 after this so that the caller does not + * also send an RPC reply. + */ + ret = 0; + } out: - return ret; + return ret; } - int -nfs3svc_rmdir (rpcsvc_request_t *req) -{ - char name[NFS_PATH_MAX]; - struct nfs3_fh fh = {{0}, }; - rmdir3args args; - int ret = RPCSVC_ACTOR_ERROR; - - if (!req) - return ret; - nfs3_prep_rmdir3args (&args, &fh, name); - if (xdr_to_rmdir3args (req->msg[0], &args) <= 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } +nfs3svc_rmdir(rpcsvc_request_t *req) +{ + char name[NFS_PATH_MAX]; + struct nfs3_fh fh = { + {0}, + }; + rmdir3args args; + int ret = RPCSVC_ACTOR_ERROR; - ret = nfs3_rmdir (req, &fh, name); - if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_DIR_OP_FAIL, - "RMDIR procedure failed"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = RPCSVC_ACTOR_ERROR; - } + if (!req) + return ret; + nfs3_prep_rmdir3args(&args, &fh, name); + if (xdr_to_rmdir3args(req->msg[0], &args) <= 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + ret = nfs3_rmdir(req, &fh, name); + if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_DIR_OP_FAIL, + "RMDIR procedure failed"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = RPCSVC_ACTOR_ERROR; + } rpcerr: - return ret; + return ret; } - int -nfs3_rename_reply (rpcsvc_request_t *req, nfsstat3 stat, struct iatt *buf, - struct iatt *preoldparent, struct iatt *postoldparent, - struct iatt *prenewparent, struct iatt *postnewparent) +nfs3_rename_reply(rpcsvc_request_t *req, nfsstat3 stat, struct iatt *buf, + struct iatt *preoldparent, struct iatt *postoldparent, + struct iatt *prenewparent, struct iatt *postnewparent) { - rename3res res = {0, }; - uint64_t deviceid = 0; + rename3res res = { + 0, + }; + uint64_t deviceid = 0; - deviceid = nfs3_request_xlator_deviceid (req); - nfs3_fill_rename3res (&res, stat, buf, preoldparent, postoldparent, - prenewparent, postnewparent, deviceid); + deviceid = nfs3_request_xlator_deviceid(req); + nfs3_fill_rename3res(&res, stat, buf, preoldparent, postoldparent, + prenewparent, postnewparent, deviceid); - nfs3svc_submit_reply (req, (void *)&res, - (nfs3_serializer) xdr_serialize_rename3res); + nfs3svc_submit_reply(req, (void *)&res, + (nfs3_serializer)xdr_serialize_rename3res); - return 0; + return 0; } - - int32_t -nfs3svc_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, - struct iatt *preoldparent, struct iatt *postoldparent, - struct iatt *prenewparent, struct iatt *postnewparent, - dict_t *xdata) +nfs3svc_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *buf, + struct iatt *preoldparent, struct iatt *postoldparent, + struct iatt *prenewparent, struct iatt *postnewparent, + dict_t *xdata) { - int ret = -EFAULT; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - nfs3_call_state_t *cs = NULL; + int ret = -EFAULT; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + nfs3_call_state_t *cs = NULL; - cs = frame->local; - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - goto nfs3err; - } + cs = frame->local; + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + goto nfs3err; + } - stat = NFS3_OK; + stat = NFS3_OK; nfs3err: - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_RENAME, stat, - -ret, cs->resolvedloc.path); - nfs3_rename_reply (cs->req, stat, buf, preoldparent, postoldparent, - prenewparent, postnewparent); - nfs3_call_state_wipe (cs); - return 0; + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_RENAME, stat, -ret, + cs->resolvedloc.path); + nfs3_rename_reply(cs->req, stat, buf, preoldparent, postoldparent, + prenewparent, postnewparent); + nfs3_call_state_wipe(cs); + return 0; } - int -nfs3_rename_resume_dst (void *carg) -{ - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs3_call_state_t *cs = NULL; - nfs_user_t nfu = {0, }; - - if (!carg) - return ret; - - cs = (nfs3_call_state_t *)carg; - nfs3_check_new_fh_resolve_status (cs, stat, nfs3err); - cs->parent = cs->resolvefh; - nfs_request_user_init (&nfu, cs->req); - ret = nfs_rename (cs->nfsx, cs->vol, &nfu, &cs->oploc, &cs->resolvedloc, - nfs3svc_rename_cbk, cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); - -nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_RENAME, stat, -ret, - cs->resolvedloc.path); - nfs3_rename_reply (cs->req, stat, NULL, NULL, NULL, NULL, NULL); - nfs3_call_state_wipe (cs); - } +nfs3_rename_resume_dst(void *carg) +{ + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs3_call_state_t *cs = NULL; + nfs_user_t nfu = { + 0, + }; + if (!carg) return ret; -} + cs = (nfs3_call_state_t *)carg; + nfs3_check_new_fh_resolve_status(cs, stat, nfs3err); + cs->parent = cs->resolvefh; + nfs_request_user_init(&nfu, cs->req); + ret = nfs_rename(cs->nfsx, cs->vol, &nfu, &cs->oploc, &cs->resolvedloc, + nfs3svc_rename_cbk, cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); +nfs3err: + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_RENAME, stat, + -ret, cs->resolvedloc.path); + nfs3_rename_reply(cs->req, stat, NULL, NULL, NULL, NULL, NULL); + nfs3_call_state_wipe(cs); + } + + return ret; +} int -nfs3_rename_resume_src (void *carg) +nfs3_rename_resume_src(void *carg) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs3_call_state_t *cs = NULL; - if (!carg) - return ret; + if (!carg) + return ret; - cs = (nfs3_call_state_t *)carg; - nfs3_check_fh_resolve_status (cs, stat, nfs3err); - /* Copy the resolved loc for the source file into another loc - * for safekeeping till we resolve the dest loc. - */ - nfs_loc_copy (&cs->oploc, &cs->resolvedloc); - nfs_loc_wipe (&cs->resolvedloc); - GF_FREE (cs->resolventry); + cs = (nfs3_call_state_t *)carg; + nfs3_check_fh_resolve_status(cs, stat, nfs3err); + /* Copy the resolved loc for the source file into another loc + * for safekeeping till we resolve the dest loc. + */ + nfs_loc_copy(&cs->oploc, &cs->resolvedloc); + nfs_loc_wipe(&cs->resolvedloc); + GF_FREE(cs->resolventry); - ret = nfs3_fh_resolve_and_resume (cs, &cs->fh, cs->pathname, - nfs3_rename_resume_dst); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + ret = nfs3_fh_resolve_and_resume(cs, &cs->fh, cs->pathname, + nfs3_rename_resume_dst); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_RENAME, stat, -ret, - cs->resolvedloc.path); - nfs3_rename_reply (cs->req, stat, NULL, NULL, NULL, NULL, NULL); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_RENAME, stat, + -ret, cs->resolvedloc.path); + nfs3_rename_reply(cs->req, stat, NULL, NULL, NULL, NULL, NULL); + nfs3_call_state_wipe(cs); + } - return ret; + return ret; } - int -nfs3_rename (rpcsvc_request_t *req, struct nfs3_fh *olddirfh, char *oldname, - struct nfs3_fh *newdirfh, char *newname) -{ - xlator_t *vol = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - struct nfs3_state *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - - if ((!req) || (!olddirfh) || (!oldname) || (!newdirfh) || (!newname)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Bad arguments"); - return -1; - } - - nfs3_log_rename_call (rpcsvc_request_xid (req), olddirfh, oldname, - newdirfh, newname); - nfs3_validate_gluster_fh (olddirfh, stat, nfs3err); - nfs3_validate_gluster_fh (newdirfh, stat, nfs3err); - nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret); - nfs3_validate_strlen_or_goto(oldname, NFS_NAME_MAX, nfs3err, stat, ret); - nfs3_validate_strlen_or_goto(newname, NFS_NAME_MAX, nfs3err, stat, ret); - nfs3_map_fh_to_volume (nfs3, olddirfh, req, vol, stat, nfs3err); - nfs3_volume_started_check (nfs3, vol, ret, out); - nfs3_check_rw_volaccess (nfs3, olddirfh->exportid, stat, nfs3err); - nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err); - - /* While we resolve the source (fh, name) pair, we need to keep a copy - * of the dest (fh,name) pair. - */ - cs->fh = *newdirfh; - cs->pathname = gf_strdup (newname); - if (!cs->pathname) { - stat = NFS3ERR_SERVERFAULT; - ret = -1; - goto nfs3err; - } - - ret = nfs3_fh_resolve_and_resume (cs, olddirfh, oldname, - nfs3_rename_resume_src); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); +nfs3_rename(rpcsvc_request_t *req, struct nfs3_fh *olddirfh, char *oldname, + struct nfs3_fh *newdirfh, char *newname) +{ + xlator_t *vol = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + struct nfs3_state *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + + if ((!req) || (!olddirfh) || (!oldname) || (!newdirfh) || (!newname)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Bad arguments"); + return -1; + } + + nfs3_log_rename_call(rpcsvc_request_xid(req), olddirfh, oldname, newdirfh, + newname); + nfs3_validate_gluster_fh(olddirfh, stat, nfs3err); + nfs3_validate_gluster_fh(newdirfh, stat, nfs3err); + nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret); + nfs3_validate_strlen_or_goto(oldname, NFS_NAME_MAX, nfs3err, stat, ret); + nfs3_validate_strlen_or_goto(newname, NFS_NAME_MAX, nfs3err, stat, ret); + nfs3_map_fh_to_volume(nfs3, olddirfh, req, vol, stat, nfs3err); + nfs3_volume_started_check(nfs3, vol, ret, out); + nfs3_check_rw_volaccess(nfs3, olddirfh->exportid, stat, nfs3err); + nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err); + + /* While we resolve the source (fh, name) pair, we need to keep a copy + * of the dest (fh,name) pair. + */ + cs->fh = *newdirfh; + cs->pathname = gf_strdup(newname); + if (!cs->pathname) { + stat = NFS3ERR_SERVERFAULT; + ret = -1; + goto nfs3err; + } + + ret = nfs3_fh_resolve_and_resume(cs, olddirfh, oldname, + nfs3_rename_resume_src); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (req), - NFS3_RENAME, stat, -ret, - cs ? cs->resolvedloc.path : NULL); - nfs3_rename_reply (req, stat, NULL, NULL, NULL, NULL, NULL); - nfs3_call_state_wipe (cs); - /* Ret must be 0 after this so that the caller does not - * also send an RPC reply. - */ - ret = 0; - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_RENAME, stat, -ret, + cs ? cs->resolvedloc.path : NULL); + nfs3_rename_reply(req, stat, NULL, NULL, NULL, NULL, NULL); + nfs3_call_state_wipe(cs); + /* Ret must be 0 after this so that the caller does not + * also send an RPC reply. + */ + ret = 0; + } out: - return ret; + return ret; } - int -nfs3svc_rename (rpcsvc_request_t *req) -{ - char newname[NFS_PATH_MAX]; - char oldname[NFS_PATH_MAX]; - struct nfs3_fh olddirfh = {{0}, }; - struct nfs3_fh newdirfh = {{0}, }; - rename3args args; - int ret = RPCSVC_ACTOR_ERROR; - - if (!req) - return ret; - nfs3_prep_rename3args (&args, &olddirfh, oldname, &newdirfh, newname); - if (xdr_to_rename3args (req->msg[0], &args) <= 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } - - ret = nfs3_rename (req, &olddirfh, oldname, &newdirfh, newname); - if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_RENAME_FAIL, - "RENAME procedure failed"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = RPCSVC_ACTOR_ERROR; - } +nfs3svc_rename(rpcsvc_request_t *req) +{ + char newname[NFS_PATH_MAX]; + char oldname[NFS_PATH_MAX]; + struct nfs3_fh olddirfh = { + {0}, + }; + struct nfs3_fh newdirfh = { + {0}, + }; + rename3args args; + int ret = RPCSVC_ACTOR_ERROR; + + if (!req) + return ret; + nfs3_prep_rename3args(&args, &olddirfh, oldname, &newdirfh, newname); + if (xdr_to_rename3args(req->msg[0], &args) <= 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + ret = nfs3_rename(req, &olddirfh, oldname, &newdirfh, newname); + if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_RENAME_FAIL, + "RENAME procedure failed"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = RPCSVC_ACTOR_ERROR; + } rpcerr: - return ret; + return ret; } - int -nfs3_link_reply (rpcsvc_request_t *req, nfsstat3 stat, struct iatt *buf, - struct iatt *preparent, struct iatt *postparent) +nfs3_link_reply(rpcsvc_request_t *req, nfsstat3 stat, struct iatt *buf, + struct iatt *preparent, struct iatt *postparent) { - link3res res = {0, }; - uint64_t deviceid = 0; + link3res res = { + 0, + }; + uint64_t deviceid = 0; - deviceid = nfs3_request_xlator_deviceid (req); - nfs3_fill_link3res (&res, stat, buf, preparent, postparent, deviceid); - nfs3svc_submit_reply (req, (void *)&res, - (nfs3_serializer)xdr_serialize_link3res); + deviceid = nfs3_request_xlator_deviceid(req); + nfs3_fill_link3res(&res, stat, buf, preparent, postparent, deviceid); + nfs3svc_submit_reply(req, (void *)&res, + (nfs3_serializer)xdr_serialize_link3res); - return 0; + return 0; } - int32_t -nfs3svc_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) -{ - nfsstat3 stat = NFS3ERR_SERVERFAULT; - nfs3_call_state_t *cs = NULL; - - cs = frame->local; - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - } else - stat = NFS3_OK; +nfs3svc_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) +{ + nfsstat3 stat = NFS3ERR_SERVERFAULT; + nfs3_call_state_t *cs = NULL; + + cs = frame->local; + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + } else + stat = NFS3_OK; - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_LINK, stat, op_errno, - cs->resolvedloc.path); - nfs3_link_reply (cs->req, stat, buf, preparent, postparent); - nfs3_call_state_wipe (cs); + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_LINK, stat, op_errno, + cs->resolvedloc.path); + nfs3_link_reply(cs->req, stat, buf, preparent, postparent); + nfs3_call_state_wipe(cs); - return 0; + return 0; } - int -nfs3_link_resume_lnk (void *carg) +nfs3_link_resume_lnk(void *carg) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs3_call_state_t *cs = NULL; - nfs_user_t nfu = {0, }; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs3_call_state_t *cs = NULL; + nfs_user_t nfu = { + 0, + }; - if (!carg) - return ret; + if (!carg) + return ret; - cs = (nfs3_call_state_t *)carg; - nfs3_check_new_fh_resolve_status (cs, stat, nfs3err); + cs = (nfs3_call_state_t *)carg; + nfs3_check_new_fh_resolve_status(cs, stat, nfs3err); - nfs_request_user_init (&nfu, cs->req); - ret = nfs_link (cs->nfsx, cs->vol, &nfu, &cs->oploc, &cs->resolvedloc, - nfs3svc_link_cbk, cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + nfs_request_user_init(&nfu, cs->req); + ret = nfs_link(cs->nfsx, cs->vol, &nfu, &cs->oploc, &cs->resolvedloc, + nfs3svc_link_cbk, cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_LINK, stat, -ret, - cs->resolvedloc.path); - nfs3_link_reply (cs->req, stat, NULL, NULL, NULL); - nfs3_call_state_wipe (cs); - } - return ret; + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_LINK, stat, -ret, + cs->resolvedloc.path); + nfs3_link_reply(cs->req, stat, NULL, NULL, NULL); + nfs3_call_state_wipe(cs); + } + return ret; } - int -nfs3_link_resume_tgt (void *carg) +nfs3_link_resume_tgt(void *carg) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs3_call_state_t *cs = NULL; - if (!carg) - return ret; + if (!carg) + return ret; - cs = (nfs3_call_state_t *)carg; - nfs3_check_fh_resolve_status (cs, stat, nfs3err); - nfs_loc_copy (&cs->oploc, &cs->resolvedloc); - nfs_loc_wipe (&cs->resolvedloc); + cs = (nfs3_call_state_t *)carg; + nfs3_check_fh_resolve_status(cs, stat, nfs3err); + nfs_loc_copy(&cs->oploc, &cs->resolvedloc); + nfs_loc_wipe(&cs->resolvedloc); - ret = nfs3_fh_resolve_and_resume (cs, &cs->fh, cs->pathname, - nfs3_link_resume_lnk); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + ret = nfs3_fh_resolve_and_resume(cs, &cs->fh, cs->pathname, + nfs3_link_resume_lnk); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_LINK, stat, -ret, - cs->resolvedloc.path); - nfs3_link_reply (cs->req, stat, NULL, NULL, NULL); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_LINK, stat, -ret, + cs->resolvedloc.path); + nfs3_link_reply(cs->req, stat, NULL, NULL, NULL); + nfs3_call_state_wipe(cs); + } - return ret; + return ret; } - int -nfs3_link (rpcsvc_request_t *req, struct nfs3_fh *targetfh, - struct nfs3_fh *dirfh, char *newname) -{ - xlator_t *vol = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - struct nfs3_state *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - - if ((!req) || (!targetfh) || (!dirfh) || (!newname)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Bad arguments"); - return -1; - } - - nfs3_validate_gluster_fh (dirfh, stat, nfs3err); - nfs3_validate_gluster_fh (targetfh, stat, nfs3err); - nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret); - nfs3_validate_strlen_or_goto(newname, NFS_NAME_MAX, nfs3err, stat, ret); - nfs3_map_fh_to_volume (nfs3, dirfh, req, vol, stat, nfs3err); - nfs3_volume_started_check (nfs3, vol, ret, out); - nfs3_check_rw_volaccess (nfs3, dirfh->exportid, stat, nfs3err); - nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err); - - cs->fh = *dirfh; - cs->pathname = gf_strdup (newname); - if (!cs->pathname) { - stat = NFS3ERR_SERVERFAULT; - ret = -1; - goto nfs3err; - } - - ret = nfs3_fh_resolve_and_resume (cs, targetfh, NULL, - nfs3_link_resume_tgt); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); +nfs3_link(rpcsvc_request_t *req, struct nfs3_fh *targetfh, + struct nfs3_fh *dirfh, char *newname) +{ + xlator_t *vol = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + struct nfs3_state *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + + if ((!req) || (!targetfh) || (!dirfh) || (!newname)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Bad arguments"); + return -1; + } + + nfs3_validate_gluster_fh(dirfh, stat, nfs3err); + nfs3_validate_gluster_fh(targetfh, stat, nfs3err); + nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret); + nfs3_validate_strlen_or_goto(newname, NFS_NAME_MAX, nfs3err, stat, ret); + nfs3_map_fh_to_volume(nfs3, dirfh, req, vol, stat, nfs3err); + nfs3_volume_started_check(nfs3, vol, ret, out); + nfs3_check_rw_volaccess(nfs3, dirfh->exportid, stat, nfs3err); + nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err); + + cs->fh = *dirfh; + cs->pathname = gf_strdup(newname); + if (!cs->pathname) { + stat = NFS3ERR_SERVERFAULT; + ret = -1; + goto nfs3err; + } + + ret = nfs3_fh_resolve_and_resume(cs, targetfh, NULL, nfs3_link_resume_tgt); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (req), - NFS3_LINK, stat, - -ret, cs ? cs->pathname : NULL); - nfs3_link_reply (req, stat, NULL, NULL, NULL); - nfs3_call_state_wipe (cs); - /* Ret must be 0 after this so that the caller does not - * also send an RPC reply. - */ - ret = 0; - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_LINK, stat, -ret, + cs ? cs->pathname : NULL); + nfs3_link_reply(req, stat, NULL, NULL, NULL); + nfs3_call_state_wipe(cs); + /* Ret must be 0 after this so that the caller does not + * also send an RPC reply. + */ + ret = 0; + } out: - return ret; + return ret; } int -nfs3svc_link (rpcsvc_request_t *req) -{ - char newpath[NFS_PATH_MAX]; - struct nfs3_fh dirfh = {{0}, }; - struct nfs3_fh targetfh = {{0}, }; - link3args args; - int ret = RPCSVC_ACTOR_ERROR; - - if (!req) - return ret; - nfs3_prep_link3args (&args, &targetfh, &dirfh, newpath); - if (xdr_to_link3args (req->msg[0], &args) <= 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } - - ret = nfs3_link (req, &targetfh, &dirfh, newpath); - if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, EXDEV, NFS_MSG_LINK_FAIL, - "LINK procedure failed"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = RPCSVC_ACTOR_ERROR; - } +nfs3svc_link(rpcsvc_request_t *req) +{ + char newpath[NFS_PATH_MAX]; + struct nfs3_fh dirfh = { + {0}, + }; + struct nfs3_fh targetfh = { + {0}, + }; + link3args args; + int ret = RPCSVC_ACTOR_ERROR; + + if (!req) + return ret; + nfs3_prep_link3args(&args, &targetfh, &dirfh, newpath); + if (xdr_to_link3args(req->msg[0], &args) <= 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + ret = nfs3_link(req, &targetfh, &dirfh, newpath); + if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, EXDEV, NFS_MSG_LINK_FAIL, + "LINK procedure failed"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = RPCSVC_ACTOR_ERROR; + } rpcerr: - return ret; + return ret; } - int -nfs3_readdirp_reply (rpcsvc_request_t *req, nfsstat3 stat,struct nfs3_fh *dirfh, - uint64_t cverf, struct iatt *dirstat, gf_dirent_t *entries, - count3 dircount, count3 maxcount, int is_eof) +nfs3_readdirp_reply(rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *dirfh, + uint64_t cverf, struct iatt *dirstat, gf_dirent_t *entries, + count3 dircount, count3 maxcount, int is_eof) { - readdirp3res res = {0, }; - uint64_t deviceid = 0; + readdirp3res res = { + 0, + }; + uint64_t deviceid = 0; - deviceid = nfs3_request_xlator_deviceid (req); - nfs3_fill_readdirp3res (&res, stat, dirfh, cverf, dirstat, entries, - dircount, maxcount, is_eof, deviceid); - nfs3svc_submit_reply (req, (void *)&res, - (nfs3_serializer) xdr_serialize_readdirp3res); - nfs3_free_readdirp3res (&res); + deviceid = nfs3_request_xlator_deviceid(req); + nfs3_fill_readdirp3res(&res, stat, dirfh, cverf, dirstat, entries, dircount, + maxcount, is_eof, deviceid); + nfs3svc_submit_reply(req, (void *)&res, + (nfs3_serializer)xdr_serialize_readdirp3res); + nfs3_free_readdirp3res(&res); - return 0; + return 0; } - int -nfs3_readdir_reply (rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *dirfh, - uint64_t cverf, struct iatt *dirstat, gf_dirent_t *entries, - count3 count, int is_eof) +nfs3_readdir_reply(rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *dirfh, + uint64_t cverf, struct iatt *dirstat, gf_dirent_t *entries, + count3 count, int is_eof) { - readdir3res res = {0, }; - uint64_t deviceid = 0; + readdir3res res = { + 0, + }; + uint64_t deviceid = 0; - deviceid = nfs3_request_xlator_deviceid (req); - nfs3_fill_readdir3res (&res, stat, dirfh, cverf, dirstat, entries, count - , is_eof, deviceid); - nfs3svc_submit_reply (req, (void *)&res, - (nfs3_serializer) xdr_serialize_readdir3res); - nfs3_free_readdir3res (&res); + deviceid = nfs3_request_xlator_deviceid(req); + nfs3_fill_readdir3res(&res, stat, dirfh, cverf, dirstat, entries, count, + is_eof, deviceid); + nfs3svc_submit_reply(req, (void *)&res, + (nfs3_serializer)xdr_serialize_readdir3res); + nfs3_free_readdir3res(&res); - return 0; + return 0; } - int32_t -nfs3svc_readdir_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, - dict_t *xdata) -{ - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int is_eof = 0; - nfs3_call_state_t *cs = NULL; - - cs = frame->local; - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - goto nfs3err; - } +nfs3svc_readdir_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *buf, + dict_t *xdata) +{ + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int is_eof = 0; + nfs3_call_state_t *cs = NULL; - /* Check whether we encountered a end of directory stream while - * readdir'ing. - */ - if (cs->operrno == ENOENT) { - gf_msg_trace (GF_NFS3, 0, "Reached end-of-directory"); - is_eof = 1; - } + cs = frame->local; + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + goto nfs3err; + } - stat = NFS3_OK; + /* Check whether we encountered a end of directory stream while + * readdir'ing. + */ + if (cs->operrno == ENOENT) { + gf_msg_trace(GF_NFS3, 0, "Reached end-of-directory"); + is_eof = 1; + } - /* do inode linking here */ - gf_link_inodes_from_dirent (this, cs->fd->inode, &cs->entries); + stat = NFS3_OK; + + /* do inode linking here */ + gf_link_inodes_from_dirent(this, cs->fd->inode, &cs->entries); nfs3err: - if (cs->maxcount == 0) { - nfs3_log_readdir_res (rpcsvc_request_xid (cs->req), - stat, op_errno, (uintptr_t)cs->fd, - cs->dircount, is_eof, - cs->resolvedloc.path); - nfs3_readdir_reply (cs->req, stat, &cs->parent, - (uintptr_t)cs->fd, buf, &cs->entries, - cs->dircount, is_eof); - } else { - nfs3_log_readdirp_res (rpcsvc_request_xid (cs->req), - stat, op_errno, (uintptr_t)cs->fd, - cs->dircount, cs->maxcount, is_eof, - cs->resolvedloc.path); - nfs3_readdirp_reply (cs->req, stat, &cs->parent, - (uintptr_t)cs->fd, buf, - &cs->entries, cs->dircount, - cs->maxcount, is_eof); - } + if (cs->maxcount == 0) { + nfs3_log_readdir_res(rpcsvc_request_xid(cs->req), stat, op_errno, + (uintptr_t)cs->fd, cs->dircount, is_eof, + cs->resolvedloc.path); + nfs3_readdir_reply(cs->req, stat, &cs->parent, (uintptr_t)cs->fd, buf, + &cs->entries, cs->dircount, is_eof); + } else { + nfs3_log_readdirp_res(rpcsvc_request_xid(cs->req), stat, op_errno, + (uintptr_t)cs->fd, cs->dircount, cs->maxcount, + is_eof, cs->resolvedloc.path); + nfs3_readdirp_reply(cs->req, stat, &cs->parent, (uintptr_t)cs->fd, buf, + &cs->entries, cs->dircount, cs->maxcount, is_eof); + } - if (is_eof) { - /* do nothing */ - } + if (is_eof) { + /* do nothing */ + } - nfs3_call_state_wipe (cs); - return 0; + nfs3_call_state_wipe(cs); + return 0; } - int32_t -nfs3svc_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, - dict_t *xdata) +nfs3svc_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, + dict_t *xdata) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - nfs3_call_state_t *cs = NULL; - - cs = frame->local; - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - goto err; - } - - cs->operrno = op_errno; - list_splice_init (&entries->list, &cs->entries.list); - nfs_request_user_init (&nfu, cs->req); - ret = nfs_fstat (cs->nfsx, cs->vol, &nfu, cs->fd, - nfs3svc_readdir_fstat_cbk, cs); - if (ret < 0) { - op_ret = -1; - stat = nfs3_errno_to_nfsstat3 (-ret); - op_errno = -ret; - } + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + nfs3_call_state_t *cs = NULL; + + cs = frame->local; + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + goto err; + } + + cs->operrno = op_errno; + list_splice_init(&entries->list, &cs->entries.list); + nfs_request_user_init(&nfu, cs->req); + ret = nfs_fstat(cs->nfsx, cs->vol, &nfu, cs->fd, nfs3svc_readdir_fstat_cbk, + cs); + if (ret < 0) { + op_ret = -1; + stat = nfs3_errno_to_nfsstat3(-ret); + op_errno = -ret; + } err: - if (op_ret >= 0) - goto ret; - - if (cs->maxcount == 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_READDIR, stat, op_errno, - cs->resolvedloc.path); - nfs3_readdir_reply (cs->req, stat, NULL, 0, NULL, NULL, 0, 0); - } else { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_READDIRP, stat, op_errno, - cs->resolvedloc.path); - nfs3_readdirp_reply (cs->req, stat, NULL, 0, NULL, NULL, - 0, 0, 0); - } - - /* For directories, we force a purge from the fd cache on close - * so that next time the dir is read, we'll get any changed directory - * entries. - */ - nfs3_call_state_wipe (cs); + if (op_ret >= 0) + goto ret; + + if (cs->maxcount == 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_READDIR, stat, + op_errno, cs->resolvedloc.path); + nfs3_readdir_reply(cs->req, stat, NULL, 0, NULL, NULL, 0, 0); + } else { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_READDIRP, stat, + op_errno, cs->resolvedloc.path); + nfs3_readdirp_reply(cs->req, stat, NULL, 0, NULL, NULL, 0, 0, 0); + } + + /* For directories, we force a purge from the fd cache on close + * so that next time the dir is read, we'll get any changed directory + * entries. + */ + nfs3_call_state_wipe(cs); ret: - return 0; + return 0; } int -nfs3_readdir_process (nfs3_call_state_t *cs) +nfs3_readdir_process(nfs3_call_state_t *cs) { - int ret = -EFAULT; - nfs_user_t nfu = {0, }; + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; - if (!cs) - return ret; - - nfs_request_user_init (&nfu, cs->req); - ret = nfs_readdirp (cs->nfsx, cs->vol, &nfu, cs->fd, cs->dircount, - cs->cookie, nfs3svc_readdir_cbk, cs); + if (!cs) return ret; -} + nfs_request_user_init(&nfu, cs->req); + ret = nfs_readdirp(cs->nfsx, cs->vol, &nfu, cs->fd, cs->dircount, + cs->cookie, nfs3svc_readdir_cbk, cs); + return ret; +} int -nfs3_readdir_read_resume (void *carg) +nfs3_readdir_read_resume(void *carg) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs3_call_state_t *cs = NULL; - struct nfs3_state *nfs3 = NULL; - - if (!carg) - return ret; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs3_call_state_t *cs = NULL; + struct nfs3_state *nfs3 = NULL; - cs = (nfs3_call_state_t *)carg; - nfs3_check_fh_resolve_status (cs, stat, nfs3err); - nfs3 = rpcsvc_request_program_private (cs->req); - ret = nfs3_verify_dircookie (nfs3, cs->fd, cs->cookie, cs->cookieverf, - &stat); - if (ret < 0) /* Stat already set by verifier function above. */ - goto nfs3err; + if (!carg) + return ret; - ret = nfs3_readdir_process (cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + cs = (nfs3_call_state_t *)carg; + nfs3_check_fh_resolve_status(cs, stat, nfs3err); + nfs3 = rpcsvc_request_program_private(cs->req); + ret = nfs3_verify_dircookie(nfs3, cs->fd, cs->cookie, cs->cookieverf, + &stat); + if (ret < 0) /* Stat already set by verifier function above. */ + goto nfs3err; + + ret = nfs3_readdir_process(cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - if (cs->maxcount == 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_READDIR, stat, -ret, - cs->resolvedloc.path); - nfs3_readdir_reply (cs->req, stat, NULL, 0, NULL, NULL, - 0, 0); - } else { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_READDIRP, stat, -ret, - cs->resolvedloc.path); - nfs3_readdirp_reply (cs->req, stat, NULL, 0, NULL, NULL, - 0, 0, 0); - } - nfs3_call_state_wipe (cs); + if (ret < 0) { + if (cs->maxcount == 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_READDIR, stat, + -ret, cs->resolvedloc.path); + nfs3_readdir_reply(cs->req, stat, NULL, 0, NULL, NULL, 0, 0); + } else { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_READDIRP, + stat, -ret, cs->resolvedloc.path); + nfs3_readdirp_reply(cs->req, stat, NULL, 0, NULL, NULL, 0, 0, 0); } + nfs3_call_state_wipe(cs); + } - return 0; + return 0; } - int32_t -nfs3svc_readdir_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, - dict_t *xdata) +nfs3svc_readdir_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, fd_t *fd, + dict_t *xdata) { - /* - * We don't really need this, it's just an artifact of forcing the - * opendir to happen. - */ - if (fd) { - fd_unref(fd); - } + /* + * We don't really need this, it's just an artifact of forcing the + * opendir to happen. + */ + if (fd) { + fd_unref(fd); + } - return 0; + return 0; } - int -nfs3_readdir_open_resume (void *carg) -{ - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs3_call_state_t *cs = NULL; - nfs_user_t nfu = {0, }; - - if (!carg) - return ret; - - cs = (nfs3_call_state_t *)carg; - nfs3_check_fh_resolve_status (cs, stat, nfs3err); - cs->fd = fd_anonymous (cs->resolvedloc.inode); - if (!cs->fd) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ANONYMOUS_FD_FAIL, - "Fail to create anonymous fd"); - goto nfs3err; - } +nfs3_readdir_open_resume(void *carg) +{ + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs3_call_state_t *cs = NULL; + nfs_user_t nfu = { + 0, + }; - /* - * NFS client will usually send us a readdirp without an opendir, - * which would cause us to skip our usual self-heal checks which occur - * in opendir for native protocol. To make sure those checks do happen, - * our most reliable option is to do our own opendir for any readdirp - * at the beginning of the directory. - */ - if (cs->cookie == 0) { - nfs_request_user_init (&nfu, cs->req); - ret = nfs_opendir (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - nfs3svc_readdir_opendir_cbk, cs); - if (ret < 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, - NFS_MSG_DIR_OP_FAIL, - "auto-opendir failed"); - } + if (!carg) + return ret; + + cs = (nfs3_call_state_t *)carg; + nfs3_check_fh_resolve_status(cs, stat, nfs3err); + cs->fd = fd_anonymous(cs->resolvedloc.inode); + if (!cs->fd) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ANONYMOUS_FD_FAIL, + "Fail to create anonymous fd"); + goto nfs3err; + } + + /* + * NFS client will usually send us a readdirp without an opendir, + * which would cause us to skip our usual self-heal checks which occur + * in opendir for native protocol. To make sure those checks do happen, + * our most reliable option is to do our own opendir for any readdirp + * at the beginning of the directory. + */ + if (cs->cookie == 0) { + nfs_request_user_init(&nfu, cs->req); + ret = nfs_opendir(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + nfs3svc_readdir_opendir_cbk, cs); + if (ret < 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_DIR_OP_FAIL, + "auto-opendir failed"); } + } - ret = nfs3_readdir_read_resume (cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + ret = nfs3_readdir_read_resume(cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - if (cs->maxcount == 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_READDIR, stat, -ret, - cs->resolvedloc.path); - nfs3_readdir_reply (cs->req, stat, NULL, 0, NULL, NULL, - 0, 0); - } else { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_READDIRP, stat, -ret, - cs->resolvedloc.path); - nfs3_readdirp_reply (cs->req, stat, NULL, 0, NULL, NULL, - 0, 0, 0); - } - nfs3_call_state_wipe (cs); + if (ret < 0) { + if (cs->maxcount == 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_READDIR, stat, + -ret, cs->resolvedloc.path); + nfs3_readdir_reply(cs->req, stat, NULL, 0, NULL, NULL, 0, 0); + } else { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_READDIRP, + stat, -ret, cs->resolvedloc.path); + nfs3_readdirp_reply(cs->req, stat, NULL, 0, NULL, NULL, 0, 0, 0); } + nfs3_call_state_wipe(cs); + } - return ret; + return ret; } - - int -nfs3_readdir (rpcsvc_request_t *req, struct nfs3_fh *fh, cookie3 cookie, - uint64_t cverf, count3 dircount, count3 maxcount) -{ - xlator_t *vol = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - struct nfs3_state *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - struct nfs_state *nfs = NULL; - gf_boolean_t is_readdirp = !!maxcount; - - if ((!req) || (!fh)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Bad arguments"); - return -1; - } - - nfs3_log_readdir_call (rpcsvc_request_xid (req), fh, dircount, - maxcount); - nfs3_validate_gluster_fh (fh, stat, nfs3err); - nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret); - nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err); - nfs3_volume_started_check (nfs3, vol, ret, out); - nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err); - nfs = nfs_state (nfs3->nfsx); - - if (is_readdirp && !nfs->rdirplus) { - ret = -ENOTSUP; - stat = nfs3_errno_to_nfsstat3 (-ret); - goto nfs3err; - } - - cs->cookieverf = cverf; - cs->dircount = dircount; - cs->maxcount = maxcount; - cs->cookie = cookie; - cs->parent = *fh; - ret = nfs3_fh_resolve_and_resume (cs, fh, NULL, - nfs3_readdir_open_resume); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); +nfs3_readdir(rpcsvc_request_t *req, struct nfs3_fh *fh, cookie3 cookie, + uint64_t cverf, count3 dircount, count3 maxcount) +{ + xlator_t *vol = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + struct nfs3_state *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + struct nfs_state *nfs = NULL; + gf_boolean_t is_readdirp = !!maxcount; + + if ((!req) || (!fh)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Bad arguments"); + return -1; + } + + nfs3_log_readdir_call(rpcsvc_request_xid(req), fh, dircount, maxcount); + nfs3_validate_gluster_fh(fh, stat, nfs3err); + nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret); + nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err); + nfs3_volume_started_check(nfs3, vol, ret, out); + nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err); + nfs = nfs_state(nfs3->nfsx); + + if (is_readdirp && !nfs->rdirplus) { + ret = -ENOTSUP; + stat = nfs3_errno_to_nfsstat3(-ret); + goto nfs3err; + } + + cs->cookieverf = cverf; + cs->dircount = dircount; + cs->maxcount = maxcount; + cs->cookie = cookie; + cs->parent = *fh; + ret = nfs3_fh_resolve_and_resume(cs, fh, NULL, nfs3_readdir_open_resume); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - if (!is_readdirp) { - nfs3_log_common_res (rpcsvc_request_xid (req), - NFS3_READDIR, stat, -ret, - cs ? cs->resolvedloc.path : NULL); - nfs3_readdir_reply (req, stat, NULL, 0, NULL, NULL, 0, - 0); - } else { - nfs3_log_common_res (rpcsvc_request_xid (req), - NFS3_READDIRP, stat, -ret, - cs ? cs->resolvedloc.path : NULL); - nfs3_readdirp_reply (req, stat, NULL, 0, NULL, NULL, 0, - 0, 0); - } - /* Ret must be NULL after this so that the caller does not - * also send an RPC reply. - */ - ret = 0; - nfs3_call_state_wipe (cs); + if (ret < 0) { + if (!is_readdirp) { + nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_READDIR, stat, + -ret, cs ? cs->resolvedloc.path : NULL); + nfs3_readdir_reply(req, stat, NULL, 0, NULL, NULL, 0, 0); + } else { + nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_READDIRP, stat, + -ret, cs ? cs->resolvedloc.path : NULL); + nfs3_readdirp_reply(req, stat, NULL, 0, NULL, NULL, 0, 0, 0); } + /* Ret must be NULL after this so that the caller does not + * also send an RPC reply. + */ + ret = 0; + nfs3_call_state_wipe(cs); + } out: - return ret; + return ret; } - int -nfs3svc_readdir (rpcsvc_request_t *req) -{ - readdir3args ra; - struct nfs3_fh fh = {{0},}; - int ret = RPCSVC_ACTOR_ERROR; - uint64_t verf = 0; - uint64_t *cval; - - if (!req) - return ret; - nfs3_prep_readdir3args (&ra, &fh); - if (xdr_to_readdir3args (req->msg[0], &ra) <= 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } - cval = (uint64_t *) ra.cookieverf; - verf = *cval; - - ret = nfs3_readdir (req, &fh, ra.cookie, verf, ra.count, 0); - if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, - NFS_MSG_READDIR_FAIL, - "READDIR procedure failed"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = RPCSVC_ACTOR_ERROR; - } +nfs3svc_readdir(rpcsvc_request_t *req) +{ + readdir3args ra; + struct nfs3_fh fh = { + {0}, + }; + int ret = RPCSVC_ACTOR_ERROR; + uint64_t verf = 0; + uint64_t *cval; -rpcerr: + if (!req) return ret; -} + nfs3_prep_readdir3args(&ra, &fh); + if (xdr_to_readdir3args(req->msg[0], &ra) <= 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + cval = (uint64_t *)ra.cookieverf; + verf = *cval; + + ret = nfs3_readdir(req, &fh, ra.cookie, verf, ra.count, 0); + if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_READDIR_FAIL, + "READDIR procedure failed"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = RPCSVC_ACTOR_ERROR; + } +rpcerr: + return ret; +} int -nfs3svc_readdirp (rpcsvc_request_t *req) -{ - readdirp3args ra; - struct nfs3_fh fh = {{0},}; - int ret = RPCSVC_ACTOR_ERROR; - uint64_t cverf = 0; - uint64_t *cval; - - if (!req) - return ret; - nfs3_prep_readdirp3args (&ra, &fh); - if (xdr_to_readdirp3args (req->msg[0], &ra) <= 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } - cval = (uint64_t *) ra.cookieverf; - cverf = *cval; - - ret = nfs3_readdir (req, &fh, ra.cookie, cverf, ra.dircount, - ra.maxcount); - if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, - NFS_MSG_READDIRP_FAIL, - "READDIRP procedure failed"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = RPCSVC_ACTOR_ERROR; - } +nfs3svc_readdirp(rpcsvc_request_t *req) +{ + readdirp3args ra; + struct nfs3_fh fh = { + {0}, + }; + int ret = RPCSVC_ACTOR_ERROR; + uint64_t cverf = 0; + uint64_t *cval; -rpcerr: + if (!req) return ret; -} + nfs3_prep_readdirp3args(&ra, &fh); + if (xdr_to_readdirp3args(req->msg[0], &ra) <= 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + cval = (uint64_t *)ra.cookieverf; + cverf = *cval; + + ret = nfs3_readdir(req, &fh, ra.cookie, cverf, ra.dircount, ra.maxcount); + if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_READDIRP_FAIL, + "READDIRP procedure failed"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = RPCSVC_ACTOR_ERROR; + } +rpcerr: + return ret; +} int -nfs3_fsstat_reply (rpcsvc_request_t *req, nfsstat3 stat, struct statvfs *fsbuf, - struct iatt *postbuf) +nfs3_fsstat_reply(rpcsvc_request_t *req, nfsstat3 stat, struct statvfs *fsbuf, + struct iatt *postbuf) { - fsstat3res res = {0, }; - uint64_t deviceid = 0; - - deviceid = nfs3_request_xlator_deviceid (req); - nfs3_fill_fsstat3res (&res, stat, fsbuf, postbuf, deviceid); - return nfs3svc_submit_reply (req, &res, - (nfs3_serializer)xdr_serialize_fsstat3res); + fsstat3res res = { + 0, + }; + uint64_t deviceid = 0; + deviceid = nfs3_request_xlator_deviceid(req); + nfs3_fill_fsstat3res(&res, stat, fsbuf, postbuf, deviceid); + return nfs3svc_submit_reply(req, &res, + (nfs3_serializer)xdr_serialize_fsstat3res); } - int32_t -nfs3_fsstat_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, - dict_t *xdata) +nfs3_fsstat_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *buf, + dict_t *xdata) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + nfs3_call_state_t *cs = NULL; - cs = frame->local; - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - } else - stat = NFS3_OK; + cs = frame->local; + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + } else + stat = NFS3_OK; - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_FSSTAT, stat, - op_errno, cs->resolvedloc.path); - nfs3_fsstat_reply (cs->req, stat, &cs->fsstat, buf); - nfs3_call_state_wipe (cs); - return 0; + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_FSSTAT, stat, + op_errno, cs->resolvedloc.path); + nfs3_fsstat_reply(cs->req, stat, &cs->fsstat, buf); + nfs3_call_state_wipe(cs); + return 0; } - int32_t -nfs3_fsstat_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct statvfs *buf, - dict_t *xdata) -{ - nfs_user_t nfu = {0, }; - int ret = -EFAULT; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - nfs3_call_state_t *cs = NULL; - - cs = frame->local; - if (op_ret == -1) { - ret = -op_errno; - stat = nfs3_cbk_errno_status (op_ret, op_errno); - goto err; - } - - /* Then get the stat for the fs root in order to fill in the - * post_op_attr. - */ - cs->fsstat = *buf; - nfs_request_user_init (&nfu, cs->req); - ret = nfs_stat (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - nfs3_fsstat_stat_cbk, cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); +nfs3_fsstat_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct statvfs *buf, + dict_t *xdata) +{ + nfs_user_t nfu = { + 0, + }; + int ret = -EFAULT; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + nfs3_call_state_t *cs = NULL; + + cs = frame->local; + if (op_ret == -1) { + ret = -op_errno; + stat = nfs3_cbk_errno_status(op_ret, op_errno); + goto err; + } + + /* Then get the stat for the fs root in order to fill in the + * post_op_attr. + */ + cs->fsstat = *buf; + nfs_request_user_init(&nfu, cs->req); + ret = nfs_stat(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + nfs3_fsstat_stat_cbk, cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_FSSTAT, stat, -ret, - cs->resolvedloc.path); - nfs3_fsstat_reply (cs->req, stat, NULL, NULL); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_FSSTAT, stat, + -ret, cs->resolvedloc.path); + nfs3_fsstat_reply(cs->req, stat, NULL, NULL); + nfs3_call_state_wipe(cs); + } - return 0; + return 0; } - int -nfs3_fsstat_resume (void *carg) -{ - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs3_call_state_t *cs = NULL; - nfs_user_t nfu = {0, }; - - if (!carg) - return ret; - - cs = (nfs3_call_state_t *)carg; - nfs3_check_fh_resolve_status (cs, stat, nfs3err); - nfs_request_user_init (&nfu, cs->req); - /* First, we need to get the statvfs for the subvol */ - ret = nfs_statfs (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - nfs3_fsstat_statfs_cbk, cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); - -nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_FSSTAT, stat, -ret, - cs->resolvedloc.path); - nfs3_fsstat_reply (cs->req, stat, NULL, NULL); - nfs3_call_state_wipe (cs); - } +nfs3_fsstat_resume(void *carg) +{ + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs3_call_state_t *cs = NULL; + nfs_user_t nfu = { + 0, + }; + if (!carg) return ret; -} - + cs = (nfs3_call_state_t *)carg; + nfs3_check_fh_resolve_status(cs, stat, nfs3err); + nfs_request_user_init(&nfu, cs->req); + /* First, we need to get the statvfs for the subvol */ + ret = nfs_statfs(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + nfs3_fsstat_statfs_cbk, cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); -int -nfs3_fsstat (rpcsvc_request_t *req, struct nfs3_fh *fh) -{ - xlator_t *vol = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - struct nfs3_state *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - - if ((!req) || (!fh)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Bad arguments"); - return -1; - } +nfs3err: + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_FSSTAT, stat, + -ret, cs->resolvedloc.path); + nfs3_fsstat_reply(cs->req, stat, NULL, NULL); + nfs3_call_state_wipe(cs); + } - nfs3_log_common_call (rpcsvc_request_xid (req), "FSSTAT", fh); - nfs3_validate_gluster_fh (fh, stat, nfs3err); - nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret); - nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err); - nfs3_volume_started_check (nfs3, vol, ret, out); - nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err); + return ret; +} - ret = nfs3_fh_resolve_and_resume (cs, fh, NULL, nfs3_fsstat_resume); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); +int +nfs3_fsstat(rpcsvc_request_t *req, struct nfs3_fh *fh) +{ + xlator_t *vol = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + struct nfs3_state *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + + if ((!req) || (!fh)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Bad arguments"); + return -1; + } + + nfs3_log_common_call(rpcsvc_request_xid(req), "FSSTAT", fh); + nfs3_validate_gluster_fh(fh, stat, nfs3err); + nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret); + nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err); + nfs3_volume_started_check(nfs3, vol, ret, out); + nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err); + + ret = nfs3_fh_resolve_and_resume(cs, fh, NULL, nfs3_fsstat_resume); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (req), - NFS3_FSSTAT, stat, -ret, - cs ? cs->resolvedloc.path : NULL); - nfs3_fsstat_reply (req, stat, NULL, NULL); - nfs3_call_state_wipe (cs); - /* Ret must be 0 after this so that the caller does not - * also send an RPC reply. - */ - ret = 0; - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_FSSTAT, stat, -ret, + cs ? cs->resolvedloc.path : NULL); + nfs3_fsstat_reply(req, stat, NULL, NULL); + nfs3_call_state_wipe(cs); + /* Ret must be 0 after this so that the caller does not + * also send an RPC reply. + */ + ret = 0; + } out: - return ret; + return ret; } - int -nfs3svc_fsstat (rpcsvc_request_t *req) -{ - struct nfs3_fh fh = {{0}, }; - fsstat3args args; - int ret = RPCSVC_ACTOR_ERROR; - - if (!req) - return ret; - nfs3_prep_fsstat3args (&args, &fh); - if (xdr_to_fsstat3args (req->msg[0], &args) <= 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } +nfs3svc_fsstat(rpcsvc_request_t *req) +{ + struct nfs3_fh fh = { + {0}, + }; + fsstat3args args; + int ret = RPCSVC_ACTOR_ERROR; - ret = nfs3_fsstat (req, &fh); - if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_FSTAT_FAIL, - "FSTAT procedure failed"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = RPCSVC_ACTOR_ERROR; - } + if (!req) + return ret; + nfs3_prep_fsstat3args(&args, &fh); + if (xdr_to_fsstat3args(req->msg[0], &args) <= 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + ret = nfs3_fsstat(req, &fh); + if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_FSTAT_FAIL, + "FSTAT procedure failed"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = RPCSVC_ACTOR_ERROR; + } rpcerr: - return ret; + return ret; } - int -nfs3_fsinfo_reply (rpcsvc_request_t *req, nfsstat3 status, struct iatt *fsroot) +nfs3_fsinfo_reply(rpcsvc_request_t *req, nfsstat3 status, struct iatt *fsroot) { - fsinfo3res res; - struct nfs3_state *nfs3 = NULL; - uint64_t deviceid = 0; + fsinfo3res res; + struct nfs3_state *nfs3 = NULL; + uint64_t deviceid = 0; - deviceid = nfs3_request_xlator_deviceid (req); - nfs3 = rpcsvc_request_program_private (req); - nfs3_fill_fsinfo3res (nfs3, &res, status, fsroot, deviceid); + deviceid = nfs3_request_xlator_deviceid(req); + nfs3 = rpcsvc_request_program_private(req); + nfs3_fill_fsinfo3res(nfs3, &res, status, fsroot, deviceid); - nfs3svc_submit_reply (req, &res, - (nfs3_serializer)xdr_serialize_fsinfo3res); - return 0; + nfs3svc_submit_reply(req, &res, (nfs3_serializer)xdr_serialize_fsinfo3res); + return 0; } - int32_t -nfs3svc_fsinfo_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, - dict_t *xdata) +nfs3svc_fsinfo_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *buf, + dict_t *xdata) { - nfsstat3 status = NFS3ERR_SERVERFAULT; - nfs3_call_state_t *cs = NULL; + nfsstat3 status = NFS3ERR_SERVERFAULT; + nfs3_call_state_t *cs = NULL; - cs = frame->local; + cs = frame->local; - if (op_ret == -1) { - status = nfs3_cbk_errno_status (op_ret, op_errno); - }else - status = NFS3_OK; + if (op_ret == -1) { + status = nfs3_cbk_errno_status(op_ret, op_errno); + } else + status = NFS3_OK; - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_FSINFO, status, - op_errno, cs->resolvedloc.path); + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_FSINFO, status, + op_errno, cs->resolvedloc.path); - nfs3_fsinfo_reply (cs->req, status, buf); - nfs3_call_state_wipe (cs); + nfs3_fsinfo_reply(cs->req, status, buf); + nfs3_call_state_wipe(cs); - return 0; + return 0; } - int -nfs3_fsinfo_resume (void *carg) +nfs3_fsinfo_resume(void *carg) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + nfs3_call_state_t *cs = NULL; + if (!carg) + return ret; - if (!carg) - return ret; - - cs = (nfs3_call_state_t *)carg; - nfs3_check_fh_resolve_status (cs, stat, nfs3err); - nfs_request_user_init (&nfu, cs->req); + cs = (nfs3_call_state_t *)carg; + nfs3_check_fh_resolve_status(cs, stat, nfs3err); + nfs_request_user_init(&nfu, cs->req); - ret = nfs_stat (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - nfs3svc_fsinfo_cbk, cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + ret = nfs_stat(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + nfs3svc_fsinfo_cbk, cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_FSINFO, stat, -ret, - cs->resolvedloc.path); - nfs3_fsinfo_reply (cs->req, stat, NULL); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_FSINFO, stat, + -ret, cs->resolvedloc.path); + nfs3_fsinfo_reply(cs->req, stat, NULL); + nfs3_call_state_wipe(cs); + } - return ret; + return ret; } - int -nfs3_fsinfo (rpcsvc_request_t *req, struct nfs3_fh *fh) -{ - xlator_t *vol = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - struct nfs3_state *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - - if ((!req) || (!fh)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Bad arguments"); - return -1; - } - - nfs3_log_common_call (rpcsvc_request_xid (req), "FSINFO", fh); - nfs3_validate_gluster_fh (fh, stat, nfs3err); - nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret); - nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err); - nfs3_volume_started_check (nfs3, vol, ret, out); - nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err); - - ret = nfs3_fh_resolve_and_resume (cs, fh, NULL, nfs3_fsinfo_resume); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); +nfs3_fsinfo(rpcsvc_request_t *req, struct nfs3_fh *fh) +{ + xlator_t *vol = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + struct nfs3_state *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + + if ((!req) || (!fh)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Bad arguments"); + return -1; + } + + nfs3_log_common_call(rpcsvc_request_xid(req), "FSINFO", fh); + nfs3_validate_gluster_fh(fh, stat, nfs3err); + nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret); + nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err); + nfs3_volume_started_check(nfs3, vol, ret, out); + nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err); + + ret = nfs3_fh_resolve_and_resume(cs, fh, NULL, nfs3_fsinfo_resume); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (req), - NFS3_FSINFO, stat, -ret, - cs ? cs->resolvedloc.path : NULL); - nfs3_fsinfo_reply (req, stat, NULL); - nfs3_call_state_wipe (cs); - ret = 0; - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_FSINFO, stat, -ret, + cs ? cs->resolvedloc.path : NULL); + nfs3_fsinfo_reply(req, stat, NULL); + nfs3_call_state_wipe(cs); + ret = 0; + } out: - return ret; + return ret; } - int -nfs3svc_fsinfo (rpcsvc_request_t *req) +nfs3svc_fsinfo(rpcsvc_request_t *req) { - int ret = RPCSVC_ACTOR_ERROR; - fsinfo3args args; - struct nfs3_fh root = {{0}, }; - - if (!req) - return ret; + int ret = RPCSVC_ACTOR_ERROR; + fsinfo3args args; + struct nfs3_fh root = { + {0}, + }; - nfs3_prep_fsinfo3args (&args, &root); - if (xdr_to_fsinfo3args (req->msg[0], &args) <= 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding arguments"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } + if (!req) + return ret; - ret = nfs3_fsinfo (req, &root); - if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_FSINFO_FAIL, - "FSINFO procedure failed"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = RPCSVC_ACTOR_ERROR; - } + nfs3_prep_fsinfo3args(&args, &root); + if (xdr_to_fsinfo3args(req->msg[0], &args) <= 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding arguments"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + ret = nfs3_fsinfo(req, &root); + if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_FSINFO_FAIL, + "FSINFO procedure failed"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = RPCSVC_ACTOR_ERROR; + } rpcerr: - return ret; + return ret; } - int -nfs3_pathconf_reply (rpcsvc_request_t *req, nfsstat3 stat, struct iatt *buf) +nfs3_pathconf_reply(rpcsvc_request_t *req, nfsstat3 stat, struct iatt *buf) { - pathconf3res res = {0, }; - uint64_t deviceid = 0; + pathconf3res res = { + 0, + }; + uint64_t deviceid = 0; - deviceid = nfs3_request_xlator_deviceid (req); - nfs3_fill_pathconf3res (&res, stat, buf, deviceid); - nfs3svc_submit_reply (req, (void *)&res, - (nfs3_serializer)xdr_serialize_pathconf3res); - return 0; + deviceid = nfs3_request_xlator_deviceid(req); + nfs3_fill_pathconf3res(&res, stat, buf, deviceid); + nfs3svc_submit_reply(req, (void *)&res, + (nfs3_serializer)xdr_serialize_pathconf3res); + return 0; } - int32_t -nfs3svc_pathconf_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, - dict_t *xdata) +nfs3svc_pathconf_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *buf, + dict_t *xdata) { - struct iatt *sbuf = NULL; - nfs3_call_state_t *cs = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; + struct iatt *sbuf = NULL; + nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; - cs = frame->local; - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - } else { - /* If stat fop failed, we can still send the other components - * in a pathconf reply. - */ - sbuf = buf; - stat = NFS3_OK; - } + cs = frame->local; + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + } else { + /* If stat fop failed, we can still send the other components + * in a pathconf reply. + */ + sbuf = buf; + stat = NFS3_OK; + } - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_PATHCONF, stat, - op_errno, cs->resolvedloc.path); - nfs3_pathconf_reply (cs->req, stat, sbuf); - nfs3_call_state_wipe (cs); + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_PATHCONF, stat, + op_errno, cs->resolvedloc.path); + nfs3_pathconf_reply(cs->req, stat, sbuf); + nfs3_call_state_wipe(cs); - return 0; + return 0; } - int -nfs3_pathconf_resume (void *carg) +nfs3_pathconf_resume(void *carg) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + nfs3_call_state_t *cs = NULL; - if (!carg) - return ret; + if (!carg) + return ret; - cs = (nfs3_call_state_t *)carg; - nfs3_check_fh_resolve_status (cs, stat, nfs3err); - nfs_request_user_init (&nfu, cs->req); - ret = nfs_stat (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, - nfs3svc_pathconf_cbk, cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + cs = (nfs3_call_state_t *)carg; + nfs3_check_fh_resolve_status(cs, stat, nfs3err); + nfs_request_user_init(&nfu, cs->req); + ret = nfs_stat(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, + nfs3svc_pathconf_cbk, cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_PATHCONF, stat, -ret, - cs->resolvedloc.path); - nfs3_pathconf_reply (cs->req, stat, NULL); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_PATHCONF, stat, + -ret, cs->resolvedloc.path); + nfs3_pathconf_reply(cs->req, stat, NULL); + nfs3_call_state_wipe(cs); + } - return ret; + return ret; } int -nfs3_pathconf (rpcsvc_request_t *req, struct nfs3_fh *fh) -{ - xlator_t *vol = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - struct nfs3_state *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - - if ((!req) || (!fh)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Bad arguments"); - return -1; - } - - nfs3_log_common_call (rpcsvc_request_xid (req), "PATHCONF", fh); - nfs3_validate_gluster_fh (fh, stat, nfs3err); - nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret); - nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err); - nfs3_volume_started_check (nfs3, vol, ret, out); - nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err); - - ret = nfs3_fh_resolve_and_resume (cs, fh, NULL, nfs3_pathconf_resume); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); +nfs3_pathconf(rpcsvc_request_t *req, struct nfs3_fh *fh) +{ + xlator_t *vol = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + struct nfs3_state *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + + if ((!req) || (!fh)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Bad arguments"); + return -1; + } + + nfs3_log_common_call(rpcsvc_request_xid(req), "PATHCONF", fh); + nfs3_validate_gluster_fh(fh, stat, nfs3err); + nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret); + nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err); + nfs3_volume_started_check(nfs3, vol, ret, out); + nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err); + + ret = nfs3_fh_resolve_and_resume(cs, fh, NULL, nfs3_pathconf_resume); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (req), - NFS3_PATHCONF, stat, -ret, - cs ? cs->resolvedloc.path : NULL); - nfs3_pathconf_reply (req, stat, NULL); - nfs3_call_state_wipe (cs); - /* Ret must be 0 after this so that the caller does not - * also send an RPC reply. - */ - ret = 0; - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_PATHCONF, stat, -ret, + cs ? cs->resolvedloc.path : NULL); + nfs3_pathconf_reply(req, stat, NULL); + nfs3_call_state_wipe(cs); + /* Ret must be 0 after this so that the caller does not + * also send an RPC reply. + */ + ret = 0; + } out: - return ret; + return ret; } - int -nfs3svc_pathconf (rpcsvc_request_t *req) -{ - struct nfs3_fh fh = {{0}, }; - pathconf3args args; - int ret = RPCSVC_ACTOR_ERROR; - - if (!req) - return ret; - nfs3_prep_pathconf3args (&args, &fh); - if (xdr_to_pathconf3args (req->msg[0], &args) <= 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } +nfs3svc_pathconf(rpcsvc_request_t *req) +{ + struct nfs3_fh fh = { + {0}, + }; + pathconf3args args; + int ret = RPCSVC_ACTOR_ERROR; - ret = nfs3_pathconf (req, &fh); - if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, - NFS_MSG_PATHCONF_FAIL, - "PATHCONF procedure failed"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = RPCSVC_ACTOR_ERROR; - } + if (!req) + return ret; + nfs3_prep_pathconf3args(&args, &fh); + if (xdr_to_pathconf3args(req->msg[0], &args) <= 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + ret = nfs3_pathconf(req, &fh); + if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_PATHCONF_FAIL, + "PATHCONF procedure failed"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = RPCSVC_ACTOR_ERROR; + } rpcerr: - return ret; + return ret; } int -nfs3_commit_reply (rpcsvc_request_t *req, nfsstat3 stat, uint64_t wverf, - struct iatt *prestat, struct iatt *poststat) +nfs3_commit_reply(rpcsvc_request_t *req, nfsstat3 stat, uint64_t wverf, + struct iatt *prestat, struct iatt *poststat) { - commit3res res = {0, }; - uint64_t deviceid = 0; + commit3res res = { + 0, + }; + uint64_t deviceid = 0; - deviceid = nfs3_request_xlator_deviceid (req); - nfs3_fill_commit3res (&res, stat, wverf, prestat, poststat, deviceid); - nfs3svc_submit_reply (req, (void *)&res, - (nfs3_serializer)xdr_serialize_commit3res); + deviceid = nfs3_request_xlator_deviceid(req); + nfs3_fill_commit3res(&res, stat, wverf, prestat, poststat, deviceid); + nfs3svc_submit_reply(req, (void *)&res, + (nfs3_serializer)xdr_serialize_commit3res); - return 0; + return 0; } - int32_t -nfs3svc_commit_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +nfs3svc_commit_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - nfs3_call_state_t *cs = NULL; - struct nfs3_state *nfs3 = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + nfs3_call_state_t *cs = NULL; + struct nfs3_state *nfs3 = NULL; - cs = frame->local; - if (op_ret == -1) { - stat = nfs3_cbk_errno_status (op_ret, op_errno); - } else - stat = NFS3_OK; + cs = frame->local; + if (op_ret == -1) { + stat = nfs3_cbk_errno_status(op_ret, op_errno); + } else + stat = NFS3_OK; - nfs3 = rpcsvc_request_program_private (cs->req); - nfs3_log_commit_res (rpcsvc_request_xid (cs->req), - stat, op_errno, nfs3->serverstart, - cs->resolvedloc.path); - nfs3_commit_reply (cs->req, stat, nfs3->serverstart, NULL, NULL); - nfs3_call_state_wipe (cs); + nfs3 = rpcsvc_request_program_private(cs->req); + nfs3_log_commit_res(rpcsvc_request_xid(cs->req), stat, op_errno, + nfs3->serverstart, cs->resolvedloc.path); + nfs3_commit_reply(cs->req, stat, nfs3->serverstart, NULL, NULL); + nfs3_call_state_wipe(cs); - return 0; + return 0; } int -nfs3_commit_resume (void *carg) +nfs3_commit_resume(void *carg) { - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - nfs3_call_state_t *cs = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + nfs3_call_state_t *cs = NULL; - if (!carg) - return ret; + if (!carg) + return ret; - cs = (nfs3_call_state_t *)carg; - nfs3_check_fh_resolve_status (cs, stat, nfs3err); + cs = (nfs3_call_state_t *)carg; + nfs3_check_fh_resolve_status(cs, stat, nfs3err); - if (nfs3_export_sync_trusted (cs->nfs3state, cs->resolvefh.exportid)) { - ret = -1; - stat = NFS3_OK; - goto nfs3err; - } + if (nfs3_export_sync_trusted(cs->nfs3state, cs->resolvefh.exportid)) { + ret = -1; + stat = NFS3_OK; + goto nfs3err; + } - nfs_request_user_init (&nfu, cs->req); - ret = nfs_flush (cs->nfsx, cs->vol, &nfu, cs->fd, - nfs3svc_commit_cbk, cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); + nfs_request_user_init(&nfu, cs->req); + ret = nfs_flush(cs->nfsx, cs->vol, &nfu, cs->fd, nfs3svc_commit_cbk, cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_COMMIT, stat, -ret, - cs->resolvedloc.path); - nfs3_commit_reply (cs->req, stat, cs->nfs3state->serverstart, - NULL, NULL); - nfs3_call_state_wipe (cs); - ret = 0; - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_COMMIT, stat, + -ret, cs->resolvedloc.path); + nfs3_commit_reply(cs->req, stat, cs->nfs3state->serverstart, NULL, + NULL); + nfs3_call_state_wipe(cs); + ret = 0; + } - return 0; + return 0; } - int -nfs3_commit_open_resume (void *carg) -{ - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - nfs3_call_state_t *cs = NULL; - - if (!carg) - return ret; - - cs = (nfs3_call_state_t *)carg; - nfs3_check_fh_resolve_status (cs, stat, nfs3err); - cs->fd = fd_anonymous (cs->resolvedloc.inode); - if (!cs->fd) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ANONYMOUS_FD_FAIL, - "Failed to create anonymous fd."); - goto nfs3err; - } - - ret = nfs3_commit_resume (cs); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); -nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (cs->req), - NFS3_COMMIT, stat, -ret, - cs->resolvedloc.path); - nfs3_commit_reply (cs->req, stat, 0, NULL, NULL); - nfs3_call_state_wipe (cs); - } +nfs3_commit_open_resume(void *carg) +{ + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + nfs3_call_state_t *cs = NULL; + if (!carg) return ret; -} + cs = (nfs3_call_state_t *)carg; + nfs3_check_fh_resolve_status(cs, stat, nfs3err); + cs->fd = fd_anonymous(cs->resolvedloc.inode); + if (!cs->fd) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ANONYMOUS_FD_FAIL, + "Failed to create anonymous fd."); + goto nfs3err; + } + + ret = nfs3_commit_resume(cs); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); +nfs3err: + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_COMMIT, stat, + -ret, cs->resolvedloc.path); + nfs3_commit_reply(cs->req, stat, 0, NULL, NULL); + nfs3_call_state_wipe(cs); + } + return ret; +} int -nfs3_commit (rpcsvc_request_t *req, struct nfs3_fh *fh, offset3 offset, - count3 count) -{ - xlator_t *vol = NULL; - nfsstat3 stat = NFS3ERR_SERVERFAULT; - int ret = -EFAULT; - struct nfs3_state *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - - if ((!req) || (!fh)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Bad arguments"); - return -1; - } - - nfs3_log_rw_call (rpcsvc_request_xid (req), "COMMIT", fh, offset, - count, -1); - nfs3_validate_gluster_fh (fh, stat, nfs3err); - nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret); - nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err); - nfs3_volume_started_check (nfs3, vol, ret, out); - nfs3_check_rw_volaccess (nfs3, fh->exportid, stat, nfs3err); - nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err); - - cs->datacount = count; - cs->dataoffset = offset; - ret = nfs3_fh_resolve_and_resume (cs, fh, NULL, - nfs3_commit_open_resume); - if (ret < 0) - stat = nfs3_errno_to_nfsstat3 (-ret); +nfs3_commit(rpcsvc_request_t *req, struct nfs3_fh *fh, offset3 offset, + count3 count) +{ + xlator_t *vol = NULL; + nfsstat3 stat = NFS3ERR_SERVERFAULT; + int ret = -EFAULT; + struct nfs3_state *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + + if ((!req) || (!fh)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Bad arguments"); + return -1; + } + + nfs3_log_rw_call(rpcsvc_request_xid(req), "COMMIT", fh, offset, count, -1); + nfs3_validate_gluster_fh(fh, stat, nfs3err); + nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret); + nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err); + nfs3_volume_started_check(nfs3, vol, ret, out); + nfs3_check_rw_volaccess(nfs3, fh->exportid, stat, nfs3err); + nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err); + + cs->datacount = count; + cs->dataoffset = offset; + ret = nfs3_fh_resolve_and_resume(cs, fh, NULL, nfs3_commit_open_resume); + if (ret < 0) + stat = nfs3_errno_to_nfsstat3(-ret); nfs3err: - if (ret < 0) { - nfs3_log_common_res (rpcsvc_request_xid (req), - NFS3_COMMIT, stat, -ret, - cs ? cs->resolvedloc.path : NULL); - nfs3_commit_reply (req, stat, 0, NULL, NULL); - nfs3_call_state_wipe (cs); - ret = 0; - } + if (ret < 0) { + nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_COMMIT, stat, -ret, + cs ? cs->resolvedloc.path : NULL); + nfs3_commit_reply(req, stat, 0, NULL, NULL); + nfs3_call_state_wipe(cs); + ret = 0; + } out: - return ret; + return ret; } - - int -nfs3svc_commit (rpcsvc_request_t *req) -{ - struct nfs3_fh fh = {{0}, }; - commit3args args; - int ret = RPCSVC_ACTOR_ERROR; - - if (!req) - return ret; - nfs3_prep_commit3args (&args, &fh); - if (xdr_to_commit3args (req->msg[0], &args) <= 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } - - ret = nfs3_commit (req, &fh, args.offset, args.count); - if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_COMMIT_FAIL, - "COMMIT procedure failed"); - rpcsvc_request_seterr (req, SYSTEM_ERR); - ret = RPCSVC_ACTOR_ERROR; - } +nfs3svc_commit(rpcsvc_request_t *req) +{ + struct nfs3_fh fh = { + {0}, + }; + commit3args args; + int ret = RPCSVC_ACTOR_ERROR; -rpcerr: + if (!req) return ret; -} - + nfs3_prep_commit3args(&args, &fh); + if (xdr_to_commit3args(req->msg[0], &args) <= 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + ret = nfs3_commit(req, &fh, args.offset, args.count); + if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_COMMIT_FAIL, + "COMMIT procedure failed"); + rpcsvc_request_seterr(req, SYSTEM_ERR); + ret = RPCSVC_ACTOR_ERROR; + } -rpcsvc_actor_t nfs3svc_actors[NFS3_PROC_COUNT] = { - {"NULL", NFS3_NULL, nfs3svc_null, NULL, 0, DRC_IDEMPOTENT}, - {"GETATTR", NFS3_GETATTR, nfs3svc_getattr, NULL, 0, DRC_IDEMPOTENT}, - {"SETATTR", NFS3_SETATTR, nfs3svc_setattr, NULL, 0, DRC_NON_IDEMPOTENT}, - {"LOOKUP", NFS3_LOOKUP, nfs3svc_lookup, NULL, 0, DRC_IDEMPOTENT}, - {"ACCESS", NFS3_ACCESS, nfs3svc_access, NULL, 0, DRC_IDEMPOTENT}, - {"READLINK", NFS3_READLINK, nfs3svc_readlink, NULL, 0, DRC_IDEMPOTENT}, - {"READ", NFS3_READ, nfs3svc_read, NULL, 0, DRC_IDEMPOTENT}, - {"WRITE", NFS3_WRITE, nfs3svc_write, nfs3svc_write_vecsizer, 0, DRC_NON_IDEMPOTENT}, - {"CREATE", NFS3_CREATE, nfs3svc_create, NULL, 0, DRC_NON_IDEMPOTENT}, - {"MKDIR", NFS3_MKDIR, nfs3svc_mkdir, NULL, 0, DRC_NON_IDEMPOTENT}, - {"SYMLINK", NFS3_SYMLINK, nfs3svc_symlink, NULL, 0, DRC_NON_IDEMPOTENT}, - {"MKNOD", NFS3_MKNOD, nfs3svc_mknod, NULL, 0, DRC_NON_IDEMPOTENT}, - {"REMOVE", NFS3_REMOVE, nfs3svc_remove, NULL, 0, DRC_NON_IDEMPOTENT}, - {"RMDIR", NFS3_RMDIR, nfs3svc_rmdir, NULL, 0, DRC_NON_IDEMPOTENT}, - {"RENAME", NFS3_RENAME, nfs3svc_rename, NULL, 0, DRC_NON_IDEMPOTENT}, - {"LINK", NFS3_LINK, nfs3svc_link, NULL, 0, DRC_NON_IDEMPOTENT}, - {"READDIR", NFS3_READDIR, nfs3svc_readdir, NULL, 0, DRC_IDEMPOTENT}, - {"READDIRPLUS", NFS3_READDIRP, nfs3svc_readdirp, NULL, 0, DRC_IDEMPOTENT}, - {"FSSTAT", NFS3_FSSTAT, nfs3svc_fsstat, NULL, 0, DRC_IDEMPOTENT}, - {"FSINFO", NFS3_FSINFO, nfs3svc_fsinfo, NULL, 0, DRC_IDEMPOTENT}, - {"PATHCONF", NFS3_PATHCONF, nfs3svc_pathconf, NULL, 0, DRC_IDEMPOTENT}, - {"COMMIT", NFS3_COMMIT, nfs3svc_commit, NULL, 0, DRC_IDEMPOTENT} -}; - - -rpcsvc_program_t nfs3prog = { - .progname = "NFS3", - .prognum = NFS_PROGRAM, - .progver = NFS_V3, - .progport = GF_NFS3_PORT, - .actors = nfs3svc_actors, - .numactors = NFS3_PROC_COUNT, - - /* Requests like FSINFO are sent before an auth scheme - * is inited by client. See RFC 2623, Section 2.3.2. */ - .min_auth = AUTH_NULL, +rpcerr: + return ret; +} + +rpcsvc_actor_t nfs3svc_actors[NFS3_PROC_COUNT] = { + {"NULL", NFS3_NULL, nfs3svc_null, NULL, 0, DRC_IDEMPOTENT}, + {"GETATTR", NFS3_GETATTR, nfs3svc_getattr, NULL, 0, DRC_IDEMPOTENT}, + {"SETATTR", NFS3_SETATTR, nfs3svc_setattr, NULL, 0, DRC_NON_IDEMPOTENT}, + {"LOOKUP", NFS3_LOOKUP, nfs3svc_lookup, NULL, 0, DRC_IDEMPOTENT}, + {"ACCESS", NFS3_ACCESS, nfs3svc_access, NULL, 0, DRC_IDEMPOTENT}, + {"READLINK", NFS3_READLINK, nfs3svc_readlink, NULL, 0, DRC_IDEMPOTENT}, + {"READ", NFS3_READ, nfs3svc_read, NULL, 0, DRC_IDEMPOTENT}, + {"WRITE", NFS3_WRITE, nfs3svc_write, nfs3svc_write_vecsizer, 0, + DRC_NON_IDEMPOTENT}, + {"CREATE", NFS3_CREATE, nfs3svc_create, NULL, 0, DRC_NON_IDEMPOTENT}, + {"MKDIR", NFS3_MKDIR, nfs3svc_mkdir, NULL, 0, DRC_NON_IDEMPOTENT}, + {"SYMLINK", NFS3_SYMLINK, nfs3svc_symlink, NULL, 0, DRC_NON_IDEMPOTENT}, + {"MKNOD", NFS3_MKNOD, nfs3svc_mknod, NULL, 0, DRC_NON_IDEMPOTENT}, + {"REMOVE", NFS3_REMOVE, nfs3svc_remove, NULL, 0, DRC_NON_IDEMPOTENT}, + {"RMDIR", NFS3_RMDIR, nfs3svc_rmdir, NULL, 0, DRC_NON_IDEMPOTENT}, + {"RENAME", NFS3_RENAME, nfs3svc_rename, NULL, 0, DRC_NON_IDEMPOTENT}, + {"LINK", NFS3_LINK, nfs3svc_link, NULL, 0, DRC_NON_IDEMPOTENT}, + {"READDIR", NFS3_READDIR, nfs3svc_readdir, NULL, 0, DRC_IDEMPOTENT}, + {"READDIRPLUS", NFS3_READDIRP, nfs3svc_readdirp, NULL, 0, DRC_IDEMPOTENT}, + {"FSSTAT", NFS3_FSSTAT, nfs3svc_fsstat, NULL, 0, DRC_IDEMPOTENT}, + {"FSINFO", NFS3_FSINFO, nfs3svc_fsinfo, NULL, 0, DRC_IDEMPOTENT}, + {"PATHCONF", NFS3_PATHCONF, nfs3svc_pathconf, NULL, 0, DRC_IDEMPOTENT}, + {"COMMIT", NFS3_COMMIT, nfs3svc_commit, NULL, 0, DRC_IDEMPOTENT}}; + +rpcsvc_program_t nfs3prog = { + .progname = "NFS3", + .prognum = NFS_PROGRAM, + .progver = NFS_V3, + .progport = GF_NFS3_PORT, + .actors = nfs3svc_actors, + .numactors = NFS3_PROC_COUNT, + + /* Requests like FSINFO are sent before an auth scheme + * is inited by client. See RFC 2623, Section 2.3.2. */ + .min_auth = AUTH_NULL, }; /* @@ -5390,504 +5235,503 @@ rpcsvc_program_t nfs3prog = { * 1MB (GF_NFS3_FILE_IO_SIZE_MAX). */ void -nfs3_iosize_roundup_4KB (uint64_t *ioszptr) +nfs3_iosize_roundup_4KB(uint64_t *ioszptr) { - uint64_t iosize; - uint64_t iopages; - - if (!ioszptr) - return; - - iosize = *ioszptr; - iopages = (iosize + GF_NFS3_IO_SIZE -1) >> GF_NFS3_IO_SHIFT; - iosize = (iopages * GF_NFS3_IO_SIZE); - - /* Double check - boundary conditions */ - if (iosize < GF_NFS3_FILE_IO_SIZE_MIN) { - iosize = GF_NFS3_FILE_IO_SIZE_MIN; - } else if (iosize > GF_NFS3_FILE_IO_SIZE_MAX) { - iosize = GF_NFS3_FILE_IO_SIZE_MAX; - } + uint64_t iosize; + uint64_t iopages; - *ioszptr = iosize; -} - -int -nfs3_init_options (struct nfs3_state *nfs3, dict_t *options) -{ - int ret = -1; - char *optstr = NULL; - uint64_t size64 = 0; - - if ((!nfs3) || (!options)) - return -1; - - /* nfs3.read-size */ - nfs3->readsize = GF_NFS3_RTPREF; - if (dict_get (options, "nfs3.read-size")) { - ret = dict_get_str (options, "nfs3.read-size", &optstr); - if (ret < 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, - "Failed to read option: nfs3.read-size"); - ret = -1; - goto err; - } - - ret = gf_string2uint64 (optstr, &size64); - if (ret == -1) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_FORMAT_FAIL, - "Failed to format option: nfs3.read-size"); - ret = -1; - goto err; - } - - nfs3_iosize_roundup_4KB (&size64); - nfs3->readsize = size64; - } - - /* nfs3.write-size */ - nfs3->writesize = GF_NFS3_WTPREF; - if (dict_get (options, "nfs3.write-size")) { - ret = dict_get_str (options, "nfs3.write-size", &optstr); - if (ret < 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, - "Failed to read option: nfs3.write-size"); - ret = -1; - goto err; - } - - ret = gf_string2uint64 (optstr, &size64); - if (ret == -1) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_FORMAT_FAIL, - "Failed to format option: nfs3.write-size"); - ret = -1; - goto err; - } - - nfs3_iosize_roundup_4KB (&size64); - nfs3->writesize = size64; - } + if (!ioszptr) + return; - /* nfs3.readdir.size */ - nfs3->readdirsize = GF_NFS3_DTPREF; - if (dict_get (options, "nfs3.readdir-size")) { - ret = dict_get_str (options,"nfs3.readdir-size", &optstr); - if (ret < 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, - "Failed to read option: nfs3.readdir-size"); - ret = -1; - goto err; - } - - ret = gf_string2uint64 (optstr, &size64); - if (ret == -1) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_FORMAT_FAIL, - "Failed to format option: nfs3.readdir-size"); - ret = -1; - goto err; - } - - nfs3_iosize_roundup_4KB (&size64); - nfs3->readdirsize = size64; - } + iosize = *ioszptr; + iopages = (iosize + GF_NFS3_IO_SIZE - 1) >> GF_NFS3_IO_SHIFT; + iosize = (iopages * GF_NFS3_IO_SIZE); - /* We want to use the size of the biggest param for the io buffer size. - */ - nfs3->iobsize = nfs3->readsize; - if (nfs3->iobsize < nfs3->writesize) - nfs3->iobsize = nfs3->writesize; - if (nfs3->iobsize < nfs3->readdirsize) - nfs3->iobsize = nfs3->readdirsize; + /* Double check - boundary conditions */ + if (iosize < GF_NFS3_FILE_IO_SIZE_MIN) { + iosize = GF_NFS3_FILE_IO_SIZE_MIN; + } else if (iosize > GF_NFS3_FILE_IO_SIZE_MAX) { + iosize = GF_NFS3_FILE_IO_SIZE_MAX; + } - /* But this is the true size of each iobuf. We need this size to - * accommodate the NFS headers also in the same buffer. */ - nfs3->iobsize = nfs3->iobsize * 2; - - ret = 0; -err: - return ret; + *ioszptr = iosize; } int -nfs3_init_subvolume_options (xlator_t *nfsx, - struct nfs3_export *exp, - dict_t *options) +nfs3_init_options(struct nfs3_state *nfs3, dict_t *options) { - int ret = -1; - char *optstr = NULL; - char searchkey[1024]; - char *name = NULL; - gf_boolean_t boolt = _gf_false; - uuid_t volumeid = {0, }; + int ret = -1; + char *optstr = NULL; + uint64_t size64 = 0; - if ((!nfsx) || (!exp)) - return -1; + if ((!nfs3) || (!options)) + return -1; - /* For init, fetch options from xlator but for - * reconfigure, take the parameter */ - if (!options) - options = nfsx->options; - - if (!options) - return (-1); - - gf_uuid_clear (volumeid); - if (gf_nfs_dvm_off (nfs_state (nfsx))) - goto no_dvm; - - ret = snprintf (searchkey, sizeof (searchkey), "nfs3.%s.volume-id",exp->subvol->name); + /* nfs3.read-size */ + nfs3->readsize = GF_NFS3_RTPREF; + if (dict_get(options, "nfs3.read-size")) { + ret = dict_get_str(options, "nfs3.read-size", &optstr); if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SNPRINTF_FAIL, - "snprintf failed"); - ret = -1; - goto err; + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, + "Failed to read option: nfs3.read-size"); + ret = -1; + goto err; } - if (dict_get (options, searchkey)) { - ret = dict_get_str (options, searchkey, &optstr); - if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, - "Failed to read option: %s", searchkey); - ret = -1; - goto err; - } - } else { - gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_VOLID_MISSING, "DVM is" - " on but volume-id not given for volume: %s", - exp->subvol->name); - ret = -1; - goto err; + ret = gf_string2uint64(optstr, &size64); + if (ret == -1) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_FORMAT_FAIL, + "Failed to format option: nfs3.read-size"); + ret = -1; + goto err; } - if (optstr) { - ret = gf_uuid_parse (optstr, volumeid); - if (ret < 0) { - gf_msg (GF_MNT, GF_LOG_ERROR, 0, - NFS_MSG_PARSE_VOL_UUID_FAIL, - "Failed to parse volume UUID"); - ret = -1; - goto err; - } - gf_uuid_copy (exp->volumeid, volumeid); - } + nfs3_iosize_roundup_4KB(&size64); + nfs3->readsize = size64; + } -no_dvm: - /* Volume Access */ - name = exp->subvol->name; - ret = snprintf (searchkey, sizeof (searchkey), "nfs3.%s.volume-access", name); + /* nfs3.write-size */ + nfs3->writesize = GF_NFS3_WTPREF; + if (dict_get(options, "nfs3.write-size")) { + ret = dict_get_str(options, "nfs3.write-size", &optstr); if (ret < 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SNPRINTF_FAIL, - "snprintf failed"); - ret = -1; - goto err; + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, + "Failed to read option: nfs3.write-size"); + ret = -1; + goto err; } - exp->access = GF_NFS3_DEFAULT_VOLACCESS; - if (dict_get (options, searchkey)) { - ret = dict_get_str (options, searchkey, &optstr); - if (ret < 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, - "Failed to read option: %s", searchkey); - ret = -1; - goto err; - } - - if (strcmp (optstr, "read-only") == 0) - exp->access = GF_NFS3_VOLACCESS_RO; + ret = gf_string2uint64(optstr, &size64); + if (ret == -1) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_FORMAT_FAIL, + "Failed to format option: nfs3.write-size"); + ret = -1; + goto err; } - ret = snprintf (searchkey, sizeof (searchkey), "rpc-auth.%s.unix", name); + nfs3_iosize_roundup_4KB(&size64); + nfs3->writesize = size64; + } + + /* nfs3.readdir.size */ + nfs3->readdirsize = GF_NFS3_DTPREF; + if (dict_get(options, "nfs3.readdir-size")) { + ret = dict_get_str(options, "nfs3.readdir-size", &optstr); if (ret < 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SNPRINTF_FAIL, - "snprintf failed"); - ret = -1; - goto err; + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, + "Failed to read option: nfs3.readdir-size"); + ret = -1; + goto err; } - if (dict_get (options, searchkey)) { - ret = dict_get_str (options, searchkey, &optstr); - if (ret < 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, - "Failed to read option: %s", searchkey); - ret = -1; - goto err; - } + ret = gf_string2uint64(optstr, &size64); + if (ret == -1) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_FORMAT_FAIL, + "Failed to format option: nfs3.readdir-size"); + ret = -1; + goto err; } - exp->trusted_sync = 0; - ret = snprintf (searchkey, sizeof (searchkey), "nfs3.%s.trusted-sync", name); - if (ret < 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SNPRINTF_FAIL, - "snprintf failed"); - ret = -1; - goto err; - } + nfs3_iosize_roundup_4KB(&size64); + nfs3->readdirsize = size64; + } - if (dict_get (options, searchkey)) { - ret = dict_get_str (options, searchkey, &optstr); - if (ret < 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, - "Failed to read option: %s", searchkey); - ret = -1; - goto err; - } - - ret = gf_string2boolean (optstr, &boolt); - if (ret < 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, - NFS_MSG_STR2BOOL_FAIL, "Failed to convert str " - "to gf_boolean_t"); - ret = -1; - goto err; - } - - if (boolt == _gf_true) - exp->trusted_sync = 1; - } + /* We want to use the size of the biggest param for the io buffer size. + */ + nfs3->iobsize = nfs3->readsize; + if (nfs3->iobsize < nfs3->writesize) + nfs3->iobsize = nfs3->writesize; + if (nfs3->iobsize < nfs3->readdirsize) + nfs3->iobsize = nfs3->readdirsize; - exp->trusted_write = 0; - ret = snprintf (searchkey, sizeof (searchkey), "nfs3.%s.trusted-write", name); + /* But this is the true size of each iobuf. We need this size to + * accommodate the NFS headers also in the same buffer. */ + nfs3->iobsize = nfs3->iobsize * 2; + + ret = 0; +err: + return ret; +} + +int +nfs3_init_subvolume_options(xlator_t *nfsx, struct nfs3_export *exp, + dict_t *options) +{ + int ret = -1; + char *optstr = NULL; + char searchkey[1024]; + char *name = NULL; + gf_boolean_t boolt = _gf_false; + uuid_t volumeid = { + 0, + }; + + if ((!nfsx) || (!exp)) + return -1; + + /* For init, fetch options from xlator but for + * reconfigure, take the parameter */ + if (!options) + options = nfsx->options; + + if (!options) + return (-1); + + gf_uuid_clear(volumeid); + if (gf_nfs_dvm_off(nfs_state(nfsx))) + goto no_dvm; + + ret = snprintf(searchkey, sizeof(searchkey), "nfs3.%s.volume-id", + exp->subvol->name); + if (ret < 0) { + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SNPRINTF_FAIL, + "snprintf failed"); + ret = -1; + goto err; + } + + if (dict_get(options, searchkey)) { + ret = dict_get_str(options, searchkey, &optstr); if (ret < 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SNPRINTF_FAIL, - "snprintf failed"); - ret = -1; - goto err; + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, + "Failed to read option: %s", searchkey); + ret = -1; + goto err; + } + } else { + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_VOLID_MISSING, + "DVM is" + " on but volume-id not given for volume: %s", + exp->subvol->name); + ret = -1; + goto err; + } + + if (optstr) { + ret = gf_uuid_parse(optstr, volumeid); + if (ret < 0) { + gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_PARSE_VOL_UUID_FAIL, + "Failed to parse volume UUID"); + ret = -1; + goto err; } + gf_uuid_copy(exp->volumeid, volumeid); + } - if (dict_get (options, searchkey)) { - ret = dict_get_str (options, searchkey, &optstr); - if (ret < 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, - "Failed to read option: %s", searchkey); - ret = -1; - goto err; - } - - ret = gf_string2boolean (optstr, &boolt); - if (ret < 0) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, - NFS_MSG_STR2BOOL_FAIL, "Failed to convert str" - " to gf_boolean_t"); - ret = -1; - goto err; - } - - if (boolt == _gf_true) - exp->trusted_write = 1; +no_dvm: + /* Volume Access */ + name = exp->subvol->name; + ret = snprintf(searchkey, sizeof(searchkey), "nfs3.%s.volume-access", name); + if (ret < 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SNPRINTF_FAIL, + "snprintf failed"); + ret = -1; + goto err; + } + + exp->access = GF_NFS3_DEFAULT_VOLACCESS; + if (dict_get(options, searchkey)) { + ret = dict_get_str(options, searchkey, &optstr); + if (ret < 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, + "Failed to read option: %s", searchkey); + ret = -1; + goto err; + } + + if (strcmp(optstr, "read-only") == 0) + exp->access = GF_NFS3_VOLACCESS_RO; + } + + ret = snprintf(searchkey, sizeof(searchkey), "rpc-auth.%s.unix", name); + if (ret < 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SNPRINTF_FAIL, + "snprintf failed"); + ret = -1; + goto err; + } + + if (dict_get(options, searchkey)) { + ret = dict_get_str(options, searchkey, &optstr); + if (ret < 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, + "Failed to read option: %s", searchkey); + ret = -1; + goto err; + } + } + + exp->trusted_sync = 0; + ret = snprintf(searchkey, sizeof(searchkey), "nfs3.%s.trusted-sync", name); + if (ret < 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SNPRINTF_FAIL, + "snprintf failed"); + ret = -1; + goto err; + } + + if (dict_get(options, searchkey)) { + ret = dict_get_str(options, searchkey, &optstr); + if (ret < 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, + "Failed to read option: %s", searchkey); + ret = -1; + goto err; } - /* If trusted-sync is on, then we also switch on trusted-write because - * tw is included in ts. In write logic, we're then only checking for - * tw. - */ - if (exp->trusted_sync) - exp->trusted_write = 1; + ret = gf_string2boolean(optstr, &boolt); + if (ret < 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_STR2BOOL_FAIL, + "Failed to convert str " + "to gf_boolean_t"); + ret = -1; + goto err; + } + + if (boolt == _gf_true) + exp->trusted_sync = 1; + } + + exp->trusted_write = 0; + ret = snprintf(searchkey, sizeof(searchkey), "nfs3.%s.trusted-write", name); + if (ret < 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SNPRINTF_FAIL, + "snprintf failed"); + ret = -1; + goto err; + } + + if (dict_get(options, searchkey)) { + ret = dict_get_str(options, searchkey, &optstr); + if (ret < 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL, + "Failed to read option: %s", searchkey); + ret = -1; + goto err; + } - gf_msg_trace (GF_NFS3, 0, "%s: %s, %s, %s", exp->subvol->name, - (exp->access == GF_NFS3_VOLACCESS_RO)?"read-only":"read-write", - (exp->trusted_sync == 0)?"no trusted_sync":"trusted_sync", - (exp->trusted_write == 0)?"no trusted_write":"trusted_write"); - ret = 0; + ret = gf_string2boolean(optstr, &boolt); + if (ret < 0) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_STR2BOOL_FAIL, + "Failed to convert str" + " to gf_boolean_t"); + ret = -1; + goto err; + } + + if (boolt == _gf_true) + exp->trusted_write = 1; + } + + /* If trusted-sync is on, then we also switch on trusted-write because + * tw is included in ts. In write logic, we're then only checking for + * tw. + */ + if (exp->trusted_sync) + exp->trusted_write = 1; + + gf_msg_trace( + GF_NFS3, 0, "%s: %s, %s, %s", exp->subvol->name, + (exp->access == GF_NFS3_VOLACCESS_RO) ? "read-only" : "read-write", + (exp->trusted_sync == 0) ? "no trusted_sync" : "trusted_sync", + (exp->trusted_write == 0) ? "no trusted_write" : "trusted_write"); + ret = 0; err: - return ret; + return ret; } - struct nfs3_export * -nfs3_init_subvolume (struct nfs3_state *nfs3, xlator_t *subvol) +nfs3_init_subvolume(struct nfs3_state *nfs3, xlator_t *subvol) { - int ret = -1; - struct nfs3_export *exp = NULL; + int ret = -1; + struct nfs3_export *exp = NULL; - if ((!nfs3) || (!subvol)) - return NULL; + if ((!nfs3) || (!subvol)) + return NULL; - exp = GF_CALLOC (1, sizeof (*exp), gf_nfs_mt_nfs3_export); - exp->subvol = subvol; - INIT_LIST_HEAD (&exp->explist); - gf_msg_trace (GF_NFS3, 0, "Initing state: %s", exp->subvol->name); + exp = GF_CALLOC(1, sizeof(*exp), gf_nfs_mt_nfs3_export); + exp->subvol = subvol; + INIT_LIST_HEAD(&exp->explist); + gf_msg_trace(GF_NFS3, 0, "Initing state: %s", exp->subvol->name); - ret = nfs3_init_subvolume_options (nfs3->nfsx, exp, NULL); - if (ret == -1) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SUBVOL_INIT_FAIL, - "Failed to init subvol"); - goto exp_free; - } + ret = nfs3_init_subvolume_options(nfs3->nfsx, exp, NULL); + if (ret == -1) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SUBVOL_INIT_FAIL, + "Failed to init subvol"); + goto exp_free; + } - ret = 0; + ret = 0; exp_free: - if (ret < 0) { - GF_FREE (exp); - exp = NULL; - } + if (ret < 0) { + GF_FREE(exp); + exp = NULL; + } - return exp; + return exp; } - int -nfs3_init_subvolumes (struct nfs3_state *nfs3) -{ - int ret = -1; - struct xlator_list *xl_list = NULL; - struct nfs3_export *exp = NULL; - - if (!nfs3) - return -1; - - xl_list = nfs3->nfsx->children; - - while (xl_list) { - exp = nfs3_init_subvolume (nfs3, xl_list->xlator); - if (!exp) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, - NFS_MSG_SUBVOL_INIT_FAIL, "Failed to init " - "subvol: %s", xl_list->xlator->name); - goto err; - } - list_add_tail (&exp->explist, &nfs3->exports); - xl_list = xl_list->next; - } - - ret = 0; -err: - return ret; -} - - -struct nfs3_state * -nfs3_init_state (xlator_t *nfsx) -{ - struct nfs3_state *nfs3 = NULL; - int ret = -1; - unsigned int localpool = 0; - struct nfs_state *nfs = NULL; - - if ((!nfsx) || (!nfsx->private)) - return NULL; - - nfs3 = (struct nfs3_state *)GF_CALLOC (1, sizeof (*nfs3), - gf_nfs_mt_nfs3_state); - if (!nfs3) { - gf_msg (GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Memory allocation failed"); - return NULL; - } +nfs3_init_subvolumes(struct nfs3_state *nfs3) +{ + int ret = -1; + struct xlator_list *xl_list = NULL; + struct nfs3_export *exp = NULL; - nfs = nfsx->private; - ret = nfs3_init_options (nfs3, nfsx->options); - if (ret == -1) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_OPT_INIT_FAIL, - "Failed to init options"); - goto ret; - } + if (!nfs3) + return -1; - nfs3->iobpool = nfsx->ctx->iobuf_pool; - - localpool = nfs->memfactor * GF_NFS_CONCURRENT_OPS_MULT; - gf_msg_trace (GF_NFS3, 0, "local pool: %d", localpool); - nfs3->localpool = mem_pool_new_ctx (nfsx->ctx, nfs3_call_state_t, - localpool); - if (!nfs3->localpool) { - gf_msg (GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "local mempool creation failed"); - ret = -1; - goto ret; - } + xl_list = nfs3->nfsx->children; - nfs3->nfsx = nfsx; - nfs3->exportslist = nfsx->children; - INIT_LIST_HEAD (&nfs3->exports); - ret = nfs3_init_subvolumes (nfs3); - if (ret == -1) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SUBVOL_INIT_FAIL, - "Failed to init per-subvolume state"); - goto free_localpool; + while (xl_list) { + exp = nfs3_init_subvolume(nfs3, xl_list->xlator); + if (!exp) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SUBVOL_INIT_FAIL, + "Failed to init " + "subvol: %s", + xl_list->xlator->name); + goto err; } + list_add_tail(&exp->explist, &nfs3->exports); + xl_list = xl_list->next; + } - nfs3->serverstart = (uint64_t)time (NULL); - INIT_LIST_HEAD (&nfs3->fdlru); - LOCK_INIT (&nfs3->fdlrulock); - nfs3->fdcount = 0; - - ret = rpcsvc_create_listeners (nfs->rpcsvc, nfsx->options, nfsx->name); - if (ret == -1) { - gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_LISTENERS_CREATE_FAIL, - "Unable to create listeners"); - goto free_localpool; - } + ret = 0; +err: + return ret; +} - nfs->nfs3state = nfs3; - ret = 0; +struct nfs3_state * +nfs3_init_state(xlator_t *nfsx) +{ + struct nfs3_state *nfs3 = NULL; + int ret = -1; + unsigned int localpool = 0; + struct nfs_state *nfs = NULL; + + if ((!nfsx) || (!nfsx->private)) + return NULL; + + nfs3 = (struct nfs3_state *)GF_CALLOC(1, sizeof(*nfs3), + gf_nfs_mt_nfs3_state); + if (!nfs3) { + gf_msg(GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); + return NULL; + } + + nfs = nfsx->private; + ret = nfs3_init_options(nfs3, nfsx->options); + if (ret == -1) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_OPT_INIT_FAIL, + "Failed to init options"); + goto ret; + } + + nfs3->iobpool = nfsx->ctx->iobuf_pool; + + localpool = nfs->memfactor * GF_NFS_CONCURRENT_OPS_MULT; + gf_msg_trace(GF_NFS3, 0, "local pool: %d", localpool); + nfs3->localpool = mem_pool_new_ctx(nfsx->ctx, nfs3_call_state_t, localpool); + if (!nfs3->localpool) { + gf_msg(GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "local mempool creation failed"); + ret = -1; + goto ret; + } + + nfs3->nfsx = nfsx; + nfs3->exportslist = nfsx->children; + INIT_LIST_HEAD(&nfs3->exports); + ret = nfs3_init_subvolumes(nfs3); + if (ret == -1) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SUBVOL_INIT_FAIL, + "Failed to init per-subvolume state"); + goto free_localpool; + } + + nfs3->serverstart = (uint64_t)time(NULL); + INIT_LIST_HEAD(&nfs3->fdlru); + LOCK_INIT(&nfs3->fdlrulock); + nfs3->fdcount = 0; + + ret = rpcsvc_create_listeners(nfs->rpcsvc, nfsx->options, nfsx->name); + if (ret == -1) { + gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_LISTENERS_CREATE_FAIL, + "Unable to create listeners"); + goto free_localpool; + } + + nfs->nfs3state = nfs3; + ret = 0; free_localpool: - if (ret == -1) - mem_pool_destroy (nfs3->localpool); + if (ret == -1) + mem_pool_destroy(nfs3->localpool); ret: - if (ret == -1) { - GF_FREE (nfs3); - nfs3 = NULL; - } + if (ret == -1) { + GF_FREE(nfs3); + nfs3 = NULL; + } - return nfs3; + return nfs3; } - rpcsvc_program_t * -nfs3svc_init (xlator_t *nfsx) +nfs3svc_init(xlator_t *nfsx) { - struct nfs3_state *nfs3 = NULL; + struct nfs3_state *nfs3 = NULL; - if (!nfsx) - return NULL; + if (!nfsx) + return NULL; - nfs3 = nfs3_init_state (nfsx); - if (!nfs3) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_STATE_INIT_FAIL, - "NFSv3 state init failed"); - return NULL; - } + nfs3 = nfs3_init_state(nfsx); + if (!nfs3) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_STATE_INIT_FAIL, + "NFSv3 state init failed"); + return NULL; + } - nfs3prog.private = nfs3; + nfs3prog.private = nfs3; - return &nfs3prog; + return &nfs3prog; } int -nfs3_reconfigure_state (xlator_t *nfsx, dict_t *options) -{ - int ret = -1; - struct nfs3_export *exp = NULL; - struct nfs_state *nfs = NULL; - struct nfs3_state *nfs3 = NULL; - - if ((!nfsx) || (!nfsx->private) || (!options)) - goto out; - - nfs = (struct nfs_state *)nfsx->private; - nfs3 = nfs->nfs3state; - if (!nfs3) - goto out; - - ret = nfs3_init_options (nfs3, options); +nfs3_reconfigure_state(xlator_t *nfsx, dict_t *options) +{ + int ret = -1; + struct nfs3_export *exp = NULL; + struct nfs_state *nfs = NULL; + struct nfs3_state *nfs3 = NULL; + + if ((!nfsx) || (!nfsx->private) || (!options)) + goto out; + + nfs = (struct nfs_state *)nfsx->private; + nfs3 = nfs->nfs3state; + if (!nfs3) + goto out; + + ret = nfs3_init_options(nfs3, options); + if (ret) { + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_RECONF_FAIL, + "Failed to reconfigure options"); + goto out; + } + + list_for_each_entry(exp, &nfs3->exports, explist) + { + ret = nfs3_init_subvolume_options(nfsx, exp, options); if (ret) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_RECONF_FAIL, - "Failed to reconfigure options"); - goto out; + gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_RECONF_SUBVOL_FAIL, + "Failed to reconfigure subvol options"); + goto out; } + } - list_for_each_entry (exp, &nfs3->exports, explist) { - ret = nfs3_init_subvolume_options (nfsx, exp, options); - if (ret) { - gf_msg (GF_NFS3, GF_LOG_ERROR, 0, - NFS_MSG_RECONF_SUBVOL_FAIL, - "Failed to reconfigure subvol options"); - goto out; - } - } - - ret = 0; + ret = 0; out: - return ret; + return ret; } diff --git a/xlators/nfs/server/src/nlm4.c b/xlators/nfs/server/src/nlm4.c index 0c81068902..0989f47f92 100644 --- a/xlators/nfs/server/src/nlm4.c +++ b/xlators/nfs/server/src/nlm4.c @@ -43,12 +43,13 @@ * 2) use GF_REF_* for nlm_clnt_t */ -typedef ssize_t (*nlm4_serializer) (struct iovec outmsg, void *args); +typedef ssize_t (*nlm4_serializer)(struct iovec outmsg, void *args); -extern void nfs3_call_state_wipe (nfs3_call_state_t *cs); +extern void +nfs3_call_state_wipe(nfs3_call_state_t *cs); nfs3_call_state_t * -nfs3_call_state_init (struct nfs3_state *s, rpcsvc_request_t *req, xlator_t *v); +nfs3_call_state_init(struct nfs3_state *s, rpcsvc_request_t *req, xlator_t *v); struct list_head nlm_client_list; gf_lock_t nlm_client_list_lk; @@ -56,2038 +57,2034 @@ gf_lock_t nlm_client_list_lk; /* race on this is harmless */ int nlm_grace_period = 50; -#define nlm4_validate_nfs3_state(request, state, status, label, retval) \ - do { \ - state = rpcsvc_request_program_private (request); \ - if (!state) { \ - gf_msg (GF_NLM, GF_LOG_ERROR, errno, \ - NFS_MSG_STATE_MISSING, "NFSv3 state " \ - "missing from RPC request"); \ - rpcsvc_request_seterr (req, SYSTEM_ERR); \ - status = nlm4_failed; \ - goto label; \ - } \ - } while (0); \ - -#define nlm4_handle_call_state_init(nfs3state, calls, rq, opstat, errlabel)\ - do { \ - calls = nlm4_call_state_init ((nfs3state), (rq)); \ - if (!calls) { \ - gf_msg (GF_NLM, GF_LOG_ERROR, errno, \ - NFS_MSG_INIT_CALL_STAT_FAIL, "Failed to "\ - "init call state"); \ - opstat = nlm4_failed; \ - rpcsvc_request_seterr (req, SYSTEM_ERR); \ - goto errlabel; \ - } \ - } while (0) \ - -#define nlm4_validate_gluster_fh(handle, status, errlabel) \ - do { \ - if (!nfs3_fh_validate (handle)) { \ - status = nlm4_stale_fh; \ - goto errlabel; \ - } \ - } while (0) \ +#define nlm4_validate_nfs3_state(request, state, status, label, retval) \ + do { \ + state = rpcsvc_request_program_private(request); \ + if (!state) { \ + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_STATE_MISSING, \ + "NFSv3 state " \ + "missing from RPC request"); \ + rpcsvc_request_seterr(req, SYSTEM_ERR); \ + status = nlm4_failed; \ + goto label; \ + } \ + } while (0); + +#define nlm4_handle_call_state_init(nfs3state, calls, rq, opstat, errlabel) \ + do { \ + calls = nlm4_call_state_init((nfs3state), (rq)); \ + if (!calls) { \ + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_INIT_CALL_STAT_FAIL, \ + "Failed to " \ + "init call state"); \ + opstat = nlm4_failed; \ + rpcsvc_request_seterr(req, SYSTEM_ERR); \ + goto errlabel; \ + } \ + } while (0) + +#define nlm4_validate_gluster_fh(handle, status, errlabel) \ + do { \ + if (!nfs3_fh_validate(handle)) { \ + status = nlm4_stale_fh; \ + goto errlabel; \ + } \ + } while (0) xlator_t * -nfs3_fh_to_xlator (struct nfs3_state *nfs3, struct nfs3_fh *fh); - -#define nlm4_map_fh_to_volume(nfs3state, handle, req, volume, status, label) \ - do { \ - char exportid[256], gfid[256]; \ - rpc_transport_t *trans = NULL; \ - volume = nfs3_fh_to_xlator ((nfs3state), &handle); \ - if (!volume) { \ - gf_uuid_unparse (handle.exportid, exportid); \ - gf_uuid_unparse (handle.gfid, gfid); \ - trans = rpcsvc_request_transport (req); \ - gf_msg (GF_NLM, GF_LOG_ERROR, errno, \ - NFS_MSG_FH_TO_VOL_FAIL, "Failed to map " \ - "FH to vol: client=%s, exportid=%s, gfid=%s",\ - trans->peerinfo.identifier, exportid, \ - gfid); \ - gf_msg (GF_NLM, GF_LOG_ERROR, errno, \ - NFS_MSG_VOLUME_ERROR, \ - "Stale nfs client %s must be trying to "\ - "connect to a deleted volume, please " \ - "unmount it.", trans->peerinfo.identifier);\ - status = nlm4_stale_fh; \ - goto label; \ - } else { \ - gf_msg_trace (GF_NLM, 0, "FH to Volume: %s" \ - , volume->name); \ - rpcsvc_request_set_private (req, volume); \ - } \ - } while (0); \ - -#define nlm4_volume_started_check(nfs3state, vlm, rtval, erlbl) \ - do { \ - if ((!nfs_subvolume_started (nfs_state (nfs3state->nfsx), vlm))){\ - gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_VOL_DISABLE, \ - "Volume is disabled: %s", \ - vlm->name); \ - rtval = RPCSVC_ACTOR_IGNORE; \ - goto erlbl; \ - } \ - } while (0) \ - -#define nlm4_check_fh_resolve_status(cst, nfstat, erlabl) \ - do { \ - xlator_t *xlatorp = NULL; \ - char buf[256], gfid[GF_UUID_BUF_SIZE]; \ - rpc_transport_t *trans = NULL; \ - if ((cst)->resolve_ret < 0) { \ - trans = rpcsvc_request_transport (cst->req); \ - xlatorp = nfs3_fh_to_xlator (cst->nfs3state, \ - &cst->resolvefh); \ - gf_uuid_unparse (cst->resolvefh.gfid, gfid); \ - snprintf (buf, sizeof (buf), "(%s) %s : %s", \ - trans->peerinfo.identifier, \ - xlatorp ? xlatorp->name : "ERR", \ - gfid); \ - gf_msg (GF_NLM, GF_LOG_ERROR, 0, \ - NFS_MSG_RESOLVE_FH_FAIL, "Unable to resolve FH"\ - ": %s", buf); \ - nfstat = nlm4_errno_to_nlm4stat (cst->resolve_errno);\ - goto erlabl; \ - } \ - } while (0) \ - +nfs3_fh_to_xlator(struct nfs3_state *nfs3, struct nfs3_fh *fh); + +#define nlm4_map_fh_to_volume(nfs3state, handle, req, volume, status, label) \ + do { \ + char exportid[256], gfid[256]; \ + rpc_transport_t *trans = NULL; \ + volume = nfs3_fh_to_xlator((nfs3state), &handle); \ + if (!volume) { \ + gf_uuid_unparse(handle.exportid, exportid); \ + gf_uuid_unparse(handle.gfid, gfid); \ + trans = rpcsvc_request_transport(req); \ + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_FH_TO_VOL_FAIL, \ + "Failed to map " \ + "FH to vol: client=%s, exportid=%s, gfid=%s", \ + trans->peerinfo.identifier, exportid, gfid); \ + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_VOLUME_ERROR, \ + "Stale nfs client %s must be trying to " \ + "connect to a deleted volume, please " \ + "unmount it.", \ + trans->peerinfo.identifier); \ + status = nlm4_stale_fh; \ + goto label; \ + } else { \ + gf_msg_trace(GF_NLM, 0, "FH to Volume: %s", volume->name); \ + rpcsvc_request_set_private(req, volume); \ + } \ + } while (0); + +#define nlm4_volume_started_check(nfs3state, vlm, rtval, erlbl) \ + do { \ + if ((!nfs_subvolume_started(nfs_state(nfs3state->nfsx), vlm))) { \ + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_VOL_DISABLE, \ + "Volume is disabled: %s", vlm->name); \ + rtval = RPCSVC_ACTOR_IGNORE; \ + goto erlbl; \ + } \ + } while (0) + +#define nlm4_check_fh_resolve_status(cst, nfstat, erlabl) \ + do { \ + xlator_t *xlatorp = NULL; \ + char buf[256], gfid[GF_UUID_BUF_SIZE]; \ + rpc_transport_t *trans = NULL; \ + if ((cst)->resolve_ret < 0) { \ + trans = rpcsvc_request_transport(cst->req); \ + xlatorp = nfs3_fh_to_xlator(cst->nfs3state, &cst->resolvefh); \ + gf_uuid_unparse(cst->resolvefh.gfid, gfid); \ + snprintf(buf, sizeof(buf), "(%s) %s : %s", \ + trans->peerinfo.identifier, \ + xlatorp ? xlatorp->name : "ERR", gfid); \ + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_RESOLVE_FH_FAIL, \ + "Unable to resolve FH" \ + ": %s", \ + buf); \ + nfstat = nlm4_errno_to_nlm4stat(cst->resolve_errno); \ + goto erlabl; \ + } \ + } while (0) void -nlm4_prep_nlm4_testargs (nlm4_testargs *args, struct nfs3_fh *fh, - nlm4_lkowner_t *oh, char *cookiebytes) +nlm4_prep_nlm4_testargs(nlm4_testargs *args, struct nfs3_fh *fh, + nlm4_lkowner_t *oh, char *cookiebytes) { - memset (args, 0, sizeof (*args)); - args->alock.fh.nlm4_netobj_val = (void *)fh; - args->alock.oh.nlm4_netobj_val = (void *)oh; - args->cookie.nlm4_netobj_val = (void *)cookiebytes; + memset(args, 0, sizeof(*args)); + args->alock.fh.nlm4_netobj_val = (void *)fh; + args->alock.oh.nlm4_netobj_val = (void *)oh; + args->cookie.nlm4_netobj_val = (void *)cookiebytes; } void -nlm4_prep_nlm4_lockargs (nlm4_lockargs *args, struct nfs3_fh *fh, - nlm4_lkowner_t *oh, char *cookiebytes) +nlm4_prep_nlm4_lockargs(nlm4_lockargs *args, struct nfs3_fh *fh, + nlm4_lkowner_t *oh, char *cookiebytes) { - memset (args, 0, sizeof (*args)); - args->alock.fh.nlm4_netobj_val = (void *)fh; - args->alock.oh.nlm4_netobj_val = (void *)oh; - args->cookie.nlm4_netobj_val = (void *)cookiebytes; + memset(args, 0, sizeof(*args)); + args->alock.fh.nlm4_netobj_val = (void *)fh; + args->alock.oh.nlm4_netobj_val = (void *)oh; + args->cookie.nlm4_netobj_val = (void *)cookiebytes; } void -nlm4_prep_nlm4_cancargs (nlm4_cancargs *args, struct nfs3_fh *fh, - nlm4_lkowner_t *oh, char *cookiebytes) +nlm4_prep_nlm4_cancargs(nlm4_cancargs *args, struct nfs3_fh *fh, + nlm4_lkowner_t *oh, char *cookiebytes) { - memset (args, 0, sizeof (*args)); - args->alock.fh.nlm4_netobj_val = (void *)fh; - args->alock.oh.nlm4_netobj_val = (void *)oh; - args->cookie.nlm4_netobj_val = (void *)cookiebytes; + memset(args, 0, sizeof(*args)); + args->alock.fh.nlm4_netobj_val = (void *)fh; + args->alock.oh.nlm4_netobj_val = (void *)oh; + args->cookie.nlm4_netobj_val = (void *)cookiebytes; } void -nlm4_prep_nlm4_unlockargs (nlm4_unlockargs *args, struct nfs3_fh *fh, - nlm4_lkowner_t *oh, char *cookiebytes) +nlm4_prep_nlm4_unlockargs(nlm4_unlockargs *args, struct nfs3_fh *fh, + nlm4_lkowner_t *oh, char *cookiebytes) { - memset (args, 0, sizeof (*args)); - args->alock.fh.nlm4_netobj_val = (void *)fh; - args->alock.oh.nlm4_netobj_val = (void *)oh; - args->cookie.nlm4_netobj_val = (void *)cookiebytes; + memset(args, 0, sizeof(*args)); + args->alock.fh.nlm4_netobj_val = (void *)fh; + args->alock.oh.nlm4_netobj_val = (void *)oh; + args->cookie.nlm4_netobj_val = (void *)cookiebytes; } void -nlm4_prep_shareargs (nlm4_shareargs *args, struct nfs3_fh *fh, - nlm4_lkowner_t *oh, char *cookiebytes) +nlm4_prep_shareargs(nlm4_shareargs *args, struct nfs3_fh *fh, + nlm4_lkowner_t *oh, char *cookiebytes) { - memset (args, 0, sizeof (*args)); - args->share.fh.nlm4_netobj_val = (void *)fh; - args->share.oh.nlm4_netobj_val = (void *)oh; - args->cookie.nlm4_netobj_val = (void *)cookiebytes; + memset(args, 0, sizeof(*args)); + args->share.fh.nlm4_netobj_val = (void *)fh; + args->share.oh.nlm4_netobj_val = (void *)oh; + args->cookie.nlm4_netobj_val = (void *)cookiebytes; } void -nlm4_prep_freeallargs (nlm4_freeallargs *args, nlm4_lkowner_t *oh) +nlm4_prep_freeallargs(nlm4_freeallargs *args, nlm4_lkowner_t *oh) { - memset (args, 0, sizeof (*args)); - args->name = (void *)oh; + memset(args, 0, sizeof(*args)); + args->name = (void *)oh; } void -nlm_copy_lkowner (gf_lkowner_t *dst, nlm4_netobj *src) +nlm_copy_lkowner(gf_lkowner_t *dst, nlm4_netobj *src) { - dst->len = src->nlm4_netobj_len; - memcpy (dst->data, src->nlm4_netobj_val, dst->len); + dst->len = src->nlm4_netobj_len; + memcpy(dst->data, src->nlm4_netobj_val, dst->len); } int -nlm_is_oh_same_lkowner (gf_lkowner_t *a, nlm4_netobj *b) +nlm_is_oh_same_lkowner(gf_lkowner_t *a, nlm4_netobj *b) { - if (!a || !b) { - gf_msg (GF_NLM, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "invalid args"); - return -1; - } + if (!a || !b) { + gf_msg(GF_NLM, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "invalid args"); + return -1; + } - return (a->len == b->nlm4_netobj_len && - !memcmp (a->data, b->nlm4_netobj_val, a->len)); + return (a->len == b->nlm4_netobj_len && + !memcmp(a->data, b->nlm4_netobj_val, a->len)); } nlm4_stats -nlm4_errno_to_nlm4stat (int errnum) +nlm4_errno_to_nlm4stat(int errnum) { - nlm4_stats stat = nlm4_denied; + nlm4_stats stat = nlm4_denied; - switch (errnum) { + switch (errnum) { case 0: - stat = nlm4_granted; - break; + stat = nlm4_granted; + break; case EROFS: - stat = nlm4_rofs; - break; + stat = nlm4_rofs; + break; case ESTALE: - stat = nlm4_stale_fh; - break; + stat = nlm4_stale_fh; + break; case ENOLCK: - stat = nlm4_failed; - break; + stat = nlm4_failed; + break; default: - stat = nlm4_denied; - break; - } + stat = nlm4_denied; + break; + } - return stat; + return stat; } nfs3_call_state_t * -nlm4_call_state_init (struct nfs3_state *s, rpcsvc_request_t *req) +nlm4_call_state_init(struct nfs3_state *s, rpcsvc_request_t *req) { - nfs3_call_state_t *cs = NULL; + nfs3_call_state_t *cs = NULL; - if ((!s) || (!req)) - return NULL; + if ((!s) || (!req)) + return NULL; - cs = nfs3_call_state_init (s, req, NULL); - if (!cs) - return NULL; + cs = nfs3_call_state_init(s, req, NULL); + if (!cs) + return NULL; - cs->monitor = 1; + cs->monitor = 1; - return cs; + return cs; } int -nlm_monitor (char *caller_name) -{ - nlm_client_t *nlmclnt = NULL; - int monitor = -1; - - LOCK (&nlm_client_list_lk); - list_for_each_entry (nlmclnt, &nlm_client_list, nlm_clients) { - if (!strcmp(caller_name, nlmclnt->caller_name)) { - monitor = nlmclnt->nsm_monitor; - nlmclnt->nsm_monitor = 1; - break; - } +nlm_monitor(char *caller_name) +{ + nlm_client_t *nlmclnt = NULL; + int monitor = -1; + + LOCK(&nlm_client_list_lk); + list_for_each_entry(nlmclnt, &nlm_client_list, nlm_clients) + { + if (!strcmp(caller_name, nlmclnt->caller_name)) { + monitor = nlmclnt->nsm_monitor; + nlmclnt->nsm_monitor = 1; + break; } - UNLOCK (&nlm_client_list_lk); + } + UNLOCK(&nlm_client_list_lk); - if (monitor == -1) - gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CALLER_NOT_FOUND, - "%s was not found in the nlmclnt list", caller_name); + if (monitor == -1) + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CALLER_NOT_FOUND, + "%s was not found in the nlmclnt list", caller_name); - return monitor; + return monitor; } rpc_clnt_t * -nlm_get_rpc_clnt (char *caller_name) -{ - nlm_client_t *nlmclnt = NULL; - int nlmclnt_found = 0; - rpc_clnt_t *rpc_clnt = NULL; - - LOCK (&nlm_client_list_lk); - list_for_each_entry (nlmclnt, &nlm_client_list, nlm_clients) { - if (!strcmp(caller_name, nlmclnt->caller_name)) { - nlmclnt_found = 1; - break; - } - } - if (!nlmclnt_found) - goto ret; - if (nlmclnt->rpc_clnt) - rpc_clnt = rpc_clnt_ref (nlmclnt->rpc_clnt); +nlm_get_rpc_clnt(char *caller_name) +{ + nlm_client_t *nlmclnt = NULL; + int nlmclnt_found = 0; + rpc_clnt_t *rpc_clnt = NULL; + + LOCK(&nlm_client_list_lk); + list_for_each_entry(nlmclnt, &nlm_client_list, nlm_clients) + { + if (!strcmp(caller_name, nlmclnt->caller_name)) { + nlmclnt_found = 1; + break; + } + } + if (!nlmclnt_found) + goto ret; + if (nlmclnt->rpc_clnt) + rpc_clnt = rpc_clnt_ref(nlmclnt->rpc_clnt); ret: - UNLOCK (&nlm_client_list_lk); - return rpc_clnt; + UNLOCK(&nlm_client_list_lk); + return rpc_clnt; } static void -nlm_client_free (nlm_client_t *nlmclnt) +nlm_client_free(nlm_client_t *nlmclnt) { - nlm_fde_t *fde = NULL, *tmp = NULL; + nlm_fde_t *fde = NULL, *tmp = NULL; - gf_msg_trace (GF_NLM, 0, "removing nlm-client %s from the list", - nlmclnt->caller_name); + gf_msg_trace(GF_NLM, 0, "removing nlm-client %s from the list", + nlmclnt->caller_name); - list_for_each_entry_safe (fde, tmp, &nlmclnt->fdes, fde_list) { - fd_unref (fde->fd); - list_del (&fde->fde_list); - GF_FREE (fde); - } + list_for_each_entry_safe(fde, tmp, &nlmclnt->fdes, fde_list) + { + fd_unref(fde->fd); + list_del(&fde->fde_list); + GF_FREE(fde); + } - list_del (&nlmclnt->fdes); - list_del (&nlmclnt->nlm_clients); - list_del (&nlmclnt->shares); + list_del(&nlmclnt->fdes); + list_del(&nlmclnt->nlm_clients); + list_del(&nlmclnt->shares); - GF_FREE (nlmclnt->caller_name); + GF_FREE(nlmclnt->caller_name); - if (nlmclnt->rpc_clnt) { - /* cleanup the saved-frames before last unref */ - rpc_clnt_connection_cleanup (&nlmclnt->rpc_clnt->conn); - /* rpc_clnt_connection_cleanup() calls rpc_clnt_unref() */ - } + if (nlmclnt->rpc_clnt) { + /* cleanup the saved-frames before last unref */ + rpc_clnt_connection_cleanup(&nlmclnt->rpc_clnt->conn); + /* rpc_clnt_connection_cleanup() calls rpc_clnt_unref() */ + } - GF_FREE (nlmclnt); + GF_FREE(nlmclnt); } int -nlm_set_rpc_clnt (rpc_clnt_t *rpc_clnt, char *caller_name) -{ - nlm_client_t *nlmclnt = NULL; - int nlmclnt_found = 0; - int ret = -1; - - LOCK (&nlm_client_list_lk); - list_for_each_entry (nlmclnt, &nlm_client_list, nlm_clients) { - if (!strcmp(caller_name, nlmclnt->caller_name)) { - nlmclnt_found = 1; - break; - } - } - - if (!nlmclnt_found) { - nlmclnt = GF_CALLOC (1, sizeof(*nlmclnt), - gf_nfs_mt_nlm4_nlmclnt); - if (nlmclnt == NULL) - goto ret; - - INIT_LIST_HEAD(&nlmclnt->fdes); - INIT_LIST_HEAD(&nlmclnt->nlm_clients); - INIT_LIST_HEAD(&nlmclnt->shares); - - list_add (&nlmclnt->nlm_clients, &nlm_client_list); - nlmclnt->caller_name = gf_strdup (caller_name); - } - - if (nlmclnt->rpc_clnt == NULL) { - nlmclnt->rpc_clnt = rpc_clnt_ref (rpc_clnt); - } - ret = 0; +nlm_set_rpc_clnt(rpc_clnt_t *rpc_clnt, char *caller_name) +{ + nlm_client_t *nlmclnt = NULL; + int nlmclnt_found = 0; + int ret = -1; + + LOCK(&nlm_client_list_lk); + list_for_each_entry(nlmclnt, &nlm_client_list, nlm_clients) + { + if (!strcmp(caller_name, nlmclnt->caller_name)) { + nlmclnt_found = 1; + break; + } + } + + if (!nlmclnt_found) { + nlmclnt = GF_CALLOC(1, sizeof(*nlmclnt), gf_nfs_mt_nlm4_nlmclnt); + if (nlmclnt == NULL) + goto ret; + + INIT_LIST_HEAD(&nlmclnt->fdes); + INIT_LIST_HEAD(&nlmclnt->nlm_clients); + INIT_LIST_HEAD(&nlmclnt->shares); + + list_add(&nlmclnt->nlm_clients, &nlm_client_list); + nlmclnt->caller_name = gf_strdup(caller_name); + } + + if (nlmclnt->rpc_clnt == NULL) { + nlmclnt->rpc_clnt = rpc_clnt_ref(rpc_clnt); + } + ret = 0; ret: - UNLOCK (&nlm_client_list_lk); - return ret; + UNLOCK(&nlm_client_list_lk); + return ret; } int -nlm_unset_rpc_clnt (rpc_clnt_t *rpc) +nlm_unset_rpc_clnt(rpc_clnt_t *rpc) { - nlm_client_t *nlmclnt = NULL; + nlm_client_t *nlmclnt = NULL; - LOCK (&nlm_client_list_lk); - list_for_each_entry (nlmclnt, &nlm_client_list, nlm_clients) { - if (rpc == nlmclnt->rpc_clnt) { - nlm_client_free (nlmclnt); - break; - } + LOCK(&nlm_client_list_lk); + list_for_each_entry(nlmclnt, &nlm_client_list, nlm_clients) + { + if (rpc == nlmclnt->rpc_clnt) { + nlm_client_free(nlmclnt); + break; } - UNLOCK (&nlm_client_list_lk); + } + UNLOCK(&nlm_client_list_lk); - return 0; + return 0; } int -nlm_add_nlmclnt (char *caller_name) -{ - nlm_client_t *nlmclnt = NULL; - int nlmclnt_found = 0; - int ret = -1; - - LOCK (&nlm_client_list_lk); - list_for_each_entry (nlmclnt, &nlm_client_list, nlm_clients) { - if (!strcmp(caller_name, nlmclnt->caller_name)) { - nlmclnt_found = 1; - break; - } - } - if (!nlmclnt_found) { - nlmclnt = GF_CALLOC (1, sizeof(*nlmclnt), - gf_nfs_mt_nlm4_nlmclnt); - if (nlmclnt == NULL) { - gf_msg (GF_NLM, GF_LOG_ERROR, ENOMEM, - NFS_MSG_NO_MEMORY, "malloc error"); - goto ret; - } - - INIT_LIST_HEAD(&nlmclnt->fdes); - INIT_LIST_HEAD(&nlmclnt->nlm_clients); - INIT_LIST_HEAD(&nlmclnt->shares); - - list_add (&nlmclnt->nlm_clients, &nlm_client_list); - nlmclnt->caller_name = gf_strdup (caller_name); +nlm_add_nlmclnt(char *caller_name) +{ + nlm_client_t *nlmclnt = NULL; + int nlmclnt_found = 0; + int ret = -1; + + LOCK(&nlm_client_list_lk); + list_for_each_entry(nlmclnt, &nlm_client_list, nlm_clients) + { + if (!strcmp(caller_name, nlmclnt->caller_name)) { + nlmclnt_found = 1; + break; + } + } + if (!nlmclnt_found) { + nlmclnt = GF_CALLOC(1, sizeof(*nlmclnt), gf_nfs_mt_nlm4_nlmclnt); + if (nlmclnt == NULL) { + gf_msg(GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "malloc error"); + goto ret; } - ret = 0; + + INIT_LIST_HEAD(&nlmclnt->fdes); + INIT_LIST_HEAD(&nlmclnt->nlm_clients); + INIT_LIST_HEAD(&nlmclnt->shares); + + list_add(&nlmclnt->nlm_clients, &nlm_client_list); + nlmclnt->caller_name = gf_strdup(caller_name); + } + ret = 0; ret: - UNLOCK (&nlm_client_list_lk); - return ret; + UNLOCK(&nlm_client_list_lk); + return ret; } int -nlm4svc_submit_reply (rpcsvc_request_t *req, void *arg, nlm4_serializer sfunc) -{ - struct iovec outmsg = {0, }; - struct iobuf *iob = NULL; - struct nfs3_state *nfs3 = NULL; - int ret = -1; - ssize_t msglen = 0; - struct iobref *iobref = NULL; - - if (!req) - return -1; - - nfs3 = (struct nfs3_state *)rpcsvc_request_program_private (req); - if (!nfs3) { - gf_msg (GF_NLM, GF_LOG_ERROR, EINVAL, - NFS_MSG_MNT_STATE_NOT_FOUND, "mount state not found"); - goto ret; - } - - /* First, get the io buffer into which the reply in arg will - * be serialized. - */ - iob = iobuf_get (nfs3->iobpool); - if (!iob) { - gf_msg (GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to get iobuf"); - goto ret; - } - - iobuf_to_iovec (iob, &outmsg); - /* Use the given serializer to translate the give C structure in arg - * to XDR format which will be written into the buffer in outmsg. - */ - msglen = sfunc (outmsg, arg); - if (msglen < 0) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ENCODE_MSG_FAIL, - "Failed to encode message"); - goto ret; - } - outmsg.iov_len = msglen; - - iobref = iobref_new (); - if (iobref == NULL) { - gf_msg (GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to get iobref"); - goto ret; - } - - ret = iobref_add (iobref, iob); - if (ret) { - gf_msg (GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to add iob to iobref"); - goto ret; - } - - /* Then, submit the message for transmission. */ - ret = rpcsvc_submit_message (req, &outmsg, 1, NULL, 0, iobref); - if (ret == -1) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_REP_SUBMIT_FAIL, - "Reply submission failed"); - goto ret; - } - - ret = 0; +nlm4svc_submit_reply(rpcsvc_request_t *req, void *arg, nlm4_serializer sfunc) +{ + struct iovec outmsg = { + 0, + }; + struct iobuf *iob = NULL; + struct nfs3_state *nfs3 = NULL; + int ret = -1; + ssize_t msglen = 0; + struct iobref *iobref = NULL; + + if (!req) + return -1; + + nfs3 = (struct nfs3_state *)rpcsvc_request_program_private(req); + if (!nfs3) { + gf_msg(GF_NLM, GF_LOG_ERROR, EINVAL, NFS_MSG_MNT_STATE_NOT_FOUND, + "mount state not found"); + goto ret; + } + + /* First, get the io buffer into which the reply in arg will + * be serialized. + */ + iob = iobuf_get(nfs3->iobpool); + if (!iob) { + gf_msg(GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to get iobuf"); + goto ret; + } + + iobuf_to_iovec(iob, &outmsg); + /* Use the given serializer to translate the give C structure in arg + * to XDR format which will be written into the buffer in outmsg. + */ + msglen = sfunc(outmsg, arg); + if (msglen < 0) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ENCODE_MSG_FAIL, + "Failed to encode message"); + goto ret; + } + outmsg.iov_len = msglen; + + iobref = iobref_new(); + if (iobref == NULL) { + gf_msg(GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to get iobref"); + goto ret; + } + + ret = iobref_add(iobref, iob); + if (ret) { + gf_msg(GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to add iob to iobref"); + goto ret; + } + + /* Then, submit the message for transmission. */ + ret = rpcsvc_submit_message(req, &outmsg, 1, NULL, 0, iobref); + if (ret == -1) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_REP_SUBMIT_FAIL, + "Reply submission failed"); + goto ret; + } + + ret = 0; ret: - if (iob) - iobuf_unref (iob); - if (iobref) - iobref_unref (iobref); + if (iob) + iobuf_unref(iob); + if (iobref) + iobref_unref(iobref); - return ret; + return ret; } -typedef int (*nlm4_resume_fn_t) (void *cs); +typedef int (*nlm4_resume_fn_t)(void *cs); int32_t -nlm4_file_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) +nlm4_file_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) { - nfs3_call_state_t *cs = frame->local; + nfs3_call_state_t *cs = frame->local; - if (op_ret == 0) - fd_bind (cs->fd); - cs->resolve_ret = op_ret; - cs->resume_fn (cs); + if (op_ret == 0) + fd_bind(cs->fd); + cs->resolve_ret = op_ret; + cs->resume_fn(cs); - frame->local = NULL; - STACK_DESTROY (frame->root); - GF_REF_PUT (cs); + frame->local = NULL; + STACK_DESTROY(frame->root); + GF_REF_PUT(cs); - return 0; + return 0; } void * nsm_monitor(void *arg) { - CLIENT *clnt = NULL; - enum clnt_stat ret; - struct mon nsm_mon; - struct sm_stat_res res; - struct timeval tout = { 5, 0 }; - char *host = NULL; - - host = arg; - nsm_mon.mon_id.mon_name = gf_strdup(host); - nsm_mon.mon_id.my_id.my_name = gf_strdup("localhost"); - nsm_mon.mon_id.my_id.my_prog = NLMCBK_PROGRAM; - nsm_mon.mon_id.my_id.my_vers = NLMCBK_V1; - nsm_mon.mon_id.my_id.my_proc = NLMCBK_SM_NOTIFY; - /* nothing to put in the private data */ + CLIENT *clnt = NULL; + enum clnt_stat ret; + struct mon nsm_mon; + struct sm_stat_res res; + struct timeval tout = {5, 0}; + char *host = NULL; + + host = arg; + nsm_mon.mon_id.mon_name = gf_strdup(host); + nsm_mon.mon_id.my_id.my_name = gf_strdup("localhost"); + nsm_mon.mon_id.my_id.my_prog = NLMCBK_PROGRAM; + nsm_mon.mon_id.my_id.my_vers = NLMCBK_V1; + nsm_mon.mon_id.my_id.my_proc = NLMCBK_SM_NOTIFY; + /* nothing to put in the private data */ #define SM_PROG 100024 #define SM_VERS 1 #define SM_MON 2 - /* create a connection to nsm on the localhost */ - clnt = clnt_create("localhost", SM_PROG, SM_VERS, "tcp"); - if(!clnt) - { - gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CLNT_CREATE_ERROR, - "%s", clnt_spcreateerror ("Clnt_create()")); - goto out; - } - - ret = clnt_call(clnt, SM_MON, - (xdrproc_t) xdr_mon, (caddr_t) & nsm_mon, - (xdrproc_t) xdr_sm_stat_res, (caddr_t) & res, tout); - if(ret != RPC_SUCCESS) - { - gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CLNT_CALL_ERROR, - "clnt_call(): %s", clnt_sperrno(ret)); - goto out; - } - if(res.res_stat != STAT_SUCC) - { - gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CLNT_CALL_ERROR, - "clnt_call(): %s", clnt_sperrno(ret)); - goto out; - } + /* create a connection to nsm on the localhost */ + clnt = clnt_create("localhost", SM_PROG, SM_VERS, "tcp"); + if (!clnt) { + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CLNT_CREATE_ERROR, "%s", + clnt_spcreateerror("Clnt_create()")); + goto out; + } + + ret = clnt_call(clnt, SM_MON, (xdrproc_t)xdr_mon, (caddr_t)&nsm_mon, + (xdrproc_t)xdr_sm_stat_res, (caddr_t)&res, tout); + if (ret != RPC_SUCCESS) { + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CLNT_CALL_ERROR, + "clnt_call(): %s", clnt_sperrno(ret)); + goto out; + } + if (res.res_stat != STAT_SUCC) { + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CLNT_CALL_ERROR, + "clnt_call(): %s", clnt_sperrno(ret)); + goto out; + } out: - GF_FREE(nsm_mon.mon_id.mon_name); - GF_FREE(nsm_mon.mon_id.my_id.my_name); - if (clnt != NULL) - clnt_destroy(clnt); - return NULL; + GF_FREE(nsm_mon.mon_id.mon_name); + GF_FREE(nsm_mon.mon_id.my_id.my_name); + if (clnt != NULL) + clnt_destroy(clnt); + return NULL; } nlm_client_t * -__nlm_get_uniq (char *caller_name) +__nlm_get_uniq(char *caller_name) { - nlm_client_t *nlmclnt = NULL; + nlm_client_t *nlmclnt = NULL; - if (!caller_name) - return NULL; + if (!caller_name) + return NULL; - list_for_each_entry (nlmclnt, &nlm_client_list, nlm_clients) { - if (!strcmp(caller_name, nlmclnt->caller_name)) - return nlmclnt; - } + list_for_each_entry(nlmclnt, &nlm_client_list, nlm_clients) + { + if (!strcmp(caller_name, nlmclnt->caller_name)) + return nlmclnt; + } - return NULL; + return NULL; } nlm_client_t * -nlm_get_uniq (char *caller_name) +nlm_get_uniq(char *caller_name) { - nlm_client_t *nlmclnt = NULL; + nlm_client_t *nlmclnt = NULL; - LOCK (&nlm_client_list_lk); - nlmclnt = __nlm_get_uniq (caller_name); - UNLOCK (&nlm_client_list_lk); + LOCK(&nlm_client_list_lk); + nlmclnt = __nlm_get_uniq(caller_name); + UNLOCK(&nlm_client_list_lk); - return nlmclnt; + return nlmclnt; } - int nlm4_file_open_and_resume(nfs3_call_state_t *cs, nlm4_resume_fn_t resume) { - fd_t *fd = NULL; - int ret = -1; - int flags = 0; - nlm_client_t *nlmclnt = NULL; - call_frame_t *frame = NULL; - - if (cs->args.nlm4_lockargs.exclusive == _gf_false) - flags = O_RDONLY; - else - flags = O_WRONLY; - - nlmclnt = nlm_get_uniq (cs->args.nlm4_lockargs.alock.caller_name); - if (nlmclnt == NULL) { - gf_msg (GF_NLM, GF_LOG_ERROR, ENOLCK, - NFS_MSG_NO_MEMORY, "nlm_get_uniq() " - "returned NULL"); - ret = -ENOLCK; - goto err; - } - cs->resume_fn = resume; - fd = fd_lookup_uint64 (cs->resolvedloc.inode, (uint64_t)nlmclnt); - if (fd) { - cs->fd = fd; - cs->resolve_ret = 0; - cs->resume_fn(cs); - ret = 0; - goto err; - } - - fd = fd_create_uint64 (cs->resolvedloc.inode, (uint64_t)nlmclnt); - if (fd == NULL) { - gf_msg (GF_NLM, GF_LOG_ERROR, ENOLCK, NFS_MSG_NO_MEMORY, - "fd_create_uint64() returned NULL"); - ret = -ENOLCK; - goto err; - } - + fd_t *fd = NULL; + int ret = -1; + int flags = 0; + nlm_client_t *nlmclnt = NULL; + call_frame_t *frame = NULL; + + if (cs->args.nlm4_lockargs.exclusive == _gf_false) + flags = O_RDONLY; + else + flags = O_WRONLY; + + nlmclnt = nlm_get_uniq(cs->args.nlm4_lockargs.alock.caller_name); + if (nlmclnt == NULL) { + gf_msg(GF_NLM, GF_LOG_ERROR, ENOLCK, NFS_MSG_NO_MEMORY, + "nlm_get_uniq() " + "returned NULL"); + ret = -ENOLCK; + goto err; + } + cs->resume_fn = resume; + fd = fd_lookup_uint64(cs->resolvedloc.inode, (uint64_t)nlmclnt); + if (fd) { cs->fd = fd; - - frame = create_frame (cs->nfsx, cs->nfsx->ctx->pool); - if (!frame) { - gf_msg (GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "unable to create frame"); - ret = -ENOMEM; - goto err; - } - - frame->root->pid = NFS_PID; - frame->root->uid = rpcsvc_request_uid (cs->req); - frame->root->gid = rpcsvc_request_gid (cs->req); - frame->local = GF_REF_GET (cs); - nfs_fix_groups (cs->nfsx, frame->root); - - STACK_WIND_COOKIE (frame, nlm4_file_open_cbk, cs->vol, cs->vol, - cs->vol->fops->open, &cs->resolvedloc, flags, - cs->fd, NULL); + cs->resolve_ret = 0; + cs->resume_fn(cs); ret = 0; + goto err; + } + + fd = fd_create_uint64(cs->resolvedloc.inode, (uint64_t)nlmclnt); + if (fd == NULL) { + gf_msg(GF_NLM, GF_LOG_ERROR, ENOLCK, NFS_MSG_NO_MEMORY, + "fd_create_uint64() returned NULL"); + ret = -ENOLCK; + goto err; + } + + cs->fd = fd; + + frame = create_frame(cs->nfsx, cs->nfsx->ctx->pool); + if (!frame) { + gf_msg(GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "unable to create frame"); + ret = -ENOMEM; + goto err; + } + + frame->root->pid = NFS_PID; + frame->root->uid = rpcsvc_request_uid(cs->req); + frame->root->gid = rpcsvc_request_gid(cs->req); + frame->local = GF_REF_GET(cs); + nfs_fix_groups(cs->nfsx, frame->root); + + STACK_WIND_COOKIE(frame, nlm4_file_open_cbk, cs->vol, cs->vol, + cs->vol->fops->open, &cs->resolvedloc, flags, cs->fd, + NULL); + ret = 0; err: - return ret; + return ret; } int -nlm4_generic_reply (rpcsvc_request_t *req, nlm4_netobj cookie, nlm4_stats stat) +nlm4_generic_reply(rpcsvc_request_t *req, nlm4_netobj cookie, nlm4_stats stat) { - nlm4_res res; + nlm4_res res; - memset (&res, 0, sizeof (res)); - res.cookie = cookie; - res.stat.stat = stat; + memset(&res, 0, sizeof(res)); + res.cookie = cookie; + res.stat.stat = stat; - nlm4svc_submit_reply (req, (void *)&res, - (nlm4_serializer)xdr_serialize_nlm4_res); - return 0; + nlm4svc_submit_reply(req, (void *)&res, + (nlm4_serializer)xdr_serialize_nlm4_res); + return 0; } int -nlm4svc_null (rpcsvc_request_t *req) +nlm4svc_null(rpcsvc_request_t *req) { - struct iovec dummyvec = {0, }; + struct iovec dummyvec = { + 0, + }; - if (!req) { - gf_msg (GF_NLM, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "Got NULL request!"); - return 0; - } - rpcsvc_submit_generic (req, &dummyvec, 1, NULL, 0, NULL); + if (!req) { + gf_msg(GF_NLM, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Got NULL request!"); return 0; + } + rpcsvc_submit_generic(req, &dummyvec, 1, NULL, 0, NULL); + return 0; } int -nlm4_gf_flock_to_holder (nlm4_holder *holder, struct gf_flock *flock) +nlm4_gf_flock_to_holder(nlm4_holder *holder, struct gf_flock *flock) { - switch (flock->l_type) { + switch (flock->l_type) { case GF_LK_F_WRLCK: - holder->exclusive = 1; - break; - } + holder->exclusive = 1; + break; + } - holder->svid = flock->l_pid; - holder->l_offset = flock->l_start; - holder->l_len = flock->l_len; - return 0; + holder->svid = flock->l_pid; + holder->l_offset = flock->l_start; + holder->l_len = flock->l_len; + return 0; } int -nlm4_lock_to_gf_flock (struct gf_flock *flock, nlm4_lock *lock, int excl) -{ - flock->l_pid = lock->svid; - flock->l_start = lock->l_offset; - flock->l_len = lock->l_len; - if (excl) - flock->l_type = F_WRLCK; - else - flock->l_type = F_RDLCK; - flock->l_whence = SEEK_SET; - nlm_copy_lkowner (&flock->l_owner, &lock->oh); - return 0; +nlm4_lock_to_gf_flock(struct gf_flock *flock, nlm4_lock *lock, int excl) +{ + flock->l_pid = lock->svid; + flock->l_start = lock->l_offset; + flock->l_len = lock->l_len; + if (excl) + flock->l_type = F_WRLCK; + else + flock->l_type = F_RDLCK; + flock->l_whence = SEEK_SET; + nlm_copy_lkowner(&flock->l_owner, &lock->oh); + return 0; } rpc_clnt_procedure_t nlm4_clnt_actors[NLM4_PROC_COUNT] = { - [NLM4_NULL] = {"NULL", NULL}, - [NLM4_GRANTED] = {"GRANTED", NULL}, + [NLM4_NULL] = {"NULL", NULL}, + [NLM4_GRANTED] = {"GRANTED", NULL}, }; char *nlm4_clnt_names[NLM4_PROC_COUNT] = { - [NLM4_NULL] = "NULL", - [NLM4_GRANTED] = "GRANTED", + [NLM4_NULL] = "NULL", + [NLM4_GRANTED] = "GRANTED", }; rpc_clnt_prog_t nlm4clntprog = { - .progname = "NLMv4", - .prognum = NLM_PROGRAM, - .progver = NLM_V4, - .numproc = NLM4_PROC_COUNT, - .proctable = nlm4_clnt_actors, - .procnames = nlm4_clnt_names, + .progname = "NLMv4", + .prognum = NLM_PROGRAM, + .progver = NLM_V4, + .numproc = NLM4_PROC_COUNT, + .proctable = nlm4_clnt_actors, + .procnames = nlm4_clnt_names, }; int -nlm4_test_reply (nfs3_call_state_t *cs, nlm4_stats stat, struct gf_flock *flock) +nlm4_test_reply(nfs3_call_state_t *cs, nlm4_stats stat, struct gf_flock *flock) { - nlm4_testres res; + nlm4_testres res; - memset (&res, 0, sizeof (res)); - res.cookie = cs->args.nlm4_testargs.cookie; - res.stat.stat = stat; - if (stat == nlm4_denied) - nlm4_gf_flock_to_holder (&res.stat.nlm4_testrply_u.holder, - flock); + memset(&res, 0, sizeof(res)); + res.cookie = cs->args.nlm4_testargs.cookie; + res.stat.stat = stat; + if (stat == nlm4_denied) + nlm4_gf_flock_to_holder(&res.stat.nlm4_testrply_u.holder, flock); - nlm4svc_submit_reply (cs->req, (void *)&res, - (nlm4_serializer)xdr_serialize_nlm4_testres); - return 0; + nlm4svc_submit_reply(cs->req, (void *)&res, + (nlm4_serializer)xdr_serialize_nlm4_testres); + return 0; } int -nlm4svc_test_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct gf_flock *flock, - dict_t *xdata) +nlm4svc_test_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct gf_flock *flock, + dict_t *xdata) { - nlm4_stats stat = nlm4_denied; - nfs3_call_state_t *cs = NULL; + nlm4_stats stat = nlm4_denied; + nfs3_call_state_t *cs = NULL; - cs = frame->local; - if (op_ret == -1) { - stat = nlm4_errno_to_nlm4stat (op_errno); - goto err; - } else if (flock->l_type == F_UNLCK) - stat = nlm4_granted; + cs = frame->local; + if (op_ret == -1) { + stat = nlm4_errno_to_nlm4stat(op_errno); + goto err; + } else if (flock->l_type == F_UNLCK) + stat = nlm4_granted; err: - nlm4_test_reply (cs, stat, flock); - nfs3_call_state_wipe (cs); - return 0; + nlm4_test_reply(cs, stat, flock); + nfs3_call_state_wipe(cs); + return 0; } int -nlm4_test_fd_resume (void *carg) -{ - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - nfs3_call_state_t *cs = NULL; - struct gf_flock flock = {0, }; - - if (!carg) - return ret; +nlm4_test_fd_resume(void *carg) +{ + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + nfs3_call_state_t *cs = NULL; + struct gf_flock flock = { + 0, + }; + + if (!carg) + return ret; - cs = GF_REF_GET ((nfs3_call_state_t *)carg); - nfs_request_user_init (&nfu, cs->req); - nlm4_lock_to_gf_flock (&flock, &cs->args.nlm4_testargs.alock, - cs->args.nlm4_testargs.exclusive); - nlm_copy_lkowner (&nfu.lk_owner, &cs->args.nlm4_testargs.alock.oh); - ret = nfs_lk (cs->nfsx, cs->vol, &nfu, cs->fd, F_GETLK, &flock, - nlm4svc_test_cbk, cs); + cs = GF_REF_GET((nfs3_call_state_t *)carg); + nfs_request_user_init(&nfu, cs->req); + nlm4_lock_to_gf_flock(&flock, &cs->args.nlm4_testargs.alock, + cs->args.nlm4_testargs.exclusive); + nlm_copy_lkowner(&nfu.lk_owner, &cs->args.nlm4_testargs.alock.oh); + ret = nfs_lk(cs->nfsx, cs->vol, &nfu, cs->fd, F_GETLK, &flock, + nlm4svc_test_cbk, cs); - GF_REF_PUT (cs); + GF_REF_PUT(cs); - return ret; + return ret; } - int -nlm4_test_resume (void *carg) +nlm4_test_resume(void *carg) { - nlm4_stats stat = nlm4_failed; - int ret = -1; - nfs3_call_state_t *cs = NULL; - fd_t *fd = NULL; + nlm4_stats stat = nlm4_failed; + int ret = -1; + nfs3_call_state_t *cs = NULL; + fd_t *fd = NULL; - if (!carg) - return ret; + if (!carg) + return ret; - cs = GF_REF_GET ((nfs3_call_state_t *)carg); - nlm4_check_fh_resolve_status (cs, stat, nlm4err); - fd = fd_anonymous (cs->resolvedloc.inode); - if (!fd) - goto nlm4err; - cs->fd = fd; - ret = nlm4_test_fd_resume (cs); + cs = GF_REF_GET((nfs3_call_state_t *)carg); + nlm4_check_fh_resolve_status(cs, stat, nlm4err); + fd = fd_anonymous(cs->resolvedloc.inode); + if (!fd) + goto nlm4err; + cs->fd = fd; + ret = nlm4_test_fd_resume(cs); nlm4err: - if (ret < 0) { - gf_msg (GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_OPEN_FAIL, - "unable to open_and_resume"); - stat = nlm4_errno_to_nlm4stat (-ret); - nlm4_test_reply (cs, stat, NULL); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + gf_msg(GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_OPEN_FAIL, + "unable to open_and_resume"); + stat = nlm4_errno_to_nlm4stat(-ret); + nlm4_test_reply(cs, stat, NULL); + nfs3_call_state_wipe(cs); + } - GF_REF_PUT (cs); + GF_REF_PUT(cs); - return ret; + return ret; } int -nlm4svc_test (rpcsvc_request_t *req) -{ - xlator_t *vol = NULL; - nlm4_stats stat = nlm4_failed; - struct nfs_state *nfs = NULL; - nfs3_state_t *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - int ret = RPCSVC_ACTOR_ERROR; - struct nfs3_fh fh = {{0}, }; - - if (!req) - return ret; - - nlm4_validate_nfs3_state (req, nfs3, stat, rpcerr, ret); - nfs = nfs_state (nfs3->nfsx); - nlm4_handle_call_state_init (nfs->nfs3state, cs, req, - stat, rpcerr); - - nlm4_prep_nlm4_testargs (&cs->args.nlm4_testargs, &fh, &cs->lkowner, - cs->cookiebytes); - if (xdr_to_nlm4_testargs(req->msg[0], &cs->args.nlm4_testargs) <= 0) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } - - nlm4_validate_gluster_fh (&fh, stat, nlm4err); - nlm4_map_fh_to_volume (cs->nfs3state, fh, req, vol, stat, nlm4err); +nlm4svc_test(rpcsvc_request_t *req) +{ + xlator_t *vol = NULL; + nlm4_stats stat = nlm4_failed; + struct nfs_state *nfs = NULL; + nfs3_state_t *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + int ret = RPCSVC_ACTOR_ERROR; + struct nfs3_fh fh = { + {0}, + }; + + if (!req) + return ret; - if (nlm_grace_period) { - gf_msg (GF_NLM, GF_LOG_WARNING, 0, NFS_MSG_NLM_GRACE_PERIOD, - "NLM in grace period"); - stat = nlm4_denied_grace_period; - nlm4_test_reply (cs, stat, NULL); - nfs3_call_state_wipe (cs); - return 0; - } + nlm4_validate_nfs3_state(req, nfs3, stat, rpcerr, ret); + nfs = nfs_state(nfs3->nfsx); + nlm4_handle_call_state_init(nfs->nfs3state, cs, req, stat, rpcerr); + + nlm4_prep_nlm4_testargs(&cs->args.nlm4_testargs, &fh, &cs->lkowner, + cs->cookiebytes); + if (xdr_to_nlm4_testargs(req->msg[0], &cs->args.nlm4_testargs) <= 0) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + nlm4_validate_gluster_fh(&fh, stat, nlm4err); + nlm4_map_fh_to_volume(cs->nfs3state, fh, req, vol, stat, nlm4err); + + if (nlm_grace_period) { + gf_msg(GF_NLM, GF_LOG_WARNING, 0, NFS_MSG_NLM_GRACE_PERIOD, + "NLM in grace period"); + stat = nlm4_denied_grace_period; + nlm4_test_reply(cs, stat, NULL); + nfs3_call_state_wipe(cs); + return 0; + } - cs->vol = vol; - nlm4_volume_started_check (nfs3, vol, ret, rpcerr); + cs->vol = vol; + nlm4_volume_started_check(nfs3, vol, ret, rpcerr); - ret = nfs3_fh_resolve_and_resume (cs, &fh, - NULL, nlm4_test_resume); + ret = nfs3_fh_resolve_and_resume(cs, &fh, NULL, nlm4_test_resume); nlm4err: - if (ret < 0) { - gf_msg (GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR, - "unable to resolve and resume"); - nlm4_test_reply (cs, stat, NULL); - nfs3_call_state_wipe (cs); - return 0; - } + if (ret < 0) { + gf_msg(GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR, + "unable to resolve and resume"); + nlm4_test_reply(cs, stat, NULL); + nfs3_call_state_wipe(cs); + return 0; + } rpcerr: - if (ret < 0) - nfs3_call_state_wipe (cs); + if (ret < 0) + nfs3_call_state_wipe(cs); - return ret; + return ret; } struct nlm4_notify_args { - GF_REF_DECL; /* refcounting */ + GF_REF_DECL; /* refcounting */ - nfs3_call_state_t *cs; /* call state, w/ lock request details */ - call_frame_t *frame; /* frame to us for the reply */ + nfs3_call_state_t *cs; /* call state, w/ lock request details */ + call_frame_t *frame; /* frame to us for the reply */ }; static int -nlm4svc_send_granted_cbk (struct rpc_req *req, struct iovec *iov, int count, - void *myframe) +nlm4svc_send_granted_cbk(struct rpc_req *req, struct iovec *iov, int count, + void *myframe) { - call_frame_t *frame = myframe; - struct nlm4_notify_args *args = frame->local; + call_frame_t *frame = myframe; + struct nlm4_notify_args *args = frame->local; - GF_REF_PUT (args); - return 0; + GF_REF_PUT(args); + return 0; } static void -nlm4_notify_free (struct nlm4_notify_args *ncf) +nlm4_notify_free(struct nlm4_notify_args *ncf) { - GF_REF_PUT (ncf->cs); - STACK_DESTROY (ncf->frame->root); - GF_FREE (ncf); + GF_REF_PUT(ncf->cs); + STACK_DESTROY(ncf->frame->root); + GF_FREE(ncf); } -static struct nlm4_notify_args* -nlm4_notify_init (nfs3_call_state_t *cs) +static struct nlm4_notify_args * +nlm4_notify_init(nfs3_call_state_t *cs) { - struct nlm4_notify_args *ncf = NULL; + struct nlm4_notify_args *ncf = NULL; - ncf = GF_CALLOC (1, sizeof (struct nlm4_notify_args), - gf_nfs_mt_nlm4_notify); - if (!ncf) - /* GF_CALLOW will log the ENOMEM error */ - goto out; + ncf = GF_CALLOC(1, sizeof(struct nlm4_notify_args), gf_nfs_mt_nlm4_notify); + if (!ncf) + /* GF_CALLOW will log the ENOMEM error */ + goto out; - GF_REF_INIT (ncf, nlm4_notify_free); - ncf->cs = GF_REF_GET (cs); + GF_REF_INIT(ncf, nlm4_notify_free); + ncf->cs = GF_REF_GET(cs); out: - return ncf; + return ncf; } static int -nlm_handle_connect (struct rpc_clnt *rpc_clnt, struct nlm4_notify_args *ncf); +nlm_handle_connect(struct rpc_clnt *rpc_clnt, struct nlm4_notify_args *ncf); int -nlm_rpcclnt_notify (struct rpc_clnt *rpc_clnt, void *mydata, - rpc_clnt_event_t fn, void *data) +nlm_rpcclnt_notify(struct rpc_clnt *rpc_clnt, void *mydata, rpc_clnt_event_t fn, + void *data) { - struct nlm4_notify_args *ncf = mydata; + struct nlm4_notify_args *ncf = mydata; - GF_VALIDATE_OR_GOTO ("NLM4-notify", ncf, out); + GF_VALIDATE_OR_GOTO("NLM4-notify", ncf, out); - switch (fn) { + switch (fn) { case RPC_CLNT_CONNECT: - nlm_handle_connect (rpc_clnt, ncf); - break; + nlm_handle_connect(rpc_clnt, ncf); + break; case RPC_CLNT_MSG: - break; + break; case RPC_CLNT_DISCONNECT: - nlm_unset_rpc_clnt (rpc_clnt); - break; + nlm_unset_rpc_clnt(rpc_clnt); + break; case RPC_CLNT_DESTROY: - GF_REF_PUT (ncf); - break; + GF_REF_PUT(ncf); + break; default: - break; - } + break; + } out: - return 0; + return 0; } void * -nlm4_establish_callback (nfs3_call_state_t *cs, call_frame_t *cbk_frame) +nlm4_establish_callback(nfs3_call_state_t *cs, call_frame_t *cbk_frame) { - int ret = -1; - union gf_sock_union sock_union; - dict_t *options = NULL; - char peerip[INET6_ADDRSTRLEN+1] = {0}; - char *portstr = NULL; - char myip[INET6_ADDRSTRLEN+1] = {0}; - rpc_clnt_t *rpc_clnt = NULL; - int port = -1; - struct nlm4_notify_args *ncf = NULL; + int ret = -1; + union gf_sock_union sock_union; + dict_t *options = NULL; + char peerip[INET6_ADDRSTRLEN + 1] = {0}; + char *portstr = NULL; + char myip[INET6_ADDRSTRLEN + 1] = {0}; + rpc_clnt_t *rpc_clnt = NULL; + int port = -1; + struct nlm4_notify_args *ncf = NULL; - glusterfs_this_set (cs->nfsx); + glusterfs_this_set(cs->nfsx); - rpc_transport_get_peeraddr (cs->trans, NULL, 0, &sock_union.storage, - sizeof (sock_union.storage)); + rpc_transport_get_peeraddr(cs->trans, NULL, 0, &sock_union.storage, + sizeof(sock_union.storage)); - switch (sock_union.sa.sa_family) { + switch (sock_union.sa.sa_family) { case AF_INET6: - /* can not come here as NLM listens on IPv4 */ - gf_msg (GF_NLM, GF_LOG_ERROR, EAFNOSUPPORT, - NFS_MSG_UNSUPPORTED_VERSION, - "NLM is not supported on IPv6 in this release"); - goto err; -/* - inet_ntop (AF_INET6, - &((struct sockaddr_in6 *)sockaddr)->sin6_addr, - peerip, INET6_ADDRSTRLEN+1); - break; -*/ + /* can not come here as NLM listens on IPv4 */ + gf_msg(GF_NLM, GF_LOG_ERROR, EAFNOSUPPORT, + NFS_MSG_UNSUPPORTED_VERSION, + "NLM is not supported on IPv6 in this release"); + goto err; + /* + inet_ntop (AF_INET6, + &((struct sockaddr_in6 + *)sockaddr)->sin6_addr, peerip, INET6_ADDRSTRLEN+1); break; + */ case AF_INET: - inet_ntop (AF_INET, &sock_union.sin.sin_addr, peerip, - INET6_ADDRSTRLEN+1); - inet_ntop (AF_INET, &(((struct sockaddr_in *)&cs->trans->myinfo.sockaddr)->sin_addr), - myip, INET6_ADDRSTRLEN + 1); - - break; + inet_ntop(AF_INET, &sock_union.sin.sin_addr, peerip, + INET6_ADDRSTRLEN + 1); + inet_ntop(AF_INET, + &(((struct sockaddr_in *)&cs->trans->myinfo.sockaddr) + ->sin_addr), + myip, INET6_ADDRSTRLEN + 1); + + break; default: - break; - /* FIXME: handle the error */ - } - - /* looks like libc rpc supports only ipv4 */ - port = pmap_getport (&sock_union.sin, NLM_PROGRAM, - NLM_V4, IPPROTO_TCP); - - if (port == 0) { - gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_GET_PORT_ERROR, - "Unable to get NLM port of the client." - " Is the firewall running on client?" - " OR Are RPC services running (rpcinfo -p)?"); - goto err; - } - - options = dict_new(); - ret = dict_set_str (options, "transport-type", "socket"); - if (ret == -1) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, - "dict_set_str error"); - goto err; - } - - ret = dict_set_dynstr (options, "remote-host", gf_strdup (peerip)); - if (ret == -1) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, - "dict_set_str error"); - goto err; - } - - ret = gf_asprintf (&portstr, "%d", port); - if (ret == -1) - goto err; - - ret = dict_set_dynstr (options, "remote-port", - portstr); - if (ret == -1) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, - "dict_set_dynstr error"); - goto err; - } - - /* needed in case virtual IP is used */ - ret = dict_set_dynstr (options, "transport.socket.source-addr", - gf_strdup (myip)); - if (ret == -1) - goto err; - - ret = dict_set_str (options, "auth-null", "on"); - if (ret == -1) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, - "dict_set_dynstr error"); - goto err; - } - - ncf = nlm4_notify_init (cs); - if (!ncf) { - ret = -1; - goto err; - } - - ncf->frame = cbk_frame; - ncf->frame->local = ncf; - - /* TODO: is 32 frames in transit enough ? */ - rpc_clnt = rpc_clnt_new (options, cs->nfsx, "NLM-client", 32); - if (rpc_clnt == NULL) { - gf_msg (GF_NLM, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, - "rpc_clnt NULL"); - goto err; - } - - ret = rpc_clnt_register_notify (rpc_clnt, nlm_rpcclnt_notify, ncf); - if (ret == -1) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_RPC_CLNT_ERROR, - "rpc_clnt_register_connect error"); - goto err; - } - - /* After this connect succeeds, granted msg is sent in notify */ - ret = rpc_transport_connect (rpc_clnt->conn.trans, port); - - if (ret == -1 && EINPROGRESS == errno) - ret = 0; + break; + /* FIXME: handle the error */ + } + + /* looks like libc rpc supports only ipv4 */ + port = pmap_getport(&sock_union.sin, NLM_PROGRAM, NLM_V4, IPPROTO_TCP); + + if (port == 0) { + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_GET_PORT_ERROR, + "Unable to get NLM port of the client." + " Is the firewall running on client?" + " OR Are RPC services running (rpcinfo -p)?"); + goto err; + } + + options = dict_new(); + ret = dict_set_str(options, "transport-type", "socket"); + if (ret == -1) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); + goto err; + } + + ret = dict_set_dynstr(options, "remote-host", gf_strdup(peerip)); + if (ret == -1) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); + goto err; + } + + ret = gf_asprintf(&portstr, "%d", port); + if (ret == -1) + goto err; + + ret = dict_set_dynstr(options, "remote-port", portstr); + if (ret == -1) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, + "dict_set_dynstr error"); + goto err; + } + + /* needed in case virtual IP is used */ + ret = dict_set_dynstr(options, "transport.socket.source-addr", + gf_strdup(myip)); + if (ret == -1) + goto err; + + ret = dict_set_str(options, "auth-null", "on"); + if (ret == -1) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, + "dict_set_dynstr error"); + goto err; + } + + ncf = nlm4_notify_init(cs); + if (!ncf) { + ret = -1; + goto err; + } + + ncf->frame = cbk_frame; + ncf->frame->local = ncf; + + /* TODO: is 32 frames in transit enough ? */ + rpc_clnt = rpc_clnt_new(options, cs->nfsx, "NLM-client", 32); + if (rpc_clnt == NULL) { + gf_msg(GF_NLM, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "rpc_clnt NULL"); + goto err; + } + + ret = rpc_clnt_register_notify(rpc_clnt, nlm_rpcclnt_notify, ncf); + if (ret == -1) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_RPC_CLNT_ERROR, + "rpc_clnt_register_connect error"); + goto err; + } + + /* After this connect succeeds, granted msg is sent in notify */ + ret = rpc_transport_connect(rpc_clnt->conn.trans, port); + + if (ret == -1 && EINPROGRESS == errno) + ret = 0; err: - if (ret == -1) { - if (rpc_clnt) - rpc_clnt_unref (rpc_clnt); - if (ncf) - GF_REF_PUT (ncf); - } + if (ret == -1) { + if (rpc_clnt) + rpc_clnt_unref(rpc_clnt); + if (ncf) + GF_REF_PUT(ncf); + } - return rpc_clnt; + return rpc_clnt; } static void -nlm4svc_send_granted (struct nlm4_notify_args *ncf) -{ - int ret = -1; - nfs3_call_state_t *cs = ncf->cs; - rpc_clnt_t *rpc_clnt = NULL; - struct iovec outmsg = {0, }; - nlm4_testargs testargs; - struct iobuf *iobuf = NULL; - struct iobref *iobref = NULL; - char peerip[INET6_ADDRSTRLEN+1]; - union gf_sock_union sock_union; - - rpc_clnt = nlm_get_rpc_clnt (cs->args.nlm4_lockargs.alock.caller_name); - if (rpc_clnt == NULL) { - nlm4_establish_callback (cs, ncf->frame); - return; - } +nlm4svc_send_granted(struct nlm4_notify_args *ncf) +{ + int ret = -1; + nfs3_call_state_t *cs = ncf->cs; + rpc_clnt_t *rpc_clnt = NULL; + struct iovec outmsg = { + 0, + }; + nlm4_testargs testargs; + struct iobuf *iobuf = NULL; + struct iobref *iobref = NULL; + char peerip[INET6_ADDRSTRLEN + 1]; + union gf_sock_union sock_union; + + rpc_clnt = nlm_get_rpc_clnt(cs->args.nlm4_lockargs.alock.caller_name); + if (rpc_clnt == NULL) { + nlm4_establish_callback(cs, ncf->frame); + return; + } - rpc_transport_get_peeraddr (cs->trans, NULL, 0, &sock_union.storage, - sizeof (sock_union.storage)); + rpc_transport_get_peeraddr(cs->trans, NULL, 0, &sock_union.storage, + sizeof(sock_union.storage)); - switch (sock_union.sa.sa_family) { + switch (sock_union.sa.sa_family) { case AF_INET6: - inet_ntop (AF_INET6, &sock_union.sin6.sin6_addr, peerip, - INET6_ADDRSTRLEN+1); - break; + inet_ntop(AF_INET6, &sock_union.sin6.sin6_addr, peerip, + INET6_ADDRSTRLEN + 1); + break; case AF_INET: - inet_ntop (AF_INET, &sock_union.sin.sin_addr, peerip, - INET6_ADDRSTRLEN+1); - break; + inet_ntop(AF_INET, &sock_union.sin.sin_addr, peerip, + INET6_ADDRSTRLEN + 1); + break; default: - break; - } - - testargs.cookie = cs->args.nlm4_lockargs.cookie; - testargs.exclusive = cs->args.nlm4_lockargs.exclusive; - testargs.alock = cs->args.nlm4_lockargs.alock; - - iobuf = iobuf_get (cs->nfs3state->iobpool); - if (!iobuf) { - gf_msg (GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to get iobuf"); - goto ret; - } - - iobuf_to_iovec (iobuf, &outmsg); - /* Use the given serializer to translate the give C structure in arg - * to XDR format which will be written into the buffer in outmsg. - */ - outmsg.iov_len = xdr_serialize_nlm4_testargs (outmsg, &testargs); - - iobref = iobref_new (); - if (iobref == NULL) { - gf_msg (GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to get iobref"); - goto ret; - } - - ret = iobref_add (iobref, iobuf); - if (ret) { - gf_msg (GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, - "Failed to add iob to iobref"); - goto ret; - } - - GF_REF_GET (ncf); - ret = rpc_clnt_submit (rpc_clnt, &nlm4clntprog, NLM4_GRANTED, - nlm4svc_send_granted_cbk, &outmsg, 1, - NULL, 0, iobref, ncf->frame, NULL, 0, - NULL, 0, NULL); - - if (ret < 0) { - gf_msg (GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_RPC_CLNT_ERROR, - "rpc_clnt_submit error"); - goto ret; - } + break; + } + + testargs.cookie = cs->args.nlm4_lockargs.cookie; + testargs.exclusive = cs->args.nlm4_lockargs.exclusive; + testargs.alock = cs->args.nlm4_lockargs.alock; + + iobuf = iobuf_get(cs->nfs3state->iobpool); + if (!iobuf) { + gf_msg(GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to get iobuf"); + goto ret; + } + + iobuf_to_iovec(iobuf, &outmsg); + /* Use the given serializer to translate the give C structure in arg + * to XDR format which will be written into the buffer in outmsg. + */ + outmsg.iov_len = xdr_serialize_nlm4_testargs(outmsg, &testargs); + + iobref = iobref_new(); + if (iobref == NULL) { + gf_msg(GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to get iobref"); + goto ret; + } + + ret = iobref_add(iobref, iobuf); + if (ret) { + gf_msg(GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to add iob to iobref"); + goto ret; + } + + GF_REF_GET(ncf); + ret = rpc_clnt_submit(rpc_clnt, &nlm4clntprog, NLM4_GRANTED, + nlm4svc_send_granted_cbk, &outmsg, 1, NULL, 0, iobref, + ncf->frame, NULL, 0, NULL, 0, NULL); + + if (ret < 0) { + gf_msg(GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_RPC_CLNT_ERROR, + "rpc_clnt_submit error"); + goto ret; + } ret: - if (iobref) - iobref_unref (iobref); - if (iobuf) - iobuf_unref (iobuf); + if (iobref) + iobref_unref(iobref); + if (iobuf) + iobuf_unref(iobuf); - rpc_clnt_unref (rpc_clnt); - return; + rpc_clnt_unref(rpc_clnt); + return; } int -nlm_cleanup_fds (char *caller_name) -{ - int nlmclnt_found = 0; - nlm_client_t *nlmclnt = NULL; - - LOCK (&nlm_client_list_lk); - list_for_each_entry (nlmclnt, - &nlm_client_list, nlm_clients) { - if (!strcmp(caller_name, nlmclnt->caller_name)) { - nlmclnt_found = 1; - break; - } +nlm_cleanup_fds(char *caller_name) +{ + int nlmclnt_found = 0; + nlm_client_t *nlmclnt = NULL; + + LOCK(&nlm_client_list_lk); + list_for_each_entry(nlmclnt, &nlm_client_list, nlm_clients) + { + if (!strcmp(caller_name, nlmclnt->caller_name)) { + nlmclnt_found = 1; + break; } + } - if (!nlmclnt_found) - goto ret; + if (!nlmclnt_found) + goto ret; - nlm_client_free (nlmclnt); + nlm_client_free(nlmclnt); ret: - UNLOCK (&nlm_client_list_lk); - return 0; + UNLOCK(&nlm_client_list_lk); + return 0; } void -nlm_search_and_delete (fd_t *fd, nlm4_lock *lk) -{ - nlm_fde_t *fde = NULL; - nlm_client_t *nlmclnt = NULL; - int nlmclnt_found = 0; - int fde_found = 0; - int transit_cnt = 0; - - LOCK (&nlm_client_list_lk); - list_for_each_entry (nlmclnt, - &nlm_client_list, nlm_clients) { - if (!strcmp (lk->caller_name, nlmclnt->caller_name)) { - nlmclnt_found = 1; - break; - } +nlm_search_and_delete(fd_t *fd, nlm4_lock *lk) +{ + nlm_fde_t *fde = NULL; + nlm_client_t *nlmclnt = NULL; + int nlmclnt_found = 0; + int fde_found = 0; + int transit_cnt = 0; + + LOCK(&nlm_client_list_lk); + list_for_each_entry(nlmclnt, &nlm_client_list, nlm_clients) + { + if (!strcmp(lk->caller_name, nlmclnt->caller_name)) { + nlmclnt_found = 1; + break; } + } - if (!nlmclnt_found) - goto ret; + if (!nlmclnt_found) + goto ret; - list_for_each_entry (fde, &nlmclnt->fdes, fde_list) { - if (fde->fd == fd) { - fde_found = 1; - break; - } + list_for_each_entry(fde, &nlmclnt->fdes, fde_list) + { + if (fde->fd == fd) { + fde_found = 1; + break; } + } - if (!fde_found) - goto ret; - transit_cnt = fde->transit_cnt; - if (transit_cnt) - goto ret; - list_del (&fde->fde_list); + if (!fde_found) + goto ret; + transit_cnt = fde->transit_cnt; + if (transit_cnt) + goto ret; + list_del(&fde->fde_list); ret: - UNLOCK (&nlm_client_list_lk); + UNLOCK(&nlm_client_list_lk); - if (fde_found && !transit_cnt) { - fd_unref (fde->fd); - GF_FREE (fde); - } - return; + if (fde_found && !transit_cnt) { + fd_unref(fde->fd); + GF_FREE(fde); + } + return; } int -nlm_dec_transit_count (fd_t *fd, char *caller_name) -{ - nlm_fde_t *fde = NULL; - nlm_client_t *nlmclnt = NULL; - int nlmclnt_found = 0; - int fde_found = 0; - int transit_cnt = -1; - - LOCK (&nlm_client_list_lk); - list_for_each_entry (nlmclnt, - &nlm_client_list, nlm_clients) { - if (!strcmp(caller_name, nlmclnt->caller_name)) { - nlmclnt_found = 1; - break; - } - } - - if (!nlmclnt_found) { - gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_NLMCLNT_NOT_FOUND, - "nlmclnt not found"); - nlmclnt = NULL; - goto ret; - } - - list_for_each_entry (fde, &nlmclnt->fdes, fde_list) { - if (fde->fd == fd) { - fde_found = 1; - break; - } - } - - if (fde_found) { - transit_cnt = --fde->transit_cnt; - goto ret; - } +nlm_dec_transit_count(fd_t *fd, char *caller_name) +{ + nlm_fde_t *fde = NULL; + nlm_client_t *nlmclnt = NULL; + int nlmclnt_found = 0; + int fde_found = 0; + int transit_cnt = -1; + + LOCK(&nlm_client_list_lk); + list_for_each_entry(nlmclnt, &nlm_client_list, nlm_clients) + { + if (!strcmp(caller_name, nlmclnt->caller_name)) { + nlmclnt_found = 1; + break; + } + } + + if (!nlmclnt_found) { + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_NLMCLNT_NOT_FOUND, + "nlmclnt not found"); + nlmclnt = NULL; + goto ret; + } + + list_for_each_entry(fde, &nlmclnt->fdes, fde_list) + { + if (fde->fd == fd) { + fde_found = 1; + break; + } + } + + if (fde_found) { + transit_cnt = --fde->transit_cnt; + goto ret; + } ret: - UNLOCK (&nlm_client_list_lk); - return transit_cnt; + UNLOCK(&nlm_client_list_lk); + return transit_cnt; } - nlm_client_t * -nlm_search_and_add (fd_t *fd, char *caller_name) -{ - nlm_fde_t *fde = NULL; - nlm_client_t *nlmclnt = NULL; - int nlmclnt_found = 0; - int fde_found = 0; - - LOCK (&nlm_client_list_lk); - list_for_each_entry (nlmclnt, - &nlm_client_list, nlm_clients) { - if (!strcmp(caller_name, nlmclnt->caller_name)) { - nlmclnt_found = 1; - break; - } - } +nlm_search_and_add(fd_t *fd, char *caller_name) +{ + nlm_fde_t *fde = NULL; + nlm_client_t *nlmclnt = NULL; + int nlmclnt_found = 0; + int fde_found = 0; - if (!nlmclnt_found) { - gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_NLMCLNT_NOT_FOUND, - "nlmclnt not found"); - nlmclnt = NULL; - goto ret; + LOCK(&nlm_client_list_lk); + list_for_each_entry(nlmclnt, &nlm_client_list, nlm_clients) + { + if (!strcmp(caller_name, nlmclnt->caller_name)) { + nlmclnt_found = 1; + break; } + } - list_for_each_entry (fde, &nlmclnt->fdes, fde_list) { - if (fde->fd == fd) { - fde_found = 1; - break; - } + if (!nlmclnt_found) { + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_NLMCLNT_NOT_FOUND, + "nlmclnt not found"); + nlmclnt = NULL; + goto ret; + } + + list_for_each_entry(fde, &nlmclnt->fdes, fde_list) + { + if (fde->fd == fd) { + fde_found = 1; + break; } + } - if (fde_found) - goto ret; + if (fde_found) + goto ret; - fde = GF_CALLOC (1, sizeof (*fde), gf_nfs_mt_nlm4_fde); + fde = GF_CALLOC(1, sizeof(*fde), gf_nfs_mt_nlm4_fde); - fde->fd = fd_ref (fd); - list_add (&fde->fde_list, &nlmclnt->fdes); + fde->fd = fd_ref(fd); + list_add(&fde->fde_list, &nlmclnt->fdes); ret: - if (nlmclnt_found && fde) - fde->transit_cnt++; - UNLOCK (&nlm_client_list_lk); - return nlmclnt; + if (nlmclnt_found && fde) + fde->transit_cnt++; + UNLOCK(&nlm_client_list_lk); + return nlmclnt; } int -nlm4svc_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct gf_flock *flock, - dict_t *xdata) -{ - nlm4_stats stat = nlm4_denied; - int transit_cnt = -1; - char *caller_name = NULL; - nfs3_call_state_t *cs = NULL; - pthread_t thr; - struct nlm4_notify_args *ncf = NULL; - - cs = frame->local; - caller_name = cs->args.nlm4_lockargs.alock.caller_name; - transit_cnt = nlm_dec_transit_count (cs->fd, caller_name); - - if (op_ret == -1) { - if (transit_cnt == 0) - nlm_search_and_delete (cs->fd, - &cs->args.nlm4_lockargs.alock); - stat = nlm4_errno_to_nlm4stat (op_errno); - goto err; - } else { - stat = nlm4_granted; - if (cs->monitor && !nlm_monitor (caller_name)) { - /* FIXME: handle nsm_monitor failure */ - gf_thread_create (&thr, NULL, nsm_monitor, - (void *)caller_name, "nlmmon"); - } - } +nlm4svc_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct gf_flock *flock, + dict_t *xdata) +{ + nlm4_stats stat = nlm4_denied; + int transit_cnt = -1; + char *caller_name = NULL; + nfs3_call_state_t *cs = NULL; + pthread_t thr; + struct nlm4_notify_args *ncf = NULL; + + cs = frame->local; + caller_name = cs->args.nlm4_lockargs.alock.caller_name; + transit_cnt = nlm_dec_transit_count(cs->fd, caller_name); + + if (op_ret == -1) { + if (transit_cnt == 0) + nlm_search_and_delete(cs->fd, &cs->args.nlm4_lockargs.alock); + stat = nlm4_errno_to_nlm4stat(op_errno); + goto err; + } else { + stat = nlm4_granted; + if (cs->monitor && !nlm_monitor(caller_name)) { + /* FIXME: handle nsm_monitor failure */ + gf_thread_create(&thr, NULL, nsm_monitor, (void *)caller_name, + "nlmmon"); + } + } err: - if (cs->args.nlm4_lockargs.block) { - ncf = nlm4_notify_init (cs); - if (ncf) { - ncf->frame = copy_frame (frame); - ncf->frame->local = ncf; - nlm4svc_send_granted (ncf); - } - } else { - nlm4_generic_reply (cs->req, cs->args.nlm4_lockargs.cookie, - stat); - nfs3_call_state_wipe (cs); + if (cs->args.nlm4_lockargs.block) { + ncf = nlm4_notify_init(cs); + if (ncf) { + ncf->frame = copy_frame(frame); + ncf->frame->local = ncf; + nlm4svc_send_granted(ncf); } + } else { + nlm4_generic_reply(cs->req, cs->args.nlm4_lockargs.cookie, stat); + nfs3_call_state_wipe(cs); + } - return 0; + return 0; } int -nlm4_lock_fd_resume (void *carg) -{ - nlm4_stats stat = nlm4_denied; - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - nfs3_call_state_t *cs = NULL; - struct gf_flock flock = {0, }; - - if (!carg) - return ret; - - cs = GF_REF_GET ((nfs3_call_state_t *)carg); - nlm4_check_fh_resolve_status (cs, stat, nlm4err); - (void) nlm_search_and_add (cs->fd, - cs->args.nlm4_lockargs.alock.caller_name); - nfs_request_user_init (&nfu, cs->req); - nlm4_lock_to_gf_flock (&flock, &cs->args.nlm4_lockargs.alock, - cs->args.nlm4_lockargs.exclusive); - nlm_copy_lkowner (&nfu.lk_owner, &cs->args.nlm4_lockargs.alock.oh); - if (cs->args.nlm4_lockargs.block) { - nlm4_generic_reply (cs->req, cs->args.nlm4_lockargs.cookie, - nlm4_blocked); - ret = nfs_lk (cs->nfsx, cs->vol, &nfu, cs->fd, F_SETLKW, - &flock, nlm4svc_lock_cbk, cs); - /* FIXME: handle error from nfs_lk() specially by just - * cleaning up cs and unblock the client lock request. - */ - ret = 0; - } else - ret = nfs_lk (cs->nfsx, cs->vol, &nfu, cs->fd, F_SETLK, - &flock, nlm4svc_lock_cbk, cs); +nlm4_lock_fd_resume(void *carg) +{ + nlm4_stats stat = nlm4_denied; + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + nfs3_call_state_t *cs = NULL; + struct gf_flock flock = { + 0, + }; + + if (!carg) + return ret; + + cs = GF_REF_GET((nfs3_call_state_t *)carg); + nlm4_check_fh_resolve_status(cs, stat, nlm4err); + (void)nlm_search_and_add(cs->fd, cs->args.nlm4_lockargs.alock.caller_name); + nfs_request_user_init(&nfu, cs->req); + nlm4_lock_to_gf_flock(&flock, &cs->args.nlm4_lockargs.alock, + cs->args.nlm4_lockargs.exclusive); + nlm_copy_lkowner(&nfu.lk_owner, &cs->args.nlm4_lockargs.alock.oh); + if (cs->args.nlm4_lockargs.block) { + nlm4_generic_reply(cs->req, cs->args.nlm4_lockargs.cookie, + nlm4_blocked); + ret = nfs_lk(cs->nfsx, cs->vol, &nfu, cs->fd, F_SETLKW, &flock, + nlm4svc_lock_cbk, cs); + /* FIXME: handle error from nfs_lk() specially by just + * cleaning up cs and unblock the client lock request. + */ + ret = 0; + } else + ret = nfs_lk(cs->nfsx, cs->vol, &nfu, cs->fd, F_SETLK, &flock, + nlm4svc_lock_cbk, cs); nlm4err: - if (ret < 0) { - stat = nlm4_errno_to_nlm4stat (-ret); - gf_msg (GF_NLM, GF_LOG_ERROR, stat, NFS_MSG_LOCK_FAIL, - "unable to call lk()"); - nlm4_generic_reply (cs->req, cs->args.nlm4_lockargs.cookie, - stat); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + stat = nlm4_errno_to_nlm4stat(-ret); + gf_msg(GF_NLM, GF_LOG_ERROR, stat, NFS_MSG_LOCK_FAIL, + "unable to call lk()"); + nlm4_generic_reply(cs->req, cs->args.nlm4_lockargs.cookie, stat); + nfs3_call_state_wipe(cs); + } - GF_REF_PUT (cs); + GF_REF_PUT(cs); - return ret; + return ret; } - int -nlm4_lock_resume (void *carg) +nlm4_lock_resume(void *carg) { - nlm4_stats stat = nlm4_failed; - int ret = -1; - nfs3_call_state_t *cs = NULL; + nlm4_stats stat = nlm4_failed; + int ret = -1; + nfs3_call_state_t *cs = NULL; - if (!carg) - return ret; + if (!carg) + return ret; - cs = GF_REF_GET ((nfs3_call_state_t *)carg); - nlm4_check_fh_resolve_status (cs, stat, nlm4err); - ret = nlm4_file_open_and_resume (cs, nlm4_lock_fd_resume); + cs = GF_REF_GET((nfs3_call_state_t *)carg); + nlm4_check_fh_resolve_status(cs, stat, nlm4err); + ret = nlm4_file_open_and_resume(cs, nlm4_lock_fd_resume); nlm4err: - if (ret < 0) { - gf_msg (GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_OPEN_FAIL, - "unable to open and resume"); - stat = nlm4_errno_to_nlm4stat (-ret); - nlm4_generic_reply (cs->req, cs->args.nlm4_lockargs.cookie, - stat); - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + gf_msg(GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_OPEN_FAIL, + "unable to open and resume"); + stat = nlm4_errno_to_nlm4stat(-ret); + nlm4_generic_reply(cs->req, cs->args.nlm4_lockargs.cookie, stat); + nfs3_call_state_wipe(cs); + } - GF_REF_PUT (cs); + GF_REF_PUT(cs); - return ret; + return ret; } int -nlm4svc_lock_common (rpcsvc_request_t *req, int mon) -{ - int ret = RPCSVC_ACTOR_ERROR; - nlm4_stats stat = nlm4_failed; - struct nfs3_fh fh = {{0}, }; - xlator_t *vol = NULL; - nfs3_state_t *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - struct nfs_state *nfs = NULL; - - if (!req) - return ret; - - nlm4_validate_nfs3_state (req, nfs3, stat, rpcerr, ret); - nfs = nfs_state (nfs3->nfsx); - nlm4_handle_call_state_init (nfs->nfs3state, cs, req, - stat, rpcerr); - - nlm4_prep_nlm4_lockargs (&cs->args.nlm4_lockargs, &cs->lockfh, - &cs->lkowner, cs->cookiebytes); - if (xdr_to_nlm4_lockargs(req->msg[0], &cs->args.nlm4_lockargs) <= 0) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } +nlm4svc_lock_common(rpcsvc_request_t *req, int mon) +{ + int ret = RPCSVC_ACTOR_ERROR; + nlm4_stats stat = nlm4_failed; + struct nfs3_fh fh = { + {0}, + }; + xlator_t *vol = NULL; + nfs3_state_t *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + struct nfs_state *nfs = NULL; + + if (!req) + return ret; - fh = cs->lockfh; - cs->monitor = mon; - nlm4_validate_gluster_fh (&fh, stat, nlm4err); - nlm4_map_fh_to_volume (cs->nfs3state, fh, req, vol, stat, nlm4err); - - if (nlm_grace_period && !cs->args.nlm4_lockargs.reclaim) { - gf_msg (GF_NLM, GF_LOG_WARNING, 0, NFS_MSG_NLM_GRACE_PERIOD, - "NLM in grace period"); - stat = nlm4_denied_grace_period; - nlm4_generic_reply (req, cs->args.nlm4_unlockargs.cookie, stat); - nfs3_call_state_wipe (cs); - return 0; - } + nlm4_validate_nfs3_state(req, nfs3, stat, rpcerr, ret); + nfs = nfs_state(nfs3->nfsx); + nlm4_handle_call_state_init(nfs->nfs3state, cs, req, stat, rpcerr); + + nlm4_prep_nlm4_lockargs(&cs->args.nlm4_lockargs, &cs->lockfh, &cs->lkowner, + cs->cookiebytes); + if (xdr_to_nlm4_lockargs(req->msg[0], &cs->args.nlm4_lockargs) <= 0) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + fh = cs->lockfh; + cs->monitor = mon; + nlm4_validate_gluster_fh(&fh, stat, nlm4err); + nlm4_map_fh_to_volume(cs->nfs3state, fh, req, vol, stat, nlm4err); + + if (nlm_grace_period && !cs->args.nlm4_lockargs.reclaim) { + gf_msg(GF_NLM, GF_LOG_WARNING, 0, NFS_MSG_NLM_GRACE_PERIOD, + "NLM in grace period"); + stat = nlm4_denied_grace_period; + nlm4_generic_reply(req, cs->args.nlm4_unlockargs.cookie, stat); + nfs3_call_state_wipe(cs); + return 0; + } - cs->vol = vol; - cs->trans = rpcsvc_request_transport_ref(req); - nlm4_volume_started_check (nfs3, vol, ret, rpcerr); + cs->vol = vol; + cs->trans = rpcsvc_request_transport_ref(req); + nlm4_volume_started_check(nfs3, vol, ret, rpcerr); - ret = nlm_add_nlmclnt (cs->args.nlm4_lockargs.alock.caller_name); + ret = nlm_add_nlmclnt(cs->args.nlm4_lockargs.alock.caller_name); - ret = nfs3_fh_resolve_and_resume (cs, &fh, - NULL, nlm4_lock_resume); + ret = nfs3_fh_resolve_and_resume(cs, &fh, NULL, nlm4_lock_resume); nlm4err: - if (ret < 0) { - gf_msg (GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR, - "unable to resolve and resume"); - nlm4_generic_reply (cs->req, cs->args.nlm4_lockargs.cookie, - stat); - nfs3_call_state_wipe (cs); - return 0; - } + if (ret < 0) { + gf_msg(GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR, + "unable to resolve and resume"); + nlm4_generic_reply(cs->req, cs->args.nlm4_lockargs.cookie, stat); + nfs3_call_state_wipe(cs); + return 0; + } rpcerr: - if (ret < 0) { - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + nfs3_call_state_wipe(cs); + } - return ret; + return ret; } int -nlm4svc_lock (rpcsvc_request_t *req) +nlm4svc_lock(rpcsvc_request_t *req) { - return nlm4svc_lock_common (req, 1); + return nlm4svc_lock_common(req, 1); } int -nlm4svc_nm_lock (rpcsvc_request_t *req) +nlm4svc_nm_lock(rpcsvc_request_t *req) { - return nlm4svc_lock_common (req, 0); + return nlm4svc_lock_common(req, 0); } int -nlm4svc_cancel_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct gf_flock *flock, - dict_t *xdata) -{ - nlm4_stats stat = nlm4_denied; - nfs3_call_state_t *cs = NULL; - - cs = frame->local; - if (op_ret == -1) { - stat = nlm4_errno_to_nlm4stat (op_errno); - goto err; - } else { - stat = nlm4_granted; - nlm_search_and_delete (cs->fd, &cs->args.nlm4_lockargs.alock); - } +nlm4svc_cancel_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct gf_flock *flock, + dict_t *xdata) +{ + nlm4_stats stat = nlm4_denied; + nfs3_call_state_t *cs = NULL; + + cs = frame->local; + if (op_ret == -1) { + stat = nlm4_errno_to_nlm4stat(op_errno); + goto err; + } else { + stat = nlm4_granted; + nlm_search_and_delete(cs->fd, &cs->args.nlm4_lockargs.alock); + } err: - nlm4_generic_reply (cs->req, cs->args.nlm4_cancargs.cookie, - stat); - nfs3_call_state_wipe (cs); - return 0; + nlm4_generic_reply(cs->req, cs->args.nlm4_cancargs.cookie, stat); + nfs3_call_state_wipe(cs); + return 0; } int -nlm4_cancel_fd_resume (void *carg) -{ - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - nfs3_call_state_t *cs = NULL; - struct gf_flock flock = {0, }; - - if (!carg) - return ret; +nlm4_cancel_fd_resume(void *carg) +{ + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + nfs3_call_state_t *cs = NULL; + struct gf_flock flock = { + 0, + }; + + if (!carg) + return ret; - cs = GF_REF_GET ((nfs3_call_state_t *)carg); - nfs_request_user_init (&nfu, cs->req); - nlm4_lock_to_gf_flock (&flock, &cs->args.nlm4_cancargs.alock, - cs->args.nlm4_cancargs.exclusive); - nlm_copy_lkowner (&nfu.lk_owner, &cs->args.nlm4_cancargs.alock.oh); - flock.l_type = F_UNLCK; - ret = nfs_lk (cs->nfsx, cs->vol, &nfu, cs->fd, F_SETLK, - &flock, nlm4svc_cancel_cbk, cs); + cs = GF_REF_GET((nfs3_call_state_t *)carg); + nfs_request_user_init(&nfu, cs->req); + nlm4_lock_to_gf_flock(&flock, &cs->args.nlm4_cancargs.alock, + cs->args.nlm4_cancargs.exclusive); + nlm_copy_lkowner(&nfu.lk_owner, &cs->args.nlm4_cancargs.alock.oh); + flock.l_type = F_UNLCK; + ret = nfs_lk(cs->nfsx, cs->vol, &nfu, cs->fd, F_SETLK, &flock, + nlm4svc_cancel_cbk, cs); - GF_REF_PUT (cs); + GF_REF_PUT(cs); - return ret; + return ret; } int -nlm4_cancel_resume (void *carg) +nlm4_cancel_resume(void *carg) { - nlm4_stats stat = nlm4_failed; - int ret = -EFAULT; - nfs3_call_state_t *cs = NULL; - nlm_client_t *nlmclnt = NULL; + nlm4_stats stat = nlm4_failed; + int ret = -EFAULT; + nfs3_call_state_t *cs = NULL; + nlm_client_t *nlmclnt = NULL; - if (!carg) - return ret; + if (!carg) + return ret; - cs = GF_REF_GET ((nfs3_call_state_t *)carg); - nlm4_check_fh_resolve_status (cs, stat, nlm4err); - - nlmclnt = nlm_get_uniq (cs->args.nlm4_cancargs.alock.caller_name); - if (nlmclnt == NULL) { - gf_msg (GF_NLM, GF_LOG_ERROR, ENOLCK, NFS_MSG_NO_MEMORY, - "nlm_get_uniq() returned NULL"); - goto nlm4err; - } - cs->fd = fd_lookup_uint64 (cs->resolvedloc.inode, (uint64_t)nlmclnt); - if (cs->fd == NULL) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_FD_LOOKUP_NULL, - "fd_lookup_uint64 retrned NULL"); - goto nlm4err; - } - ret = nlm4_cancel_fd_resume (cs); + cs = GF_REF_GET((nfs3_call_state_t *)carg); + nlm4_check_fh_resolve_status(cs, stat, nlm4err); + + nlmclnt = nlm_get_uniq(cs->args.nlm4_cancargs.alock.caller_name); + if (nlmclnt == NULL) { + gf_msg(GF_NLM, GF_LOG_ERROR, ENOLCK, NFS_MSG_NO_MEMORY, + "nlm_get_uniq() returned NULL"); + goto nlm4err; + } + cs->fd = fd_lookup_uint64(cs->resolvedloc.inode, (uint64_t)nlmclnt); + if (cs->fd == NULL) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_FD_LOOKUP_NULL, + "fd_lookup_uint64 retrned NULL"); + goto nlm4err; + } + ret = nlm4_cancel_fd_resume(cs); nlm4err: - if (ret < 0) { - gf_msg (GF_NLM, GF_LOG_WARNING, -ret, NFS_MSG_LOCK_FAIL, - "unable to unlock_fd_resume()"); - stat = nlm4_errno_to_nlm4stat (-ret); - nlm4_generic_reply (cs->req, cs->args.nlm4_cancargs.cookie, - stat); - - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + gf_msg(GF_NLM, GF_LOG_WARNING, -ret, NFS_MSG_LOCK_FAIL, + "unable to unlock_fd_resume()"); + stat = nlm4_errno_to_nlm4stat(-ret); + nlm4_generic_reply(cs->req, cs->args.nlm4_cancargs.cookie, stat); - GF_REF_PUT (cs); + nfs3_call_state_wipe(cs); + } - /* clean up is taken care of */ - return 0; + GF_REF_PUT(cs); + + /* clean up is taken care of */ + return 0; } int -nlm4svc_cancel (rpcsvc_request_t *req) -{ - xlator_t *vol = NULL; - nlm4_stats stat = nlm4_failed; - struct nfs_state *nfs = NULL; - nfs3_state_t *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - int ret = RPCSVC_ACTOR_ERROR; - struct nfs3_fh fh = {{0}, }; - - if (!req) - return ret; - - nlm4_validate_nfs3_state (req, nfs3, stat, rpcerr, ret); - nfs = nfs_state (nfs3->nfsx); - nlm4_handle_call_state_init (nfs->nfs3state, cs, req, - stat, rpcerr); - - nlm4_prep_nlm4_cancargs (&cs->args.nlm4_cancargs, &fh, &cs->lkowner, - cs->cookiebytes); - if (xdr_to_nlm4_cancelargs(req->msg[0], &cs->args.nlm4_cancargs) <= 0) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } - - nlm4_validate_gluster_fh (&fh, stat, nlm4err); - nlm4_map_fh_to_volume (cs->nfs3state, fh, req, vol, stat, nlm4err); +nlm4svc_cancel(rpcsvc_request_t *req) +{ + xlator_t *vol = NULL; + nlm4_stats stat = nlm4_failed; + struct nfs_state *nfs = NULL; + nfs3_state_t *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + int ret = RPCSVC_ACTOR_ERROR; + struct nfs3_fh fh = { + {0}, + }; + + if (!req) + return ret; - if (nlm_grace_period) { - gf_msg (GF_NLM, GF_LOG_WARNING, 0, NFS_MSG_NLM_GRACE_PERIOD, - "NLM in grace period"); - stat = nlm4_denied_grace_period; - nlm4_generic_reply (req, cs->args.nlm4_unlockargs.cookie, stat); - nfs3_call_state_wipe (cs); - return 0; - } + nlm4_validate_nfs3_state(req, nfs3, stat, rpcerr, ret); + nfs = nfs_state(nfs3->nfsx); + nlm4_handle_call_state_init(nfs->nfs3state, cs, req, stat, rpcerr); + + nlm4_prep_nlm4_cancargs(&cs->args.nlm4_cancargs, &fh, &cs->lkowner, + cs->cookiebytes); + if (xdr_to_nlm4_cancelargs(req->msg[0], &cs->args.nlm4_cancargs) <= 0) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + nlm4_validate_gluster_fh(&fh, stat, nlm4err); + nlm4_map_fh_to_volume(cs->nfs3state, fh, req, vol, stat, nlm4err); + + if (nlm_grace_period) { + gf_msg(GF_NLM, GF_LOG_WARNING, 0, NFS_MSG_NLM_GRACE_PERIOD, + "NLM in grace period"); + stat = nlm4_denied_grace_period; + nlm4_generic_reply(req, cs->args.nlm4_unlockargs.cookie, stat); + nfs3_call_state_wipe(cs); + return 0; + } - cs->vol = vol; - nlm4_volume_started_check (nfs3, vol, ret, rpcerr); + cs->vol = vol; + nlm4_volume_started_check(nfs3, vol, ret, rpcerr); - ret = nfs3_fh_resolve_and_resume (cs, &fh, - NULL, nlm4_cancel_resume); + ret = nfs3_fh_resolve_and_resume(cs, &fh, NULL, nlm4_cancel_resume); nlm4err: - if (ret < 0) { - gf_msg (GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR, - "unable to resolve and resume"); - nlm4_generic_reply (cs->req, cs->args.nlm4_cancargs.cookie, - stat); - nfs3_call_state_wipe (cs); - return 0; - } + if (ret < 0) { + gf_msg(GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR, + "unable to resolve and resume"); + nlm4_generic_reply(cs->req, cs->args.nlm4_cancargs.cookie, stat); + nfs3_call_state_wipe(cs); + return 0; + } rpcerr: - if (ret < 0) { - nfs3_call_state_wipe (cs); - } - return ret; + if (ret < 0) { + nfs3_call_state_wipe(cs); + } + return ret; } int -nlm4svc_unlock_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct gf_flock *flock, - dict_t *xdata) -{ - nlm4_stats stat = nlm4_denied; - nfs3_call_state_t *cs = NULL; - - cs = GF_REF_GET ((nfs3_call_state_t*) frame->local); - if (op_ret == -1) { - stat = nlm4_errno_to_nlm4stat (op_errno); - goto err; - } else { - stat = nlm4_granted; - if (flock->l_type == F_UNLCK) - nlm_search_and_delete (cs->fd, - &cs->args.nlm4_unlockargs.alock); - } +nlm4svc_unlock_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct gf_flock *flock, + dict_t *xdata) +{ + nlm4_stats stat = nlm4_denied; + nfs3_call_state_t *cs = NULL; + + cs = GF_REF_GET((nfs3_call_state_t *)frame->local); + if (op_ret == -1) { + stat = nlm4_errno_to_nlm4stat(op_errno); + goto err; + } else { + stat = nlm4_granted; + if (flock->l_type == F_UNLCK) + nlm_search_and_delete(cs->fd, &cs->args.nlm4_unlockargs.alock); + } err: - nlm4_generic_reply (cs->req, cs->args.nlm4_unlockargs.cookie, stat); - GF_REF_PUT (cs); - return 0; + nlm4_generic_reply(cs->req, cs->args.nlm4_unlockargs.cookie, stat); + GF_REF_PUT(cs); + return 0; } int -nlm4_unlock_fd_resume (void *carg) -{ - int ret = -EFAULT; - nfs_user_t nfu = {0, }; - nfs3_call_state_t *cs = NULL; - struct gf_flock flock = {0, }; - - if (!carg) - return ret; - cs = GF_REF_GET ((nfs3_call_state_t *)carg); - nfs_request_user_init (&nfu, cs->req); - nlm4_lock_to_gf_flock (&flock, &cs->args.nlm4_unlockargs.alock, 0); - nlm_copy_lkowner (&nfu.lk_owner, &cs->args.nlm4_unlockargs.alock.oh); - flock.l_type = F_UNLCK; - ret = nfs_lk (cs->nfsx, cs->vol, &nfu, cs->fd, F_SETLK, - &flock, nlm4svc_unlock_cbk, cs); +nlm4_unlock_fd_resume(void *carg) +{ + int ret = -EFAULT; + nfs_user_t nfu = { + 0, + }; + nfs3_call_state_t *cs = NULL; + struct gf_flock flock = { + 0, + }; + + if (!carg) + return ret; + cs = GF_REF_GET((nfs3_call_state_t *)carg); + nfs_request_user_init(&nfu, cs->req); + nlm4_lock_to_gf_flock(&flock, &cs->args.nlm4_unlockargs.alock, 0); + nlm_copy_lkowner(&nfu.lk_owner, &cs->args.nlm4_unlockargs.alock.oh); + flock.l_type = F_UNLCK; + ret = nfs_lk(cs->nfsx, cs->vol, &nfu, cs->fd, F_SETLK, &flock, + nlm4svc_unlock_cbk, cs); - GF_REF_PUT (cs); + GF_REF_PUT(cs); - return ret; + return ret; } int -nlm4_unlock_resume (void *carg) +nlm4_unlock_resume(void *carg) { - nlm4_stats stat = nlm4_failed; - int ret = -1; - nfs3_call_state_t *cs = NULL; - nlm_client_t *nlmclnt = NULL; - char *caller_name = NULL; - - if (!carg) - return ret; + nlm4_stats stat = nlm4_failed; + int ret = -1; + nfs3_call_state_t *cs = NULL; + nlm_client_t *nlmclnt = NULL; + char *caller_name = NULL; - cs = GF_REF_GET ((nfs3_call_state_t *)carg); - nlm4_check_fh_resolve_status (cs, stat, nlm4err); - caller_name = cs->args.nlm4_unlockargs.alock.caller_name; + if (!carg) + return ret; - nlmclnt = nlm_get_uniq (caller_name); - if (nlmclnt == NULL) { - stat = nlm4_granted; - gf_msg (GF_NLM, GF_LOG_WARNING, ENOLCK, NFS_MSG_NO_MEMORY, - "nlm_get_uniq() returned NULL for %s", caller_name); - goto nlm4err; - } - cs->fd = fd_lookup_uint64 (cs->resolvedloc.inode, (uint64_t)nlmclnt); - if (cs->fd == NULL) { - stat = nlm4_granted; - gf_msg (GF_NLM, GF_LOG_WARNING, 0, NFS_MSG_FD_LOOKUP_NULL, - "fd_lookup_uint64() returned NULL"); - goto nlm4err; - } - ret = nlm4_unlock_fd_resume (cs); + cs = GF_REF_GET((nfs3_call_state_t *)carg); + nlm4_check_fh_resolve_status(cs, stat, nlm4err); + caller_name = cs->args.nlm4_unlockargs.alock.caller_name; + + nlmclnt = nlm_get_uniq(caller_name); + if (nlmclnt == NULL) { + stat = nlm4_granted; + gf_msg(GF_NLM, GF_LOG_WARNING, ENOLCK, NFS_MSG_NO_MEMORY, + "nlm_get_uniq() returned NULL for %s", caller_name); + goto nlm4err; + } + cs->fd = fd_lookup_uint64(cs->resolvedloc.inode, (uint64_t)nlmclnt); + if (cs->fd == NULL) { + stat = nlm4_granted; + gf_msg(GF_NLM, GF_LOG_WARNING, 0, NFS_MSG_FD_LOOKUP_NULL, + "fd_lookup_uint64() returned NULL"); + goto nlm4err; + } + ret = nlm4_unlock_fd_resume(cs); nlm4err: - if (ret < 0) { - gf_msg (GF_NLM, GF_LOG_WARNING, -ret, NFS_MSG_LOCK_FAIL, - "unable to unlock_fd_resume"); - stat = nlm4_errno_to_nlm4stat (-ret); - nlm4_generic_reply (cs->req, cs->args.nlm4_unlockargs.cookie, - stat); - - nfs3_call_state_wipe (cs); - } + if (ret < 0) { + gf_msg(GF_NLM, GF_LOG_WARNING, -ret, NFS_MSG_LOCK_FAIL, + "unable to unlock_fd_resume"); + stat = nlm4_errno_to_nlm4stat(-ret); + nlm4_generic_reply(cs->req, cs->args.nlm4_unlockargs.cookie, stat); - GF_REF_PUT (cs); + nfs3_call_state_wipe(cs); + } - /* we have already taken care of cleanup */ - return 0; + GF_REF_PUT(cs); + + /* we have already taken care of cleanup */ + return 0; } int -nlm4svc_unlock (rpcsvc_request_t *req) -{ - xlator_t *vol = NULL; - nlm4_stats stat = nlm4_failed; - struct nfs_state *nfs = NULL; - nfs3_state_t *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - int ret = RPCSVC_ACTOR_ERROR; - struct nfs3_fh fh = {{0}, }; - - if (!req) - return ret; - - nlm4_validate_nfs3_state (req, nfs3, stat, rpcerr, ret); - nfs = nfs_state (nfs3->nfsx); - nlm4_handle_call_state_init (nfs->nfs3state, cs, req, - stat, rpcerr); - - nlm4_prep_nlm4_unlockargs (&cs->args.nlm4_unlockargs, &fh, &cs->lkowner, - cs->cookiebytes); - if (xdr_to_nlm4_unlockargs(req->msg[0], &cs->args.nlm4_unlockargs) <= 0) - { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } - - nlm4_validate_gluster_fh (&fh, stat, nlm4err); - nlm4_map_fh_to_volume (cs->nfs3state, fh, req, vol, stat, nlm4err); +nlm4svc_unlock(rpcsvc_request_t *req) +{ + xlator_t *vol = NULL; + nlm4_stats stat = nlm4_failed; + struct nfs_state *nfs = NULL; + nfs3_state_t *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + int ret = RPCSVC_ACTOR_ERROR; + struct nfs3_fh fh = { + {0}, + }; + + if (!req) + return ret; - if (nlm_grace_period) { - gf_msg (GF_NLM, GF_LOG_WARNING, 0, NFS_MSG_NLM_GRACE_PERIOD, - "NLM in grace period"); - stat = nlm4_denied_grace_period; - nlm4_generic_reply (req, cs->args.nlm4_unlockargs.cookie, stat); - nfs3_call_state_wipe (cs); - return 0; - } + nlm4_validate_nfs3_state(req, nfs3, stat, rpcerr, ret); + nfs = nfs_state(nfs3->nfsx); + nlm4_handle_call_state_init(nfs->nfs3state, cs, req, stat, rpcerr); + + nlm4_prep_nlm4_unlockargs(&cs->args.nlm4_unlockargs, &fh, &cs->lkowner, + cs->cookiebytes); + if (xdr_to_nlm4_unlockargs(req->msg[0], &cs->args.nlm4_unlockargs) <= 0) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + nlm4_validate_gluster_fh(&fh, stat, nlm4err); + nlm4_map_fh_to_volume(cs->nfs3state, fh, req, vol, stat, nlm4err); + + if (nlm_grace_period) { + gf_msg(GF_NLM, GF_LOG_WARNING, 0, NFS_MSG_NLM_GRACE_PERIOD, + "NLM in grace period"); + stat = nlm4_denied_grace_period; + nlm4_generic_reply(req, cs->args.nlm4_unlockargs.cookie, stat); + nfs3_call_state_wipe(cs); + return 0; + } - cs->vol = vol; - /* FIXME: check if trans is being used at all for unlock */ - cs->trans = rpcsvc_request_transport_ref(req); - nlm4_volume_started_check (nfs3, vol, ret, rpcerr); + cs->vol = vol; + /* FIXME: check if trans is being used at all for unlock */ + cs->trans = rpcsvc_request_transport_ref(req); + nlm4_volume_started_check(nfs3, vol, ret, rpcerr); - ret = nfs3_fh_resolve_and_resume (cs, &fh, - NULL, nlm4_unlock_resume); + ret = nfs3_fh_resolve_and_resume(cs, &fh, NULL, nlm4_unlock_resume); nlm4err: - if (ret < 0) { - gf_msg (GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR, - "unable to resolve and resume"); - nlm4_generic_reply (req, cs->args.nlm4_unlockargs.cookie, stat); - nfs3_call_state_wipe (cs); - return 0; - } + if (ret < 0) { + gf_msg(GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR, + "unable to resolve and resume"); + nlm4_generic_reply(req, cs->args.nlm4_unlockargs.cookie, stat); + nfs3_call_state_wipe(cs); + return 0; + } rpcerr: - if (ret < 0) { - nfs3_call_state_wipe (cs); - } - return ret; + if (ret < 0) { + nfs3_call_state_wipe(cs); + } + return ret; } int -nlm4_share_reply (nfs3_call_state_t *cs, nlm4_stats stat) +nlm4_share_reply(nfs3_call_state_t *cs, nlm4_stats stat) { - nlm4_shareres res = {{0}, 0, 0}; + nlm4_shareres res = {{0}, 0, 0}; - if (!cs) - return -1; + if (!cs) + return -1; - res.cookie = cs->args.nlm4_shareargs.cookie; - res.stat = stat; - res.sequence = 0; + res.cookie = cs->args.nlm4_shareargs.cookie; + res.stat = stat; + res.sequence = 0; - nlm4svc_submit_reply (cs->req, (void *)&res, - (nlm4_serializer)xdr_serialize_nlm4_shareres); - return 0; + nlm4svc_submit_reply(cs->req, (void *)&res, + (nlm4_serializer)xdr_serialize_nlm4_shareres); + return 0; } nlm_share_t * -nlm4_share_new () -{ - nlm_share_t *share = NULL; - - share = GF_CALLOC (1, sizeof (nlm_share_t), - gf_nfs_mt_nlm4_share); - if (!share) - goto out; - - INIT_LIST_HEAD (&share->client_list); - INIT_LIST_HEAD (&share->inode_list); - out: - return share; -} - -int -nlm4_add_share_to_inode (nlm_share_t *share) +nlm4_share_new() { - int ret = -1; - uint64_t ctx = 0; - struct list_head *head = NULL; - xlator_t *this = NULL; - inode_t *inode = NULL; - struct nfs_inode_ctx *ictx = NULL; - struct nfs_state *priv = NULL; - - this = THIS; - priv = this->private; - inode = share->inode; - ret = inode_ctx_get (inode, this, &ctx); - - if (ret == -1) { - ictx = GF_CALLOC (1, sizeof (struct nfs_inode_ctx), - gf_nfs_mt_inode_ctx); - if (!ictx ) { - gf_msg (this->name, GF_LOG_ERROR, ENOMEM, - NFS_MSG_NO_MEMORY, - "could not allocate nfs inode ctx"); - ret = -1; - goto out; - } - ictx->generation = priv->generation; - - head = &ictx->shares; - INIT_LIST_HEAD (head); - - ret = inode_ctx_put (inode, this, (uint64_t)ictx); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, - NFS_MSG_SHARE_LIST_STORE_FAIL, - "could not store share list"); - goto out; - } - } - else { - ictx = (struct nfs_inode_ctx *)ctx; - head = &ictx->shares; - } + nlm_share_t *share = NULL; - list_add (&share->inode_list, head); + share = GF_CALLOC(1, sizeof(nlm_share_t), gf_nfs_mt_nlm4_share); + if (!share) + goto out; - out: - if (ret && head) - GF_FREE (head); - - return ret; + INIT_LIST_HEAD(&share->client_list); + INIT_LIST_HEAD(&share->inode_list); +out: + return share; } int -nlm4_approve_share_reservation (nfs3_call_state_t *cs) -{ - int ret = -1; - uint64_t ctx = 0; - fsh_mode req_mode = 0; - fsh_access req_access = 0; - inode_t *inode = NULL; - nlm_share_t *share = NULL; - struct list_head *head = NULL; - struct nfs_inode_ctx *ictx = NULL; - - if (!cs) - goto out; +nlm4_add_share_to_inode(nlm_share_t *share) +{ + int ret = -1; + uint64_t ctx = 0; + struct list_head *head = NULL; + xlator_t *this = NULL; + inode_t *inode = NULL; + struct nfs_inode_ctx *ictx = NULL; + struct nfs_state *priv = NULL; + + this = THIS; + priv = this->private; + inode = share->inode; + ret = inode_ctx_get(inode, this, &ctx); + + if (ret == -1) { + ictx = GF_CALLOC(1, sizeof(struct nfs_inode_ctx), gf_nfs_mt_inode_ctx); + if (!ictx) { + gf_msg(this->name, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "could not allocate nfs inode ctx"); + ret = -1; + goto out; + } + ictx->generation = priv->generation; - inode = cs->resolvedloc.inode; + head = &ictx->shares; + INIT_LIST_HEAD(head); - ret = inode_ctx_get (inode, THIS, &ctx); + ret = inode_ctx_put(inode, this, (uint64_t)ictx); if (ret) { - ret = 0; - goto out; + gf_msg(this->name, GF_LOG_ERROR, 0, NFS_MSG_SHARE_LIST_STORE_FAIL, + "could not store share list"); + goto out; } + } else { ictx = (struct nfs_inode_ctx *)ctx; - head = &ictx->shares; - if (!head || list_empty (head)) - goto out; + } - req_mode = cs->args.nlm4_shareargs.share.mode; - req_access = cs->args.nlm4_shareargs.share.access; + list_add(&share->inode_list, head); - list_for_each_entry (share, head, inode_list) { - ret = (((req_mode & share->access) == 0) && - ((req_access & share->mode) == 0)); - if (!ret) { - ret = -1; - goto out; - } - } - ret = 0; +out: + if (ret && head) + GF_FREE(head); - out: - return ret; + return ret; } int -nlm4_create_share_reservation (nfs3_call_state_t *cs) +nlm4_approve_share_reservation(nfs3_call_state_t *cs) { - int ret = -1; - nlm_share_t *share = NULL; - nlm_client_t *client = NULL; - inode_t *inode = NULL; + int ret = -1; + uint64_t ctx = 0; + fsh_mode req_mode = 0; + fsh_access req_access = 0; + inode_t *inode = NULL; + nlm_share_t *share = NULL; + struct list_head *head = NULL; + struct nfs_inode_ctx *ictx = NULL; - LOCK (&nlm_client_list_lk); + if (!cs) + goto out; - inode = inode_ref (cs->resolvedloc.inode); - if (!inode) { - gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_INODE_NOT_FOUND, - "inode not found"); - goto out; - } + inode = cs->resolvedloc.inode; - client = __nlm_get_uniq (cs->args.nlm4_shareargs.share.caller_name); - if (!client) { - /* DO NOT add client. the client is supposed - to be here, since nlm4svc_share adds it */ - gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CLIENT_NOT_FOUND, - "client not found"); - goto out; - } + ret = inode_ctx_get(inode, THIS, &ctx); + if (ret) { + ret = 0; + goto out; + } + ictx = (struct nfs_inode_ctx *)ctx; - ret = nlm4_approve_share_reservation (cs); - if (ret) - goto out; + head = &ictx->shares; + if (!head || list_empty(head)) + goto out; - share = nlm4_share_new (); - if (!share) { - ret = -1; - goto out; - } + req_mode = cs->args.nlm4_shareargs.share.mode; + req_access = cs->args.nlm4_shareargs.share.access; - share->inode = inode; - share->mode = cs->args.nlm4_shareargs.share.mode; - share->access = cs->args.nlm4_shareargs.share.access; - nlm_copy_lkowner (&share->lkowner, - &cs->args.nlm4_shareargs.share.oh); + list_for_each_entry(share, head, inode_list) + { + ret = (((req_mode & share->access) == 0) && + ((req_access & share->mode) == 0)); + if (!ret) { + ret = -1; + goto out; + } + } + ret = 0; - ret = nlm4_add_share_to_inode (share); - if (ret) - goto out; +out: + return ret; +} - list_add (&share->client_list, &client->shares); +int +nlm4_create_share_reservation(nfs3_call_state_t *cs) +{ + int ret = -1; + nlm_share_t *share = NULL; + nlm_client_t *client = NULL; + inode_t *inode = NULL; + + LOCK(&nlm_client_list_lk); + + inode = inode_ref(cs->resolvedloc.inode); + if (!inode) { + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_INODE_NOT_FOUND, + "inode not found"); + goto out; + } + + client = __nlm_get_uniq(cs->args.nlm4_shareargs.share.caller_name); + if (!client) { + /* DO NOT add client. the client is supposed + to be here, since nlm4svc_share adds it */ + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CLIENT_NOT_FOUND, + "client not found"); + goto out; + } + + ret = nlm4_approve_share_reservation(cs); + if (ret) + goto out; + + share = nlm4_share_new(); + if (!share) { + ret = -1; + goto out; + } + + share->inode = inode; + share->mode = cs->args.nlm4_shareargs.share.mode; + share->access = cs->args.nlm4_shareargs.share.access; + nlm_copy_lkowner(&share->lkowner, &cs->args.nlm4_shareargs.share.oh); + + ret = nlm4_add_share_to_inode(share); + if (ret) + goto out; + + list_add(&share->client_list, &client->shares); - out: - if (ret && inode) { - inode_unref (inode); - GF_FREE (share); - } +out: + if (ret && inode) { + inode_unref(inode); + GF_FREE(share); + } - UNLOCK (&nlm_client_list_lk); - return ret; + UNLOCK(&nlm_client_list_lk); + return ret; } /* @@ -2096,676 +2093,672 @@ nlm4_create_share_reservation (nfs3_call_state_t *cs) at *nfs xlator level only*, in memory */ int -nlm4_share_resume (void *call_state) +nlm4_share_resume(void *call_state) { - int ret = -1; - nlm4_stats stat = nlm4_failed; - nfs3_call_state_t *cs = NULL; + int ret = -1; + nlm4_stats stat = nlm4_failed; + nfs3_call_state_t *cs = NULL; - if (!call_state) - return ret; + if (!call_state) + return ret; - cs = (nfs3_call_state_t *)call_state; - nlm4_check_fh_resolve_status (cs, stat, out); + cs = (nfs3_call_state_t *)call_state; + nlm4_check_fh_resolve_status(cs, stat, out); - ret = nlm4_create_share_reservation (cs); - if (!ret) - stat = nlm4_granted; + ret = nlm4_create_share_reservation(cs); + if (!ret) + stat = nlm4_granted; - out: - nlm4_share_reply (cs, stat); - nfs3_call_state_wipe (cs); - return 0; +out: + nlm4_share_reply(cs, stat); + nfs3_call_state_wipe(cs); + return 0; } int -nlm4svc_share (rpcsvc_request_t *req) -{ - nlm4_stats stat = nlm4_failed; - xlator_t *vol = NULL; - nfs3_state_t *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - struct nfs_state *nfs = NULL; - struct nfs3_fh fh = {{0}, }; - int ret = RPCSVC_ACTOR_ERROR; - - if (!req) - return ret; - - nlm4_validate_nfs3_state (req, nfs3, stat, rpcerr, ret); - nfs = nfs_state (nfs3->nfsx); - nlm4_handle_call_state_init (nfs->nfs3state, cs, req, - stat, rpcerr); - - nlm4_prep_shareargs (&cs->args.nlm4_shareargs, &cs->lockfh, - &cs->lkowner, cs->cookiebytes); - - if (xdr_to_nlm4_shareargs (req->msg[0], - &cs->args.nlm4_shareargs) <= 0) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding SHARE args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } +nlm4svc_share(rpcsvc_request_t *req) +{ + nlm4_stats stat = nlm4_failed; + xlator_t *vol = NULL; + nfs3_state_t *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + struct nfs_state *nfs = NULL; + struct nfs3_fh fh = { + {0}, + }; + int ret = RPCSVC_ACTOR_ERROR; + + if (!req) + return ret; - fh = cs->lockfh; - nlm4_validate_gluster_fh (&fh, stat, nlm4err); - nlm4_map_fh_to_volume (cs->nfs3state, fh, req, - vol, stat, nlm4err); - - if (nlm_grace_period && !cs->args.nlm4_shareargs.reclaim) { - gf_msg_debug (GF_NLM, 0, "NLM in grace period"); - stat = nlm4_denied_grace_period; - nlm4_share_reply (cs, stat); - nfs3_call_state_wipe (cs); - return 0; - } + nlm4_validate_nfs3_state(req, nfs3, stat, rpcerr, ret); + nfs = nfs_state(nfs3->nfsx); + nlm4_handle_call_state_init(nfs->nfs3state, cs, req, stat, rpcerr); + + nlm4_prep_shareargs(&cs->args.nlm4_shareargs, &cs->lockfh, &cs->lkowner, + cs->cookiebytes); + + if (xdr_to_nlm4_shareargs(req->msg[0], &cs->args.nlm4_shareargs) <= 0) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding SHARE args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + fh = cs->lockfh; + nlm4_validate_gluster_fh(&fh, stat, nlm4err); + nlm4_map_fh_to_volume(cs->nfs3state, fh, req, vol, stat, nlm4err); + + if (nlm_grace_period && !cs->args.nlm4_shareargs.reclaim) { + gf_msg_debug(GF_NLM, 0, "NLM in grace period"); + stat = nlm4_denied_grace_period; + nlm4_share_reply(cs, stat); + nfs3_call_state_wipe(cs); + return 0; + } - cs->vol = vol; - cs->trans = rpcsvc_request_transport_ref(req); - nlm4_volume_started_check (nfs3, vol, ret, rpcerr); + cs->vol = vol; + cs->trans = rpcsvc_request_transport_ref(req); + nlm4_volume_started_check(nfs3, vol, ret, rpcerr); - ret = nlm_add_nlmclnt (cs->args.nlm4_shareargs.share.caller_name); + ret = nlm_add_nlmclnt(cs->args.nlm4_shareargs.share.caller_name); - ret = nfs3_fh_resolve_and_resume (cs, &fh, NULL, nlm4_share_resume); + ret = nfs3_fh_resolve_and_resume(cs, &fh, NULL, nlm4_share_resume); - nlm4err: - if (ret < 0) { - gf_msg (GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_SHARE_CALL_FAIL, - "SHARE call failed"); - nlm4_share_reply (cs, stat); - nfs3_call_state_wipe (cs); - return 0; - } +nlm4err: + if (ret < 0) { + gf_msg(GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_SHARE_CALL_FAIL, + "SHARE call failed"); + nlm4_share_reply(cs, stat); + nfs3_call_state_wipe(cs); + return 0; + } - rpcerr: - if (ret < 0) - nfs3_call_state_wipe (cs); +rpcerr: + if (ret < 0) + nfs3_call_state_wipe(cs); - return ret; + return ret; } int -nlm4_remove_share_reservation (nfs3_call_state_t *cs) -{ - int ret = -1; - uint64_t ctx = 0; - fsh_mode req_mode = 0; - fsh_access req_access = 0; - nlm_share_t *share = NULL; - nlm_share_t *tmp = NULL; - nlm_client_t *client = NULL; - char *caller = NULL; - inode_t *inode = NULL; - xlator_t *this = NULL; - struct list_head *head = NULL; - nlm4_shareargs *args = NULL; - struct nfs_inode_ctx *ictx = NULL; - - LOCK (&nlm_client_list_lk); - - args = &cs->args.nlm4_shareargs; - caller = args->share.caller_name; - - client = __nlm_get_uniq (caller); - if (!client) { - gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CLIENT_NOT_FOUND, - "client not found: %s", caller); - goto out; - } - - inode = cs->resolvedloc.inode; - if (!inode) { - gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_INODE_NOT_FOUND, - "inode not found: client: %s", caller); - goto out; - } - - this = THIS; - ret = inode_ctx_get (inode, this, &ctx); +nlm4_remove_share_reservation(nfs3_call_state_t *cs) +{ + int ret = -1; + uint64_t ctx = 0; + fsh_mode req_mode = 0; + fsh_access req_access = 0; + nlm_share_t *share = NULL; + nlm_share_t *tmp = NULL; + nlm_client_t *client = NULL; + char *caller = NULL; + inode_t *inode = NULL; + xlator_t *this = NULL; + struct list_head *head = NULL; + nlm4_shareargs *args = NULL; + struct nfs_inode_ctx *ictx = NULL; + + LOCK(&nlm_client_list_lk); + + args = &cs->args.nlm4_shareargs; + caller = args->share.caller_name; + + client = __nlm_get_uniq(caller); + if (!client) { + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CLIENT_NOT_FOUND, + "client not found: %s", caller); + goto out; + } + + inode = cs->resolvedloc.inode; + if (!inode) { + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_INODE_NOT_FOUND, + "inode not found: client: %s", caller); + goto out; + } + + this = THIS; + ret = inode_ctx_get(inode, this, &ctx); + if (ret) { + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_INODE_SHARES_NOT_FOUND, + "no shares found for inode:" + "gfid: %s; client: %s", + inode->gfid, caller); + goto out; + } + ictx = (struct nfs_inode_ctx *)ctx; + + head = &ictx->shares; + if (list_empty(head)) { + ret = -1; + goto out; + } + + ret = 0; + req_mode = args->share.mode; + req_access = args->share.access; + + list_for_each_entry_safe(share, tmp, head, inode_list) + { + ret = ((req_mode == share->mode) && (req_access == share->access) && + nlm_is_oh_same_lkowner(&share->lkowner, &args->share.oh)); if (ret) { - gf_msg (GF_NLM, GF_LOG_ERROR, 0, - NFS_MSG_INODE_SHARES_NOT_FOUND, - "no shares found for inode:" - "gfid: %s; client: %s", - inode->gfid, caller); - goto out; + list_del(&share->client_list); + list_del(&share->inode_list); + inode_unref(share->inode); + GF_FREE(share); + break; } - ictx = (struct nfs_inode_ctx *)ctx; - - head = &ictx->shares; - if (list_empty (head)) { - ret = -1; - goto out; - } - - ret = 0; - req_mode = args->share.mode; - req_access = args->share.access; - - list_for_each_entry_safe (share, tmp, head, inode_list) { - ret = ((req_mode == share->mode) && - (req_access == share->access) && - nlm_is_oh_same_lkowner (&share->lkowner, &args->share.oh)); - if (ret) { - list_del (&share->client_list); - list_del (&share->inode_list); - inode_unref (share->inode); - GF_FREE (share); - break; - } - } - - ret = 0; - out: - UNLOCK (&nlm_client_list_lk); - return ret; + } + ret = 0; +out: + UNLOCK(&nlm_client_list_lk); + return ret; } int -nlm4_unshare_resume (void *call_state) +nlm4_unshare_resume(void *call_state) { - int ret = -1; - nlm4_stats stat = nlm4_failed; - nfs3_call_state_t *cs = NULL; + int ret = -1; + nlm4_stats stat = nlm4_failed; + nfs3_call_state_t *cs = NULL; - if (!call_state) - return ret; + if (!call_state) + return ret; - cs = (nfs3_call_state_t *)call_state; + cs = (nfs3_call_state_t *)call_state; - nlm4_check_fh_resolve_status (cs, stat, out); - ret = nlm4_remove_share_reservation (cs); - if (!ret) - stat = nlm4_granted; + nlm4_check_fh_resolve_status(cs, stat, out); + ret = nlm4_remove_share_reservation(cs); + if (!ret) + stat = nlm4_granted; - out: - nlm4_share_reply (cs, stat); - nfs3_call_state_wipe (cs); - return 0; +out: + nlm4_share_reply(cs, stat); + nfs3_call_state_wipe(cs); + return 0; } int -nlm4svc_unshare (rpcsvc_request_t *req) -{ - nlm4_stats stat = nlm4_failed; - xlator_t *vol = NULL; - nfs3_state_t *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - struct nfs_state *nfs = NULL; - struct nfs3_fh fh = {{0}, }; - int ret = RPCSVC_ACTOR_ERROR; - - if (!req) - return ret; - - nlm4_validate_nfs3_state (req, nfs3, stat, rpcerr, ret); - nfs = nfs_state (nfs3->nfsx); - nlm4_handle_call_state_init (nfs->nfs3state, cs, req, - stat, rpcerr); - - nlm4_prep_shareargs (&cs->args.nlm4_shareargs, &cs->lockfh, - &cs->lkowner, cs->cookiebytes); - - if (xdr_to_nlm4_shareargs (req->msg[0], - &cs->args.nlm4_shareargs) <= 0) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding UNSHARE args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto rpcerr; - } +nlm4svc_unshare(rpcsvc_request_t *req) +{ + nlm4_stats stat = nlm4_failed; + xlator_t *vol = NULL; + nfs3_state_t *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + struct nfs_state *nfs = NULL; + struct nfs3_fh fh = { + {0}, + }; + int ret = RPCSVC_ACTOR_ERROR; + + if (!req) + return ret; - fh = cs->lockfh; - nlm4_validate_gluster_fh (&fh, stat, nlm4err); - nlm4_map_fh_to_volume (cs->nfs3state, fh, req, - vol, stat, nlm4err); - - if (nlm_grace_period && !cs->args.nlm4_shareargs.reclaim) { - gf_msg_debug (GF_NLM, 0, "NLM in grace period"); - stat = nlm4_denied_grace_period; - nlm4_share_reply (cs, stat); - nfs3_call_state_wipe (cs); - return 0; - } + nlm4_validate_nfs3_state(req, nfs3, stat, rpcerr, ret); + nfs = nfs_state(nfs3->nfsx); + nlm4_handle_call_state_init(nfs->nfs3state, cs, req, stat, rpcerr); + + nlm4_prep_shareargs(&cs->args.nlm4_shareargs, &cs->lockfh, &cs->lkowner, + cs->cookiebytes); + + if (xdr_to_nlm4_shareargs(req->msg[0], &cs->args.nlm4_shareargs) <= 0) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding UNSHARE args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto rpcerr; + } + + fh = cs->lockfh; + nlm4_validate_gluster_fh(&fh, stat, nlm4err); + nlm4_map_fh_to_volume(cs->nfs3state, fh, req, vol, stat, nlm4err); + + if (nlm_grace_period && !cs->args.nlm4_shareargs.reclaim) { + gf_msg_debug(GF_NLM, 0, "NLM in grace period"); + stat = nlm4_denied_grace_period; + nlm4_share_reply(cs, stat); + nfs3_call_state_wipe(cs); + return 0; + } - cs->vol = vol; - cs->trans = rpcsvc_request_transport_ref(req); - nlm4_volume_started_check (nfs3, vol, ret, rpcerr); + cs->vol = vol; + cs->trans = rpcsvc_request_transport_ref(req); + nlm4_volume_started_check(nfs3, vol, ret, rpcerr); - ret = nfs3_fh_resolve_and_resume (cs, &fh, NULL, - nlm4_unshare_resume); + ret = nfs3_fh_resolve_and_resume(cs, &fh, NULL, nlm4_unshare_resume); - nlm4err: - if (ret < 0) { - gf_msg (GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_UNSHARE_CALL_FAIL, - "UNSHARE call failed"); - nlm4_share_reply (cs, stat); - ret = 0; - return 0; - } +nlm4err: + if (ret < 0) { + gf_msg(GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_UNSHARE_CALL_FAIL, + "UNSHARE call failed"); + nlm4_share_reply(cs, stat); + ret = 0; + return 0; + } - rpcerr: - if (ret < 0) - nfs3_call_state_wipe (cs); +rpcerr: + if (ret < 0) + nfs3_call_state_wipe(cs); - return ret; + return ret; } int -nlm4_free_all_shares (char *caller_name) -{ - nlm_share_t *share = NULL; - nlm_share_t *tmp = NULL; - nlm_client_t *client = NULL; - - LOCK (&nlm_client_list_lk); - - client = __nlm_get_uniq (caller_name); - if (!client) { - gf_msg_debug (GF_NLM, 0, "client not found: %s", caller_name); - goto out; - } - - list_for_each_entry_safe (share, tmp, &client->shares, client_list) { - list_del (&share->inode_list); - list_del (&share->client_list); - inode_unref (share->inode); - GF_FREE (share); - } - out: - UNLOCK (&nlm_client_list_lk); - return 0; +nlm4_free_all_shares(char *caller_name) +{ + nlm_share_t *share = NULL; + nlm_share_t *tmp = NULL; + nlm_client_t *client = NULL; + + LOCK(&nlm_client_list_lk); + + client = __nlm_get_uniq(caller_name); + if (!client) { + gf_msg_debug(GF_NLM, 0, "client not found: %s", caller_name); + goto out; + } + + list_for_each_entry_safe(share, tmp, &client->shares, client_list) + { + list_del(&share->inode_list); + list_del(&share->client_list); + inode_unref(share->inode); + GF_FREE(share); + } +out: + UNLOCK(&nlm_client_list_lk); + return 0; } int -nlm4svc_free_all (rpcsvc_request_t *req) -{ - int ret = RPCSVC_ACTOR_ERROR; - nlm4_stats stat = nlm4_failed; - nfs3_state_t *nfs3 = NULL; - nfs3_call_state_t *cs = NULL; - struct nfs_state *nfs = NULL; - - nlm4_validate_nfs3_state (req, nfs3, stat, err, ret); - nfs = nfs_state (nfs3->nfsx); - nlm4_handle_call_state_init (nfs->nfs3state, cs, - req, stat, err); - - nlm4_prep_freeallargs (&cs->args.nlm4_freeallargs, - &cs->lkowner); - - if (xdr_to_nlm4_freeallargs (req->msg[0], - &cs->args.nlm4_freeallargs) <= 0) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR, - "Error decoding FREE_ALL args"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - goto err; - } +nlm4svc_free_all(rpcsvc_request_t *req) +{ + int ret = RPCSVC_ACTOR_ERROR; + nlm4_stats stat = nlm4_failed; + nfs3_state_t *nfs3 = NULL; + nfs3_call_state_t *cs = NULL; + struct nfs_state *nfs = NULL; - ret = nlm4_free_all_shares (cs->args.nlm4_freeallargs.name); - if (ret) - goto err; + nlm4_validate_nfs3_state(req, nfs3, stat, err, ret); + nfs = nfs_state(nfs3->nfsx); + nlm4_handle_call_state_init(nfs->nfs3state, cs, req, stat, err); - ret = nlm_cleanup_fds (cs->args.nlm4_freeallargs.name); - if (ret) - goto err; + nlm4_prep_freeallargs(&cs->args.nlm4_freeallargs, &cs->lkowner); - err: - nfs3_call_state_wipe (cs); - if (ret) - gf_msg_debug (GF_NLM, 0, "error in free all; stat: %d", stat); - return ret; + if (xdr_to_nlm4_freeallargs(req->msg[0], &cs->args.nlm4_freeallargs) <= 0) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR, + "Error decoding FREE_ALL args"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + goto err; + } + + ret = nlm4_free_all_shares(cs->args.nlm4_freeallargs.name); + if (ret) + goto err; + + ret = nlm_cleanup_fds(cs->args.nlm4_freeallargs.name); + if (ret) + goto err; +err: + nfs3_call_state_wipe(cs); + if (ret) + gf_msg_debug(GF_NLM, 0, "error in free all; stat: %d", stat); + return ret; } void -nlm4svc_sm_notify (struct nlm_sm_status *status) +nlm4svc_sm_notify(struct nlm_sm_status *status) { - gf_msg (GF_NLM, GF_LOG_INFO, 0, NFS_MSG_SM_NOTIFY, "sm_notify: " - "%s, state: %d", status->mon_name, status->state); - nlm_cleanup_fds (status->mon_name); + gf_msg(GF_NLM, GF_LOG_INFO, 0, NFS_MSG_SM_NOTIFY, + "sm_notify: " + "%s, state: %d", + status->mon_name, status->state); + nlm_cleanup_fds(status->mon_name); } - /* RPC_CLNT_CONNECT gets called on (re)connects and should be able to handle * different NLM requests. */ static int -nlm_handle_connect (struct rpc_clnt *rpc_clnt, struct nlm4_notify_args *ncf) -{ - int ret = -1; - int nlm_proc = NLM4_NULL; - nfs3_call_state_t *cs = NULL; - struct nlm4_lock *alock = NULL; - char *caller_name = NULL; - - cs = GF_REF_GET (ncf->cs); - if (!cs || !cs->req) { - gf_msg (GF_NLM, GF_LOG_ERROR, EINVAL, NFS_MSG_RPC_CLNT_ERROR, - "Spurious notify?!"); - goto out; - } - - /* NLM4_* actions from nlm4.h */ - if (cs->req->prognum == NLM_PROGRAM) { - nlm_proc = cs->req->procnum; - } else { - /* hmm, cs->req has not been filled completely */ - if (cs->resume_fn == nlm4_lock_fd_resume) - nlm_proc = NLM4_LOCK; - else if (cs->resume_fn == nlm4_cancel_fd_resume) - nlm_proc = NLM4_CANCEL; - else if (cs->resume_fn == nlm4_unlock_fd_resume) - nlm_proc = NLM4_UNLOCK; - else { - gf_msg (GF_NLM, GF_LOG_ERROR, 0, - NFS_MSG_RPC_CLNT_ERROR, "(re)connect with an " - "unexpected NLM4 procedure (%d)", nlm_proc); - goto out; - } +nlm_handle_connect(struct rpc_clnt *rpc_clnt, struct nlm4_notify_args *ncf) +{ + int ret = -1; + int nlm_proc = NLM4_NULL; + nfs3_call_state_t *cs = NULL; + struct nlm4_lock *alock = NULL; + char *caller_name = NULL; + + cs = GF_REF_GET(ncf->cs); + if (!cs || !cs->req) { + gf_msg(GF_NLM, GF_LOG_ERROR, EINVAL, NFS_MSG_RPC_CLNT_ERROR, + "Spurious notify?!"); + goto out; + } + + /* NLM4_* actions from nlm4.h */ + if (cs->req->prognum == NLM_PROGRAM) { + nlm_proc = cs->req->procnum; + } else { + /* hmm, cs->req has not been filled completely */ + if (cs->resume_fn == nlm4_lock_fd_resume) + nlm_proc = NLM4_LOCK; + else if (cs->resume_fn == nlm4_cancel_fd_resume) + nlm_proc = NLM4_CANCEL; + else if (cs->resume_fn == nlm4_unlock_fd_resume) + nlm_proc = NLM4_UNLOCK; + else { + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_RPC_CLNT_ERROR, + "(re)connect with an " + "unexpected NLM4 procedure (%d)", + nlm_proc); + goto out; } + } - switch (nlm_proc) { + switch (nlm_proc) { case NLM4_LOCK: - alock = &cs->args.nlm4_lockargs.alock; - caller_name = alock->caller_name; - - ret = nlm_set_rpc_clnt (rpc_clnt, caller_name); - if (ret == -1) { - gf_msg (GF_NLM, GF_LOG_ERROR, 0, - NFS_MSG_RPC_CLNT_ERROR, "Failed to set " - "rpc clnt"); - goto out; - } + alock = &cs->args.nlm4_lockargs.alock; + caller_name = alock->caller_name; + + ret = nlm_set_rpc_clnt(rpc_clnt, caller_name); + if (ret == -1) { + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_RPC_CLNT_ERROR, + "Failed to set " + "rpc clnt"); + goto out; + } - /* extra ref taken with nlm_set_rpc_clnt() */ - rpc_clnt_unref (rpc_clnt); + /* extra ref taken with nlm_set_rpc_clnt() */ + rpc_clnt_unref(rpc_clnt); - nlm4svc_send_granted (ncf); - break; + nlm4svc_send_granted(ncf); + break; case NLM4_CANCEL: - /* alock = &cs->args.nlm4_cancargs.alock; */ - ret = nlm4svc_cancel (cs->req); - break; + /* alock = &cs->args.nlm4_cancargs.alock; */ + ret = nlm4svc_cancel(cs->req); + break; case NLM4_UNLOCK: - /* alock = &cs->args.nlm4_unlockargs.alock; */ - ret = nlm4svc_unlock (cs->req); - break; + /* alock = &cs->args.nlm4_unlockargs.alock; */ + ret = nlm4svc_unlock(cs->req); + break; default: - gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_RPC_CLNT_ERROR, - "(re)connect with an unexpected NLM4 procedure " - "(%d)", nlm_proc); - } + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_RPC_CLNT_ERROR, + "(re)connect with an unexpected NLM4 procedure " + "(%d)", + nlm_proc); + } out: - if (cs) - GF_REF_PUT (cs); - - return ret; -} - - -rpcsvc_actor_t nlm4svc_actors[NLM4_PROC_COUNT] = { - /* 0 */ - {"NULL", NLM4_NULL, nlm4svc_null, NULL, 0, DRC_IDEMPOTENT}, - {"TEST", NLM4_TEST, nlm4svc_test, NULL, 0, DRC_IDEMPOTENT}, - {"LOCK", NLM4_LOCK, nlm4svc_lock, NULL, 0, DRC_NON_IDEMPOTENT}, - {"CANCEL", NLM4_CANCEL, nlm4svc_cancel, NULL, 0, DRC_NON_IDEMPOTENT}, - {"UNLOCK", NLM4_UNLOCK, nlm4svc_unlock, NULL, 0, DRC_NON_IDEMPOTENT}, - /* 5 */ - {"GRANTED", NLM4_GRANTED, NULL, NULL, 0, DRC_NA}, - {"TEST", NLM4_TEST_MSG, NULL, NULL, 0, DRC_NA}, - {"LOCK", NLM4_LOCK_MSG, NULL, NULL, 0, DRC_NA}, - {"CANCEL", NLM4_CANCEL_MSG, NULL, NULL, 0, DRC_NA}, - {"UNLOCK", NLM4_UNLOCK_MSG, NULL, NULL, 0, DRC_NA}, - /* 10 */ - {"GRANTED", NLM4_GRANTED_MSG, NULL, NULL, 0, DRC_NA}, - {"TEST", NLM4_TEST_RES, NULL, NULL, 0, DRC_NA}, - {"LOCK", NLM4_LOCK_RES, NULL, NULL, 0, DRC_NA}, - {"CANCEL", NLM4_CANCEL_RES, NULL, NULL, 0, DRC_NA}, - {"UNLOCK", NLM4_UNLOCK_RES, NULL, NULL, 0, DRC_NA}, - /* 15 ; procedures 17,18,19 are not defined by nlm */ - {"GRANTED", NLM4_GRANTED_RES, NULL, NULL, 0, DRC_NA}, - {"SM_NOTIFY", NLM4_SM_NOTIFY, NULL, NULL, 0, DRC_NA}, - {"SEVENTEEN", NLM4_SEVENTEEN, NULL, NULL, 0, DRC_NA}, - {"EIGHTEEN", NLM4_EIGHTEEN, NULL, NULL, 0, DRC_NA}, - {"NINETEEN", NLM4_NINETEEN, NULL, NULL, 0, DRC_NA}, - /* 20 */ - {"SHARE", NLM4_SHARE, nlm4svc_share, NULL, 0, DRC_NON_IDEMPOTENT}, - {"UNSHARE", NLM4_UNSHARE, nlm4svc_unshare, NULL, 0, DRC_NON_IDEMPOTENT}, - {"NM_LOCK", NLM4_NM_LOCK, nlm4svc_nm_lock, NULL, 0, DRC_NON_IDEMPOTENT}, - {"FREE_ALL", NLM4_FREE_ALL, nlm4svc_free_all, NULL, 0, DRC_IDEMPOTENT}, + if (cs) + GF_REF_PUT(cs); + + return ret; +} + +rpcsvc_actor_t nlm4svc_actors[NLM4_PROC_COUNT] = { + /* 0 */ + {"NULL", NLM4_NULL, nlm4svc_null, NULL, 0, DRC_IDEMPOTENT}, + {"TEST", NLM4_TEST, nlm4svc_test, NULL, 0, DRC_IDEMPOTENT}, + {"LOCK", NLM4_LOCK, nlm4svc_lock, NULL, 0, DRC_NON_IDEMPOTENT}, + {"CANCEL", NLM4_CANCEL, nlm4svc_cancel, NULL, 0, DRC_NON_IDEMPOTENT}, + {"UNLOCK", NLM4_UNLOCK, nlm4svc_unlock, NULL, 0, DRC_NON_IDEMPOTENT}, + /* 5 */ + {"GRANTED", NLM4_GRANTED, NULL, NULL, 0, DRC_NA}, + {"TEST", NLM4_TEST_MSG, NULL, NULL, 0, DRC_NA}, + {"LOCK", NLM4_LOCK_MSG, NULL, NULL, 0, DRC_NA}, + {"CANCEL", NLM4_CANCEL_MSG, NULL, NULL, 0, DRC_NA}, + {"UNLOCK", NLM4_UNLOCK_MSG, NULL, NULL, 0, DRC_NA}, + /* 10 */ + {"GRANTED", NLM4_GRANTED_MSG, NULL, NULL, 0, DRC_NA}, + {"TEST", NLM4_TEST_RES, NULL, NULL, 0, DRC_NA}, + {"LOCK", NLM4_LOCK_RES, NULL, NULL, 0, DRC_NA}, + {"CANCEL", NLM4_CANCEL_RES, NULL, NULL, 0, DRC_NA}, + {"UNLOCK", NLM4_UNLOCK_RES, NULL, NULL, 0, DRC_NA}, + /* 15 ; procedures 17,18,19 are not defined by nlm */ + {"GRANTED", NLM4_GRANTED_RES, NULL, NULL, 0, DRC_NA}, + {"SM_NOTIFY", NLM4_SM_NOTIFY, NULL, NULL, 0, DRC_NA}, + {"SEVENTEEN", NLM4_SEVENTEEN, NULL, NULL, 0, DRC_NA}, + {"EIGHTEEN", NLM4_EIGHTEEN, NULL, NULL, 0, DRC_NA}, + {"NINETEEN", NLM4_NINETEEN, NULL, NULL, 0, DRC_NA}, + /* 20 */ + {"SHARE", NLM4_SHARE, nlm4svc_share, NULL, 0, DRC_NON_IDEMPOTENT}, + {"UNSHARE", NLM4_UNSHARE, nlm4svc_unshare, NULL, 0, DRC_NON_IDEMPOTENT}, + {"NM_LOCK", NLM4_NM_LOCK, nlm4svc_nm_lock, NULL, 0, DRC_NON_IDEMPOTENT}, + {"FREE_ALL", NLM4_FREE_ALL, nlm4svc_free_all, NULL, 0, DRC_IDEMPOTENT}, }; -rpcsvc_program_t nlm4prog = { - .progname = "NLM4", - .prognum = NLM_PROGRAM, - .progver = NLM_V4, - .progport = GF_NLM4_PORT, - .actors = nlm4svc_actors, - .numactors = NLM4_PROC_COUNT, - .min_auth = AUTH_NULL, +rpcsvc_program_t nlm4prog = { + .progname = "NLM4", + .prognum = NLM_PROGRAM, + .progver = NLM_V4, + .progport = GF_NLM4_PORT, + .actors = nlm4svc_actors, + .numactors = NLM4_PROC_COUNT, + .min_auth = AUTH_NULL, }; - int -nlm4_init_state (xlator_t *nfsx) +nlm4_init_state(xlator_t *nfsx) { - return 0; + return 0; } -extern void *nsm_thread (void *argv); +extern void * +nsm_thread(void *argv); -void nlm_grace_period_over(void *arg) +void +nlm_grace_period_over(void *arg) { - nlm_grace_period = 0; + nlm_grace_period = 0; } rpcsvc_program_t * nlm4svc_init(xlator_t *nfsx) { - struct nfs3_state *ns = NULL; - struct nfs_state *nfs = NULL; - dict_t *options = NULL; - int ret = -1; - char *portstr = NULL; - pthread_t thr; - struct timespec timeout = {0,}; - FILE *pidfile = NULL; - pid_t pid = -1; - static gf_boolean_t nlm4_inited = _gf_false; - - /* Already inited */ - if (nlm4_inited) - return &nlm4prog; - - nfs = (struct nfs_state*)nfsx->private; - - ns = nfs->nfs3state; - if (!ns) { - gf_msg (GF_NLM, GF_LOG_ERROR, EINVAL, NFS_MSG_NLM_INIT_FAIL, - "NLM4 init failed"); - goto err; - } - nlm4prog.private = ns; - - options = dict_new (); - - ret = gf_asprintf (&portstr, "%d", GF_NLM4_PORT); - if (ret == -1) - goto err; - - ret = dict_set_dynstr (options, "transport.socket.listen-port", - portstr); - if (ret == -1) - goto err; - ret = dict_set_str (options, "transport-type", "socket"); - if (ret == -1) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, - NFS_MSG_DICT_SET_FAILED, "dict_set_str error"); - goto err; - } - - if (nfs->allow_insecure) { - ret = dict_set_str (options, "rpc-auth-allow-insecure", "on"); - if (ret == -1) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, - NFS_MSG_DICT_SET_FAILED, "dict_set_str error"); - goto err; - } - ret = dict_set_str (options, "rpc-auth.ports.insecure", "on"); - if (ret == -1) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, - NFS_MSG_DICT_SET_FAILED, "dict_set_str error"); - goto err; - } - } + struct nfs3_state *ns = NULL; + struct nfs_state *nfs = NULL; + dict_t *options = NULL; + int ret = -1; + char *portstr = NULL; + pthread_t thr; + struct timespec timeout = { + 0, + }; + FILE *pidfile = NULL; + pid_t pid = -1; + static gf_boolean_t nlm4_inited = _gf_false; + + /* Already inited */ + if (nlm4_inited) + return &nlm4prog; - ret = dict_set_str (options, "transport.address-family", "inet"); + nfs = (struct nfs_state *)nfsx->private; + + ns = nfs->nfs3state; + if (!ns) { + gf_msg(GF_NLM, GF_LOG_ERROR, EINVAL, NFS_MSG_NLM_INIT_FAIL, + "NLM4 init failed"); + goto err; + } + nlm4prog.private = ns; + + options = dict_new(); + + ret = gf_asprintf(&portstr, "%d", GF_NLM4_PORT); + if (ret == -1) + goto err; + + ret = dict_set_dynstr(options, "transport.socket.listen-port", portstr); + if (ret == -1) + goto err; + ret = dict_set_str(options, "transport-type", "socket"); + if (ret == -1) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); + goto err; + } + + if (nfs->allow_insecure) { + ret = dict_set_str(options, "rpc-auth-allow-insecure", "on"); if (ret == -1) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, - "dict_set_str error"); - goto err; + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); + goto err; } - - ret = rpcsvc_create_listeners (nfs->rpcsvc, options, "NLM"); + ret = dict_set_str(options, "rpc-auth.ports.insecure", "on"); if (ret == -1) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, - NFS_MSG_LISTENERS_CREATE_FAIL, - "Unable to create listeners"); - dict_unref (options); - goto err; - } - INIT_LIST_HEAD(&nlm_client_list); - LOCK_INIT (&nlm_client_list_lk); - - /* unlink sm-notify.pid so that when we restart rpc.statd/sm-notify - * it thinks that the machine has restarted and sends NOTIFY to clients. - */ - - /* TODO: - notify/rpc.statd is done differently on OSX - - On OSX rpc.statd is controlled by rpc.lockd and are part for launchd - (unified service management framework) - - A runcmd() should be invoking "launchctl start com.apple.lockd" - instead. This is still a theory but we need to thoroughly test it - out. Until then NLM support is non-existent on OSX. - */ - ret = sys_unlink (GF_SM_NOTIFY_PIDFILE); - if (ret == -1 && errno != ENOENT) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_UNLINK_ERROR, - "unable to unlink %s: %d", - GF_SM_NOTIFY_PIDFILE, errno); - goto err; - } - /* temporary work around to restart statd, not distro/OS independent. - * Need to figure out a more graceful way - * killall will cause problems on solaris. + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); + goto err; + } + } + + ret = dict_set_str(options, "transport.address-family", "inet"); + if (ret == -1) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); + goto err; + } + + ret = rpcsvc_create_listeners(nfs->rpcsvc, options, "NLM"); + if (ret == -1) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_LISTENERS_CREATE_FAIL, + "Unable to create listeners"); + dict_unref(options); + goto err; + } + INIT_LIST_HEAD(&nlm_client_list); + LOCK_INIT(&nlm_client_list_lk); + + /* unlink sm-notify.pid so that when we restart rpc.statd/sm-notify + * it thinks that the machine has restarted and sends NOTIFY to clients. + */ + + /* TODO: + notify/rpc.statd is done differently on OSX + + On OSX rpc.statd is controlled by rpc.lockd and are part for launchd + (unified service management framework) + + A runcmd() should be invoking "launchctl start com.apple.lockd" + instead. This is still a theory but we need to thoroughly test it + out. Until then NLM support is non-existent on OSX. + */ + ret = sys_unlink(GF_SM_NOTIFY_PIDFILE); + if (ret == -1 && errno != ENOENT) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_UNLINK_ERROR, + "unable to unlink %s: %d", GF_SM_NOTIFY_PIDFILE, errno); + goto err; + } + /* temporary work around to restart statd, not distro/OS independent. + * Need to figure out a more graceful way + * killall will cause problems on solaris. + */ + + char *pid_file = GF_RPC_STATD_PIDFILE; + if (nfs->rpc_statd_pid_file) + pid_file = nfs->rpc_statd_pid_file; + pidfile = fopen(pid_file, "r"); + if (pidfile) { + ret = fscanf(pidfile, "%d", &pid); + if (ret <= 0) { + gf_msg(GF_NLM, GF_LOG_WARNING, errno, NFS_MSG_GET_PID_FAIL, + "unable to get pid of " + "rpc.statd from %s ", + GF_RPC_STATD_PIDFILE); + ret = runcmd(KILLALL_CMD, "-9", "rpc.statd", NULL); + } else + kill(pid, SIGKILL); + + fclose(pidfile); + } else { + gf_msg(GF_NLM, GF_LOG_WARNING, errno, NFS_MSG_OPEN_FAIL, + "opening %s of rpc.statd failed (%s)", pid_file, + strerror(errno)); + /* if ret == -1, do nothing - case either statd was not + * running or was running in valgrind mode */ - - char *pid_file = GF_RPC_STATD_PIDFILE; - if (nfs->rpc_statd_pid_file) - pid_file = nfs->rpc_statd_pid_file; - pidfile = fopen (pid_file, "r"); - if (pidfile) { - ret = fscanf (pidfile, "%d", &pid); - if (ret <= 0) { - gf_msg (GF_NLM, GF_LOG_WARNING, errno, - NFS_MSG_GET_PID_FAIL, "unable to get pid of " - "rpc.statd from %s ", GF_RPC_STATD_PIDFILE); - ret = runcmd (KILLALL_CMD, "-9", "rpc.statd", NULL); - } else - kill (pid, SIGKILL); - - fclose (pidfile); - } else { - gf_msg (GF_NLM, GF_LOG_WARNING, errno, NFS_MSG_OPEN_FAIL, - "opening %s of rpc.statd failed (%s)", - pid_file, strerror (errno)); - /* if ret == -1, do nothing - case either statd was not - * running or was running in valgrind mode - */ - ret = runcmd (KILLALL_CMD, "-9", "rpc.statd", NULL); - } - - ret = sys_unlink (GF_RPC_STATD_PIDFILE); - if (ret == -1 && errno != ENOENT) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_UNLINK_ERROR, - "unable to unlink %s", pid_file); - goto err; - } - - ret = runcmd (nfs->rpc_statd, NULL); - if (ret == -1) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_START_ERROR, - "unable to start %s", nfs->rpc_statd); - goto err; - } - - - gf_thread_create (&thr, NULL, nsm_thread, (void *)NULL, "nfsnsm"); - - timeout.tv_sec = nlm_grace_period; - timeout.tv_nsec = 0; - - gf_timer_call_after (nfsx->ctx, timeout, nlm_grace_period_over, NULL); - nlm4_inited = _gf_true; - return &nlm4prog; + ret = runcmd(KILLALL_CMD, "-9", "rpc.statd", NULL); + } + + ret = sys_unlink(GF_RPC_STATD_PIDFILE); + if (ret == -1 && errno != ENOENT) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_UNLINK_ERROR, + "unable to unlink %s", pid_file); + goto err; + } + + ret = runcmd(nfs->rpc_statd, NULL); + if (ret == -1) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_START_ERROR, + "unable to start %s", nfs->rpc_statd); + goto err; + } + + gf_thread_create(&thr, NULL, nsm_thread, (void *)NULL, "nfsnsm"); + + timeout.tv_sec = nlm_grace_period; + timeout.tv_nsec = 0; + + gf_timer_call_after(nfsx->ctx, timeout, nlm_grace_period_over, NULL); + nlm4_inited = _gf_true; + return &nlm4prog; err: - return NULL; + return NULL; } int32_t -nlm_priv (xlator_t *this) +nlm_priv(xlator_t *this) { - int32_t ret = -1; - uint32_t client_count = 0; - uint64_t file_count = 0; - nlm_client_t *client = NULL; - nlm_fde_t *fde = NULL; - char key[GF_DUMP_MAX_BUF_LEN] = {0}; - char gfid_str[64] = {0}; - - gf_proc_dump_add_section("nfs.nlm"); - - if (TRY_LOCK (&nlm_client_list_lk)) - goto out; + int32_t ret = -1; + uint32_t client_count = 0; + uint64_t file_count = 0; + nlm_client_t *client = NULL; + nlm_fde_t *fde = NULL; + char key[GF_DUMP_MAX_BUF_LEN] = {0}; + char gfid_str[64] = {0}; - list_for_each_entry (client, &nlm_client_list, nlm_clients) { + gf_proc_dump_add_section("nfs.nlm"); - gf_proc_dump_build_key (key, "client", "%d.hostname", client_count); - gf_proc_dump_write (key, "%s\n", client->caller_name); + if (TRY_LOCK(&nlm_client_list_lk)) + goto out; - file_count = 0; - list_for_each_entry (fde, &client->fdes, fde_list) { - gf_proc_dump_build_key (key, "file", "%ld.gfid", file_count); - memset (gfid_str, 0, 64); - uuid_utoa_r (fde->fd->inode->gfid, gfid_str); - gf_proc_dump_write (key, "%s", gfid_str); - file_count++; - } + list_for_each_entry(client, &nlm_client_list, nlm_clients) + { + gf_proc_dump_build_key(key, "client", "%d.hostname", client_count); + gf_proc_dump_write(key, "%s\n", client->caller_name); - gf_proc_dump_build_key (key, "client", "files-locked"); - gf_proc_dump_write (key, "%ld\n", file_count); - client_count++; + file_count = 0; + list_for_each_entry(fde, &client->fdes, fde_list) + { + gf_proc_dump_build_key(key, "file", "%ld.gfid", file_count); + memset(gfid_str, 0, 64); + uuid_utoa_r(fde->fd->inode->gfid, gfid_str); + gf_proc_dump_write(key, "%s", gfid_str); + file_count++; } - gf_proc_dump_build_key (key, "nlm", "client-count"); - gf_proc_dump_write (key, "%d", client_count); - ret = 0; - UNLOCK (&nlm_client_list_lk); + gf_proc_dump_build_key(key, "client", "files-locked"); + gf_proc_dump_write(key, "%ld\n", file_count); + client_count++; + } - out: - if (ret) { - gf_proc_dump_build_key (key, "nlm", "statedump_error"); - gf_proc_dump_write (key, "Unable to dump nlm state because " - "nlm_client_list_lk lock couldn't be acquired"); - } + gf_proc_dump_build_key(key, "nlm", "client-count"); + gf_proc_dump_write(key, "%d", client_count); + ret = 0; + UNLOCK(&nlm_client_list_lk); - return ret; +out: + if (ret) { + gf_proc_dump_build_key(key, "nlm", "statedump_error"); + gf_proc_dump_write(key, + "Unable to dump nlm state because " + "nlm_client_list_lk lock couldn't be acquired"); + } + + return ret; } diff --git a/xlators/nfs/server/src/nlmcbk_svc.c b/xlators/nfs/server/src/nlmcbk_svc.c index badbd088f3..1d57f415e2 100644 --- a/xlators/nfs/server/src/nlmcbk_svc.c +++ b/xlators/nfs/server/src/nlmcbk_svc.c @@ -25,102 +25,105 @@ #include <netinet/in.h> #ifndef SIG_PF -#define SIG_PF void(*)(int) +#define SIG_PF void (*)(int) #endif void -nlm4svc_sm_notify (struct nlm_sm_status *status); +nlm4svc_sm_notify(struct nlm_sm_status *status); -void *nlmcbk_sm_notify_0_svc(struct nlm_sm_status *status, struct svc_req *req) +void * +nlmcbk_sm_notify_0_svc(struct nlm_sm_status *status, struct svc_req *req) { - nlm4svc_sm_notify (status); - return NULL; + nlm4svc_sm_notify(status); + return NULL; } static void nlmcbk_program_0(struct svc_req *rqstp, register SVCXPRT *transp) { - union { - struct nlm_sm_status nlmcbk_sm_notify_0_arg; - } argument; - char *result; - xdrproc_t _xdr_argument, _xdr_result; - char *(*local)(char *, struct svc_req *); + union { + struct nlm_sm_status nlmcbk_sm_notify_0_arg; + } argument; + char *result; + xdrproc_t _xdr_argument, _xdr_result; + char *(*local)(char *, struct svc_req *); - switch (rqstp->rq_proc) { - case NULLPROC: - (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL); - return; + switch (rqstp->rq_proc) { + case NULLPROC: + (void)svc_sendreply(transp, (xdrproc_t)xdr_void, (char *)NULL); + return; - case NLMCBK_SM_NOTIFY: - _xdr_argument = (xdrproc_t) xdr_nlm_sm_status; - _xdr_result = (xdrproc_t) xdr_void; - local = (char *(*)(char *, struct svc_req *)) nlmcbk_sm_notify_0_svc; - break; + case NLMCBK_SM_NOTIFY: + _xdr_argument = (xdrproc_t)xdr_nlm_sm_status; + _xdr_result = (xdrproc_t)xdr_void; + local = (char *(*)(char *, struct svc_req *))nlmcbk_sm_notify_0_svc; + break; - default: - svcerr_noproc (transp); - return; - } - memset ((char *)&argument, 0, sizeof (argument)); - if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) { - svcerr_decode (transp); - return; - } - result = (*local)((char *)&argument, rqstp); - if (!svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) { - svcerr_systemerr (transp); - } + default: + svcerr_noproc(transp); + return; + } + memset((char *)&argument, 0, sizeof(argument)); + if (!svc_getargs(transp, (xdrproc_t)_xdr_argument, (caddr_t)&argument)) { + svcerr_decode(transp); + return; + } + result = (*local)((char *)&argument, rqstp); + if (!svc_sendreply(transp, (xdrproc_t)_xdr_result, result)) { + svcerr_systemerr(transp); + } - if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) { - gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_ARG_FREE_FAIL, - "unable to free arguments"); - return; - } - return; + if (!svc_freeargs(transp, (xdrproc_t)_xdr_argument, (caddr_t)&argument)) { + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_ARG_FREE_FAIL, + "unable to free arguments"); + return; + } + return; } void * -nsm_thread (void *argv) +nsm_thread(void *argv) { - register SVCXPRT *transp; - int ret = 0; + register SVCXPRT *transp; + int ret = 0; - ret = pmap_unset (NLMCBK_PROGRAM, NLMCBK_V1); - if (ret == 0) { - gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_PMAP_UNSET_FAIL, - "pmap_unset failed"); - return NULL; - } - transp = svcudp_create(RPC_ANYSOCK); - if (transp == NULL) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_UDP_SERV_FAIL, - "cannot create udp service."); - return NULL; - } - if (!svc_register(transp, NLMCBK_PROGRAM, NLMCBK_V1, nlmcbk_program_0, IPPROTO_UDP)) { - gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_REG_NLMCBK_FAIL, - "unable to register (NLMCBK_PROGRAM, " - "NLMCBK_V0, udp)."); - return NULL; - } - - transp = svctcp_create(RPC_ANYSOCK, 0, 0); - if (transp == NULL) { - gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_TCP_SERV_FAIL, - "cannot create tcp service."); - return NULL; - } - if (!svc_register(transp, NLMCBK_PROGRAM, NLMCBK_V1, nlmcbk_program_0, IPPROTO_TCP)) { - gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_REG_NLMCBK_FAIL, - "unable to register (NLMCBK_PROGRAM, " - "NLMCBK_V0, tcp)."); - return NULL; - } + ret = pmap_unset(NLMCBK_PROGRAM, NLMCBK_V1); + if (ret == 0) { + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_PMAP_UNSET_FAIL, + "pmap_unset failed"); + return NULL; + } + transp = svcudp_create(RPC_ANYSOCK); + if (transp == NULL) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_UDP_SERV_FAIL, + "cannot create udp service."); + return NULL; + } + if (!svc_register(transp, NLMCBK_PROGRAM, NLMCBK_V1, nlmcbk_program_0, + IPPROTO_UDP)) { + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_REG_NLMCBK_FAIL, + "unable to register (NLMCBK_PROGRAM, " + "NLMCBK_V0, udp)."); + return NULL; + } - svc_run (); - gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_SVC_RUN_RETURNED, - "svc_run returned"); + transp = svctcp_create(RPC_ANYSOCK, 0, 0); + if (transp == NULL) { + gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_TCP_SERV_FAIL, + "cannot create tcp service."); return NULL; - /* NOTREACHED */ + } + if (!svc_register(transp, NLMCBK_PROGRAM, NLMCBK_V1, nlmcbk_program_0, + IPPROTO_TCP)) { + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_REG_NLMCBK_FAIL, + "unable to register (NLMCBK_PROGRAM, " + "NLMCBK_V0, tcp)."); + return NULL; + } + + svc_run(); + gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_SVC_RUN_RETURNED, + "svc_run returned"); + return NULL; + /* NOTREACHED */ } |