int nlm4_Sm_Notify(nfs_arg_t *args, struct svc_req *req, nfs_res_t *res)
{
nlm4_sm_notifyargs *arg = &args->arg_nlm4_sm_notify;
state_status_t state_status = STATE_SUCCESS;
state_nsm_client_t *nsm_client;
LogDebug(COMPONENT_NLM,
"REQUEST PROCESSING: Calling nlm4_sm_notify for %s",
arg->name);
nsm_client = get_nsm_client(CARE_NOT, NULL, arg->name);
if (nsm_client != NULL) {
/* Cast the state number into a state pointer to protect
* locks from a client that has rebooted from being released
* by this SM_NOTIFY.
*/
state_status = state_nlm_notify(nsm_client, true, arg->state);
if (state_status != STATE_SUCCESS) {
/** @todo FSF: Deal with error
*/
}
dec_nsm_client_ref(nsm_client);
}
LogDebug(COMPONENT_NLM, "REQUEST RESULT: nlm4_sm_notify DONE");
return NFS_REQ_OK;
}
/**
* @brief Unlock Message
*
* @param[in] args
* @param[in] req
* @param[out] res
*
*/
int nlm4_Unlock_Message(nfs_arg_t *args, struct svc_req *req, nfs_res_t *res)
{
state_nlm_client_t *nlm_client = NULL;
state_nsm_client_t *nsm_client;
nlm4_unlockargs *arg = &args->arg_nlm4_unlock;
int rc = NFS_REQ_OK;
LogDebug(COMPONENT_NLM,
"REQUEST PROCESSING: Calling nlm_Unlock_Message");
nsm_client = get_nsm_client(CARE_NO_MONITOR,
req->rq_xprt,
arg->alock.caller_name);
if (nsm_client != NULL)
nlm_client = get_nlm_client(CARE_NO_MONITOR,
req->rq_xprt, nsm_client,
arg->alock.caller_name);
if (nlm_client == NULL)
rc = NFS_REQ_DROP;
else
rc = nlm4_Unlock(args, req, res);
if (rc == NFS_REQ_OK)
rc = nlm_send_async_res_nlm4(nlm_client,
nlm4_unlock_message_resp,
res);
if (rc == NFS_REQ_DROP) {
if (nsm_client != NULL)
dec_nsm_client_ref(nsm_client);
if (nlm_client != NULL)
dec_nlm_client_ref(nlm_client);
LogCrit(COMPONENT_NLM,
"Could not send async response for nlm_Unlock_Message");
}
return NFS_REQ_DROP;
}
/**
* nlm4_Lock_Message: Lock Message
*
* @param parg [IN]
* @param pexportlist [IN]
* @param pcontextp [IN]
* @param pclient [INOUT]
* @param ht [INOUT]
* @param preq [IN]
* @param pres [OUT]
*
*/
int nlm4_Lock_Message(nfs_arg_t * parg /* IN */ ,
exportlist_t * pexport /* IN */ ,
fsal_op_context_t * pcontext /* IN */ ,
cache_inode_client_t * pclient /* INOUT */ ,
hash_table_t * ht /* INOUT */ ,
struct svc_req *preq /* IN */ ,
nfs_res_t * pres /* OUT */ )
{
state_nlm_client_t * nlm_client = NULL;
state_nsm_client_t * nsm_client;
nlm4_lockargs * arg = &parg->arg_nlm4_lock;
int rc = NFS_REQ_OK;
LogDebug(COMPONENT_NLM, "REQUEST PROCESSING: Calling nlm_Lock_Message");
nsm_client = get_nsm_client(CARE_NO_MONITOR, preq->rq_xprt, arg->alock.caller_name);
if(nsm_client != NULL)
nlm_client = get_nlm_client(CARE_NO_MONITOR, preq->rq_xprt, nsm_client, arg->alock.caller_name);
if(nlm_client == NULL)
rc = NFS_REQ_DROP;
else
rc = nlm4_Lock(parg, pexport, pcontext, pclient, ht, preq, pres);
if(rc == NFS_REQ_OK)
rc = nlm_send_async_res_nlm4(nlm_client, nlm4_lock_message_resp, pres);
if(rc == NFS_REQ_DROP)
{
if(nsm_client != NULL)
dec_nsm_client_ref(nsm_client);
if(nlm_client != NULL)
dec_nlm_client_ref(nlm_client);
LogCrit(COMPONENT_NLM,
"Could not send async response for nlm_Lock_Message");
}
return NFS_REQ_DROP;
}
int nlm4_Sm_Notify(nfs_arg_t * parg /* IN */ ,
exportlist_t * pexport /* IN */ ,
fsal_op_context_t * pcontext /* IN */ ,
cache_inode_client_t * pclient /* INOUT */ ,
hash_table_t * ht /* INOUT */ ,
struct svc_req *preq /* IN */ ,
nfs_res_t * pres /* OUT */ )
{
nlm4_sm_notifyargs * arg = &parg->arg_nlm4_sm_notify;
state_status_t state_status = CACHE_INODE_SUCCESS;
state_nsm_client_t * nsm_client;
LogDebug(COMPONENT_NLM,
"REQUEST PROCESSING: Calling nlm4_sm_notify for %s",
arg->name);
nsm_client = get_nsm_client(TRUE, NULL, arg->name);
if(nsm_client != NULL)
{
/* Cast the state number into a state pointer to protect
* locks from a client that has rebooted from being released
* by this SM_NOTIFY.
*/
if(state_nlm_notify(nsm_client,
(void *) (ptrdiff_t) arg->state,
pclient,
&state_status) != STATE_SUCCESS)
{
/* TODO FSF: Deal with error */
}
}
dec_nsm_client_ref(nsm_client);
LogDebug(COMPONENT_NLM,
"REQUEST RESULT: nlm4_sm_notify DONE");
return NFS_REQ_OK;
}
int nlm4_Sm_Notify(nfs_arg_t *parg,
exportlist_t *pexport,
fsal_op_context_t *pcontext,
nfs_worker_data_t *pworker,
struct svc_req *preq,
nfs_res_t *pres)
{
nlm4_sm_notifyargs * arg = &parg->arg_nlm4_sm_notify;
state_status_t state_status = STATE_SUCCESS;
state_nsm_client_t * nsm_client;
LogDebug(COMPONENT_NLM,
"REQUEST PROCESSING: Calling nlm4_sm_notify for %s",
arg->name);
nsm_client = get_nsm_client(CARE_NOT, NULL, arg->name);
if(nsm_client != NULL)
{
/* Cast the state number into a state pointer to protect
* locks from a client that has rebooted from being released
* by this SM_NOTIFY.
*/
if(state_nlm_notify(nsm_client,
(void *) (ptrdiff_t) arg->state,
&state_status) != STATE_SUCCESS)
{
/* TODO FSF: Deal with error */
}
dec_nsm_client_ref(nsm_client);
}
LogDebug(COMPONENT_NLM,
"REQUEST RESULT: nlm4_sm_notify DONE");
return NFS_REQ_OK;
}
int nlm_process_share_parms(struct svc_req * preq,
nlm4_share * share,
cache_entry_t ** ppentry,
fsal_op_context_t * pcontext,
care_t care,
state_nsm_client_t ** ppnsm_client,
state_nlm_client_t ** ppnlm_client,
state_owner_t ** ppowner)
{
cache_inode_fsal_data_t fsal_data;
fsal_attrib_list_t attr;
cache_inode_status_t cache_status;
SVCXPRT *ptr_svc = preq->rq_xprt;
int rc;
*ppnsm_client = NULL;
*ppnlm_client = NULL;
*ppowner = NULL;
/* Convert file handle into a cache entry */
if(share->fh.n_len > MAX_NETOBJ_SZ ||
!nfs3_FhandleToFSAL((nfs_fh3 *) &share->fh, &fsal_data.fh_desc, pcontext))
{
/* handle is not valid */
return NLM4_STALE_FH;
}
/* Now get the cached inode attributes */
*ppentry = cache_inode_get(&fsal_data,
&attr,
pcontext,
NULL,
&cache_status);
if(*ppentry == NULL)
{
/* handle is not valid */
return NLM4_STALE_FH;
}
*ppnsm_client = get_nsm_client(care, ptr_svc, share->caller_name);
if(*ppnsm_client == NULL)
{
/* If NSM Client is not found, and we don't care (for unshare),
* just return GRANTED (the unshare must succeed, there can't be
* any shares).
*/
if(care != CARE_NOT)
rc = NLM4_DENIED_NOLOCKS;
else
rc = NLM4_GRANTED;
goto out_put;
}
*ppnlm_client = get_nlm_client(care, ptr_svc, *ppnsm_client, share->caller_name);
if(*ppnlm_client == NULL)
{
/* If NLM Client is not found, and we don't care (such as unlock),
* just return GRANTED (the unlock must succeed, there can't be
* any locks).
*/
dec_nsm_client_ref(*ppnsm_client);
if(care != CARE_NOT)
rc = NLM4_DENIED_NOLOCKS;
else
rc = NLM4_GRANTED;
goto out_put;
}
*ppowner = get_nlm_owner(care, *ppnlm_client, &share->oh, 0);
if(*ppowner == NULL)
{
LogDebug(COMPONENT_NLM,
"Could not get NLM Owner");
dec_nsm_client_ref(*ppnsm_client);
dec_nlm_client_ref(*ppnlm_client);
*ppnlm_client = NULL;
/* If owner is not found, and we don't care (such as unlock),
* just return GRANTED (the unlock must succeed, there can't be
* any locks).
*/
if(care != CARE_NOT)
rc = NLM4_DENIED_NOLOCKS;
else
rc = NLM4_GRANTED;
goto out_put;
}
LogFullDebug(COMPONENT_NLM,
"Parameters Processed");
return -1;
out_put:
cache_inode_put(*ppentry);
*ppentry = NULL;
return rc;
}
int nlm_process_parameters(struct svc_req * preq,
bool_t exclusive,
nlm4_lock * alock,
fsal_lock_param_t * plock,
cache_entry_t ** ppentry,
fsal_op_context_t * pcontext,
care_t care,
state_nsm_client_t ** ppnsm_client,
state_nlm_client_t ** ppnlm_client,
state_owner_t ** ppowner,
state_block_data_t ** ppblock_data)
{
cache_inode_fsal_data_t fsal_data;
fsal_attrib_list_t attr;
cache_inode_status_t cache_status;
SVCXPRT *ptr_svc = preq->rq_xprt;
int rc;
*ppnsm_client = NULL;
*ppnlm_client = NULL;
*ppowner = NULL;
/* Convert file handle into a cache entry */
if(alock->fh.n_len > MAX_NETOBJ_SZ ||
!nfs3_FhandleToFSAL((nfs_fh3 *) &alock->fh, &fsal_data.fh_desc, pcontext))
{
/* handle is not valid */
return NLM4_STALE_FH;
}
/* Now get the cached inode attributes */
*ppentry = cache_inode_get(&fsal_data,
&attr,
pcontext,
NULL,
&cache_status);
if(*ppentry == NULL)
{
/* handle is not valid */
return NLM4_STALE_FH;
}
*ppnsm_client = get_nsm_client(care, ptr_svc, alock->caller_name);
if(*ppnsm_client == NULL)
{
/* If NSM Client is not found, and we don't care (such as unlock),
* just return GRANTED (the unlock must succeed, there can't be
* any locks).
*/
if(care != CARE_NOT)
rc = NLM4_DENIED_NOLOCKS;
else
rc = NLM4_GRANTED;
goto out_put;
}
*ppnlm_client = get_nlm_client(care, ptr_svc, *ppnsm_client, alock->caller_name);
if(*ppnlm_client == NULL)
{
/* If NLM Client is not found, and we don't care (such as unlock),
* just return GRANTED (the unlock must succeed, there can't be
* any locks).
*/
dec_nsm_client_ref(*ppnsm_client);
if(care != CARE_NOT)
rc = NLM4_DENIED_NOLOCKS;
else
rc = NLM4_GRANTED;
goto out_put;
}
*ppowner = get_nlm_owner(care, *ppnlm_client, &alock->oh, alock->svid);
if(*ppowner == NULL)
{
LogDebug(COMPONENT_NLM,
"Could not get NLM Owner");
dec_nsm_client_ref(*ppnsm_client);
dec_nlm_client_ref(*ppnlm_client);
*ppnlm_client = NULL;
/* If owner is not found, and we don't care (such as unlock),
* just return GRANTED (the unlock must succeed, there can't be
* any locks).
*/
if(care != CARE_NOT)
rc = NLM4_DENIED_NOLOCKS;
else
rc = NLM4_GRANTED;
goto out_put;
}
if(ppblock_data != NULL)
{
*ppblock_data = gsh_calloc(1, sizeof(**ppblock_data));
/* Fill in the block data, if we don't get one, we will just proceed
* without (which will mean the lock doesn't block.
*/
if(*ppblock_data != NULL)
{
if(copy_xprt_addr(&(*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_nlm_hostaddr, ptr_svc) == 0)
{
LogFullDebug(COMPONENT_NLM,
"copy_xprt_addr failed for Program %d, Version %d, Function %d",
(int)preq->rq_prog, (int)preq->rq_vers, (int)preq->rq_proc);
gsh_free(*ppblock_data);
*ppblock_data = NULL;
rc = NLM4_FAILED;
goto out_put;
}
(*ppblock_data)->sbd_granted_callback = nlm_granted_callback;
(*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_nlm_fh.n_bytes =
(*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_nlm_fh_buf;
(*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_nlm_fh.n_len = alock->fh.n_len;
memcpy((*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_nlm_fh_buf,
alock->fh.n_bytes,
alock->fh.n_len);
/* FSF TODO: Ultimately I think the following will go away, we won't need the context, just the export */
/* Copy credentials from pcontext */
#ifdef _USE_HPSS
/** @todo : PhD: Think about removing hpsscred_t from FSAL */
(*ppblock_data)->sbd_credential.user = pcontext->credential.hpss_usercred.Uid ;
(*ppblock_data)->sbd_credential.group = pcontext->credential.hpss_usercred.Gid ;
#else
(*ppblock_data)->sbd_credential = pcontext->credential;
/* Copy the alt groups list */
if(pcontext->credential.nbgroups != 0)
{
(*ppblock_data)->sbd_credential.alt_groups =
gsh_malloc(sizeof(gid_t) * pcontext->credential.nbgroups);
if((*ppblock_data)->sbd_credential.alt_groups == NULL)
{
gsh_free(*ppblock_data);
*ppblock_data = NULL;
rc = NLM4_FAILED;
goto out_put;
}
memcpy((*ppblock_data)->sbd_credential.alt_groups,
pcontext->credential.alt_groups,
pcontext->credential.nbgroups);
}
#endif
}
}
/* Fill in plock */
plock->lock_type = exclusive ? FSAL_LOCK_W : FSAL_LOCK_R;
plock->lock_start = alock->l_offset;
plock->lock_length = alock->l_len;
LogFullDebug(COMPONENT_NLM,
"Parameters Processed");
return -1;
out_put:
cache_inode_put(*ppentry);
*ppentry = NULL;
return rc;
}
int nlm_process_parameters(struct svc_req * preq,
bool_t exclusive,
nlm4_lock * alock,
state_lock_desc_t * plock,
hash_table_t * ht,
cache_entry_t ** ppentry,
fsal_op_context_t * pcontext,
cache_inode_client_t * pclient,
care_t care,
state_nsm_client_t ** ppnsm_client,
state_nlm_client_t ** ppnlm_client,
state_owner_t ** ppowner,
state_block_data_t ** ppblock_data)
{
cache_inode_fsal_data_t fsal_data;
fsal_attrib_list_t attr;
cache_inode_status_t cache_status;
SVCXPRT *ptr_svc = preq->rq_xprt;
*ppnsm_client = NULL;
*ppnlm_client = NULL;
*ppowner = NULL;
/* Convert file handle into a cache entry */
if(alock->fh.n_len > MAX_NETOBJ_SZ ||
!nfs3_FhandleToFSAL((nfs_fh3 *) &alock->fh, &fsal_data.handle, pcontext))
{
/* handle is not valid */
return NLM4_STALE_FH;
}
/* Now get the cached inode attributes */
fsal_data.cookie = DIR_START;
*ppentry = cache_inode_get(&fsal_data,
CACHE_INODE_JOKER_POLICY,
&attr,
ht,
pclient,
pcontext,
&cache_status);
if(*ppentry == NULL)
{
/* handle is not valid */
return NLM4_STALE_FH;
}
*ppnsm_client = get_nsm_client(care, ptr_svc, alock->caller_name);
if(*ppnsm_client == NULL)
{
/* If NSM Client is not found, and we don't care (such as unlock),
* just return GRANTED (the unlock must succeed, there can't be
* any locks).
*/
if(care != CARE_NOT)
return NLM4_DENIED_NOLOCKS;
else
return NLM4_GRANTED;
}
*ppnlm_client = get_nlm_client(care, ptr_svc, *ppnsm_client, alock->caller_name);
if(*ppnlm_client == NULL)
{
/* If NLM Client is not found, and we don't care (such as unlock),
* just return GRANTED (the unlock must succeed, there can't be
* any locks).
*/
dec_nsm_client_ref(*ppnsm_client);
if(care != CARE_NOT)
return NLM4_DENIED_NOLOCKS;
else
return NLM4_GRANTED;
}
*ppowner = get_nlm_owner(care, *ppnlm_client, &alock->oh, alock->svid);
if(*ppowner == NULL)
{
LogDebug(COMPONENT_NLM,
"Could not get NLM Owner");
dec_nsm_client_ref(*ppnsm_client);
dec_nlm_client_ref(*ppnlm_client);
*ppnlm_client = NULL;
/* If owner is not found, and we don't care (such as unlock),
* just return GRANTED (the unlock must succeed, there can't be
* any locks).
*/
if(care)
return NLM4_DENIED_NOLOCKS;
else
return NLM4_GRANTED;
}
if(ppblock_data != NULL)
{
*ppblock_data = (state_block_data_t *) Mem_Alloc_Label(sizeof(**ppblock_data),
"NLM_Block_Data");
/* Fill in the block data, if we don't get one, we will just proceed
* without (which will mean the lock doesn't block.
*/
if(*ppblock_data != NULL)
{
memset(*ppblock_data, 0, sizeof(**ppblock_data));
if(copy_xprt_addr(&(*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_nlm_hostaddr, ptr_svc) == 0)
{
LogFullDebug(COMPONENT_NLM,
"copy_xprt_addr failed for Program %d, Version %d, Function %d",
(int)preq->rq_prog, (int)preq->rq_vers, (int)preq->rq_proc);
Mem_Free(*ppblock_data);
*ppblock_data = NULL;
return NLM4_FAILED;
}
(*ppblock_data)->sbd_granted_callback = nlm_granted_callback;
(*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_nlm_fh.n_bytes =
(*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_nlm_fh_buf;
(*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_nlm_fh.n_len = alock->fh.n_len;
memcpy((*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_nlm_fh_buf,
alock->fh.n_bytes,
alock->fh.n_len);
/* FSF TODO: Ultimately I think the following will go away, we won't need the context, just the export */
/* Copy credentials from pcontext */
(*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_credential = pcontext->credential;
}
}
/* Fill in plock */
plock->sld_type = exclusive ? STATE_LOCK_W : STATE_LOCK_R;
plock->sld_offset = alock->l_offset;
plock->sld_length = alock->l_len;
LogFullDebug(COMPONENT_NLM,
"Parameters Processed");
return -1;
}
* @param[out] res
*/
int nlm4_Sm_Notify(nfs_arg_t *args, exportlist_t *export,
struct req_op_context *req_ctx, nfs_worker_data_t *worker,
struct svc_req *req, nfs_res_t *res)
{
nlm4_sm_notifyargs *arg = &args->arg_nlm4_sm_notify;
state_status_t state_status = STATE_SUCCESS;
state_nsm_client_t *nsm_client;
LogDebug(COMPONENT_NLM,
"REQUEST PROCESSING: Calling nlm4_sm_notify for %s",
arg->name);
nsm_client = get_nsm_client(CARE_NOT, NULL, arg->name);
if (nsm_client != NULL) {
/* Cast the state number into a state pointer to protect
* locks from a client that has rebooted from being released
* by this SM_NOTIFY.
*/
state_status = state_nlm_notify(nsm_client,
req_ctx,
(void *)(ptrdiff_t) arg->state);
if (state_status != STATE_SUCCESS) {
/** @todo FSF: Deal with error
*/
}