int init_server_pkgs(void)
{
cache_inode_status_t cache_status;
state_status_t state_status;
/* init uid2grp cache */
uid2grp_cache_init();
/* Cache Inode Initialisation */
cache_status = cache_inode_init();
if (cache_status != CACHE_INODE_SUCCESS) {
LogCrit(COMPONENT_INIT,
"Cache Inode Layer could not be initialized, status=%s",
cache_inode_err_str(cache_status));
return -1;
}
state_status = state_lock_init();
if (state_status != STATE_SUCCESS) {
LogCrit(COMPONENT_INIT,
"State Lock Layer could not be initialized, status=%s",
state_err_str(state_status));
return -1;
}
LogInfo(COMPONENT_INIT, "Cache Inode library successfully initialized");
/* Init the IP/name cache */
LogDebug(COMPONENT_INIT, "Now building IP/name cache");
if (nfs_Init_ip_name() != IP_NAME_SUCCESS) {
LogCrit(COMPONENT_INIT,
"Error while initializing IP/name cache");
return -1;
}
LogInfo(COMPONENT_INIT, "IP/name cache successfully initialized");
LogEvent(COMPONENT_INIT, "Initializing ID Mapper.");
if (!idmapper_init()) {
LogCrit(COMPONENT_INIT, "Failed initializing ID Mapper.");
return -1;
}
LogEvent(COMPONENT_INIT, "ID Mapper successfully initialized.");
return 0;
}
int nfs4_op_lock(struct nfs_argop4 *op, compound_data_t * data, struct nfs_resop4 *resp)
{
char __attribute__ ((__unused__)) funcname[] = "nfs4_op_lock";
#ifndef _WITH_NFSV4_LOCKS
/* Lock are not supported */
resp->resop = NFS4_OP_LOCK;
res_LOCK4.status = NFS4ERR_LOCK_NOTSUPP;
return res_LOCK4.status;
#else
state_status_t state_status;
state_data_t candidate_data;
state_type_t candidate_type;
int rc = 0;
seqid4 seqid;
state_t * plock_state; /* state for the lock */
state_t * pstate_open; /* state for the open owner */
state_owner_t * plock_owner;
state_owner_t * popen_owner;
state_owner_t * presp_owner; /* Owner to store response in */
state_owner_t * conflict_owner = NULL;
state_nfs4_owner_name_t owner_name;
nfs_client_id_t nfs_client_id;
state_lock_desc_t lock_desc, conflict_desc;
state_blocking_t blocking = STATE_NON_BLOCKING;
const char * tag = "LOCK";
LogDebug(COMPONENT_NFS_V4_LOCK,
"Entering NFS v4 LOCK handler -----------------------------------------------------");
/* Initialize to sane starting values */
resp->resop = NFS4_OP_LOCK;
/* If there is no FH */
if(nfs4_Is_Fh_Empty(&(data->currentFH)))
{
res_LOCK4.status = NFS4ERR_NOFILEHANDLE;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed nfs4_Is_Fh_Empty");
return res_LOCK4.status;
}
/* If the filehandle is invalid */
if(nfs4_Is_Fh_Invalid(&(data->currentFH)))
{
res_LOCK4.status = NFS4ERR_BADHANDLE;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed nfs4_Is_Fh_Invalid");
return res_LOCK4.status;
}
/* Tests if the Filehandle is expired (for volatile filehandle) */
if(nfs4_Is_Fh_Expired(&(data->currentFH)))
{
res_LOCK4.status = NFS4ERR_FHEXPIRED;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed nfs4_Is_Fh_Expired");
return res_LOCK4.status;
}
/* Lock is done only on a file */
if(data->current_filetype != REGULAR_FILE)
{
/* Type of the entry is not correct */
switch (data->current_filetype)
{
case DIRECTORY:
res_LOCK4.status = NFS4ERR_ISDIR;
break;
default:
res_LOCK4.status = NFS4ERR_INVAL;
break;
}
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed wrong file type");
return res_LOCK4.status;
}
/* Convert lock parameters to internal types */
switch(arg_LOCK4.locktype)
{
case READ_LT:
lock_desc.sld_type = STATE_LOCK_R;
blocking = STATE_NON_BLOCKING;
break;
case WRITE_LT:
lock_desc.sld_type = STATE_LOCK_W;
blocking = STATE_NON_BLOCKING;
break;
case READW_LT:
lock_desc.sld_type = STATE_LOCK_R;
blocking = STATE_NFSV4_BLOCKING;
break;
case WRITEW_LT:
lock_desc.sld_type = STATE_LOCK_W;
blocking = STATE_NFSV4_BLOCKING;
break;
}
lock_desc.sld_offset = arg_LOCK4.offset;
if(arg_LOCK4.length != STATE_LOCK_OFFSET_EOF)
lock_desc.sld_length = arg_LOCK4.length;
else
lock_desc.sld_length = 0;
if(arg_LOCK4.locker.new_lock_owner)
{
/* New lock owner, Find the open owner */
tag = "LOCK (new owner)";
/* Check stateid correctness and get pointer to state */
if((rc = nfs4_Check_Stateid(&arg_LOCK4.locker.locker4_u.open_owner.open_stateid,
data->current_entry,
0LL,
&pstate_open,
data,
STATEID_SPECIAL_FOR_LOCK,
tag)) != NFS4_OK)
{
res_LOCK4.status = rc;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed nfs4_Check_Stateid for open owner");
return res_LOCK4.status;
}
popen_owner = pstate_open->state_powner;
plock_state = NULL;
plock_owner = NULL;
presp_owner = popen_owner;
seqid = arg_LOCK4.locker.locker4_u.open_owner.open_seqid;
LogLock(COMPONENT_NFS_V4_LOCK, NIV_FULL_DEBUG,
"LOCK New lock owner from open owner",
data->current_entry,
data->pcontext,
popen_owner,
&lock_desc);
/* Check is the clientid is known or not */
if(nfs_client_id_get(arg_LOCK4.locker.locker4_u.open_owner.lock_owner.clientid,
&nfs_client_id) == CLIENT_ID_NOT_FOUND)
{
res_LOCK4.status = NFS4ERR_STALE_CLIENTID;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed nfs_client_id_get");
return res_LOCK4.status;
}
/* The related stateid is already stored in pstate_open */
/* An open state has been found. Check its type */
if(pstate_open->state_type != STATE_TYPE_SHARE)
{
res_LOCK4.status = NFS4ERR_BAD_STATEID;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed open stateid is not a SHARE");
return res_LOCK4.status;
}
/* Lock seqid (seqid wanted for new lock) should be 0 (see newpynfs test LOCK8c) */
if(arg_LOCK4.locker.locker4_u.open_owner.lock_seqid != 0)
{
res_LOCK4.status = NFS4ERR_BAD_SEQID;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed new lock stateid is not 0");
return res_LOCK4.status;
}
/* Is this lock_owner known ? */
convert_nfs4_lock_owner(&arg_LOCK4.locker.locker4_u.open_owner.lock_owner,
&owner_name);
}
else
{
/* Existing lock owner
* Find the lock stateid
* From that, get the open_owner
*/
tag = "LOCK (existing owner)";
/* There was code here before to handle all-0 stateid, but that
* really doesn't apply - when we handle temporary locks for
* I/O operations (which is where we will see all-0 or all-1
* stateid, those will not come in through nfs4_op_lock.
*/
/* Check stateid correctness and get pointer to state */
if((rc = nfs4_Check_Stateid(&arg_LOCK4.locker.locker4_u.lock_owner.lock_stateid,
data->current_entry,
0LL,
&plock_state,
data,
STATEID_SPECIAL_FOR_LOCK,
tag)) != NFS4_OK)
{
res_LOCK4.status = rc;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed nfs4_Check_Stateid for existing lock owner");
return res_LOCK4.status;
}
/* An lock state has been found. Check its type */
if(plock_state->state_type != STATE_TYPE_LOCK)
{
res_LOCK4.status = NFS4ERR_BAD_STATEID;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed existing lock owner, state type is not LOCK");
return res_LOCK4.status;
}
/* Get the old lockowner. We can do the following 'cast', in NFSv4 lock_owner4 and open_owner4
* are different types but with the same definition*/
plock_owner = plock_state->state_powner;
popen_owner = plock_owner->so_owner.so_nfs4_owner.so_related_owner;
pstate_open = plock_state->state_data.lock.popenstate;
presp_owner = plock_owner;
seqid = arg_LOCK4.locker.locker4_u.lock_owner.lock_seqid;
LogLock(COMPONENT_NFS_V4_LOCK, NIV_FULL_DEBUG,
"LOCK Existing lock owner",
data->current_entry,
data->pcontext,
plock_owner,
&lock_desc);
#ifdef _CONFORM_TO_TEST_LOCK8c
/* Check validity of the seqid */
if(arg_LOCK4.locker.locker4_u.lock_owner.lock_seqid != 0)
{
res_LOCK4.status = NFS4ERR_BAD_SEQID;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed existing lock owner, lock seqid != 0");
return res_LOCK4.status;
}
#endif
} /* if( arg_LOCK4.locker.new_lock_owner ) */
/* Check seqid (lock_seqid or open_seqid) */
if(!Check_nfs4_seqid(presp_owner, seqid, op, data, resp, tag))
{
/* Response is all setup for us and LogDebug told what was wrong */
return res_LOCK4.status;
}
/* Lock length should not be 0 */
if(arg_LOCK4.length == 0LL)
{
res_LOCK4.status = NFS4ERR_INVAL;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed length == 0");
/* Save the response in the lock or open owner */
Copy_nfs4_state_req(presp_owner, seqid, op, data, resp, tag);
return res_LOCK4.status;
}
/* Check for range overflow.
* Comparing beyond 2^64 is not possible int 64 bits precision,
* but off+len > 2^64-1 is equivalent to len > 2^64-1 - off
*/
if(lock_desc.sld_length > (STATE_LOCK_OFFSET_EOF - lock_desc.sld_offset))
{
res_LOCK4.status = NFS4ERR_INVAL;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed length overflow");
/* Save the response in the lock or open owner */
Copy_nfs4_state_req(presp_owner, seqid, op, data, resp, tag);
return res_LOCK4.status;
}
/* check if open state has correct access for type of lock.
* Don't need to check for conflicting states since this open
* state assures there are no conflicting states.
*/
if(((arg_LOCK4.locktype == WRITE_LT || arg_LOCK4.locktype == WRITEW_LT) &&
((pstate_open->state_data.share.share_access & OPEN4_SHARE_ACCESS_WRITE) == 0)) ||
((arg_LOCK4.locktype == READ_LT || arg_LOCK4.locktype == READW_LT) &&
((pstate_open->state_data.share.share_access & OPEN4_SHARE_ACCESS_READ) == 0)))
{
/* The open state doesn't allow access based on the type of lock */
LogLock(COMPONENT_NFS_V4_LOCK, NIV_DEBUG,
"LOCK failed, SHARE doesn't allow access",
data->current_entry,
data->pcontext,
plock_owner,
&lock_desc);
res_LOCK4.status = NFS4ERR_OPENMODE;
/* Save the response in the lock or open owner */
Copy_nfs4_state_req(presp_owner, seqid, op, data, resp, tag);
return res_LOCK4.status;
}
if(arg_LOCK4.locker.new_lock_owner)
{
/* A lock owner is always associated with a previously made open
* which has itself a previously made stateid
*/
/* Get reference to open owner */
inc_state_owner_ref(popen_owner);
if(nfs4_owner_Get_Pointer(&owner_name, &plock_owner))
{
/* Lock owner already existsc, check lock_seqid if it's not 0 */
if(!Check_nfs4_seqid(plock_owner,
arg_LOCK4.locker.locker4_u.open_owner.lock_seqid,
op,
data,
resp,
"LOCK (new owner but owner exists)"))
{
/* Response is all setup for us and LogDebug told what was wrong */
return res_LOCK4.status;
}
}
else
{
/* This lock owner is not known yet, allocated and set up a new one */
plock_owner = create_nfs4_owner(data->pclient,
&owner_name,
STATE_LOCK_OWNER_NFSV4,
popen_owner,
0);
if(plock_owner == NULL)
{
res_LOCK4.status = NFS4ERR_RESOURCE;
LogLock(COMPONENT_NFS_V4_LOCK, NIV_DEBUG,
"LOCK failed to create new lock owner",
data->current_entry,
data->pcontext,
popen_owner,
&lock_desc);
return res_LOCK4.status;
}
}
/* Prepare state management structure */
memset(&candidate_type, 0, sizeof(candidate_type));
candidate_type = STATE_TYPE_LOCK;
candidate_data.lock.popenstate = pstate_open;
/* Add the lock state to the lock table */
if(state_add(data->current_entry,
candidate_type,
&candidate_data,
plock_owner,
data->pclient,
data->pcontext,
&plock_state, &state_status) != STATE_SUCCESS)
{
res_LOCK4.status = NFS4ERR_RESOURCE;
LogLock(COMPONENT_NFS_V4_LOCK, NIV_DEBUG,
"LOCK failed to add new stateid",
data->current_entry,
data->pcontext,
plock_owner,
&lock_desc);
dec_state_owner_ref(plock_owner, data->pclient);
return res_LOCK4.status;
}
init_glist(&plock_state->state_data.lock.state_locklist);
/* Add lock state to the list of lock states belonging to the open state */
glist_add_tail(&pstate_open->state_data.share.share_lockstates,
&plock_state->state_data.lock.state_sharelist);
} /* if( arg_LOCK4.locker.new_lock_owner ) */
/* Now we have a lock owner and a stateid.
* Go ahead and push lock into SAL (and FSAL).
*/
if(state_lock(data->current_entry,
data->pcontext,
plock_owner,
plock_state,
blocking,
NULL, /* No block data for now */
&lock_desc,
&conflict_owner,
&conflict_desc,
data->pclient,
&state_status) != STATE_SUCCESS)
{
if(state_status == STATE_LOCK_CONFLICT)
{
/* A conflicting lock from a different lock_owner, returns NFS4ERR_DENIED */
Process_nfs4_conflict(&res_LOCK4.LOCK4res_u.denied,
conflict_owner,
&conflict_desc,
data->pclient);
}
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed with status %s",
state_err_str(state_status));
res_LOCK4.status = nfs4_Errno_state(state_status);
/* Save the response in the lock or open owner */
if(res_LOCK4.status != NFS4ERR_RESOURCE &&
res_LOCK4.status != NFS4ERR_BAD_STATEID)
Copy_nfs4_state_req(presp_owner, seqid, op, data, resp, tag);
if(arg_LOCK4.locker.new_lock_owner)
{
/* Need to destroy lock owner and state */
if(state_del(plock_state,
data->pclient,
&state_status) != STATE_SUCCESS)
LogDebug(COMPONENT_NFS_V4_LOCK,
"state_del failed with status %s",
state_err_str(state_status));
}
return res_LOCK4.status;
}
res_LOCK4.status = NFS4_OK;
/* Handle stateid/seqid for success */
update_stateid(plock_state,
&res_LOCK4.LOCK4res_u.resok4.lock_stateid,
data,
tag);
LogFullDebug(COMPONENT_NFS_V4_LOCK,
"LOCK state_seqid = %u, plock_state = %p",
plock_state->state_seqid,
plock_state);
/* Save the response in the lock or open owner */
Copy_nfs4_state_req(presp_owner, seqid, op, data, resp, tag);
LogLock(COMPONENT_NFS_V4_LOCK, NIV_FULL_DEBUG,
"LOCK applied",
data->current_entry,
data->pcontext,
plock_owner,
&lock_desc);
return res_LOCK4.status;
#endif
} /* nfs4_op_lock */
/**
*
* nlm4_send_grant_msg: Send NLMPROC4_GRANTED_MSG
*
* This runs in the nlm_asyn_thread context.
*/
static void nlm4_send_grant_msg(state_async_queue_t *arg)
{
int retval;
char buffer[1024];
state_status_t state_status = STATE_SUCCESS;
state_cookie_entry_t * cookie_entry;
fsal_op_context_t context, * pcontext = &context;
state_nlm_async_data_t * nlm_arg = &arg->state_async_data.state_nlm_async_data;
if(isDebug(COMPONENT_NLM))
{
netobj_to_string(&nlm_arg->nlm_async_args.nlm_async_grant.cookie,
buffer, sizeof(buffer));
LogDebug(COMPONENT_NLM,
"Sending GRANTED for arg=%p svid=%d start=%llx len=%llx cookie=%s",
arg, nlm_arg->nlm_async_args.nlm_async_grant.alock.svid,
(unsigned long long) nlm_arg->nlm_async_args.nlm_async_grant.alock.l_offset,
(unsigned long long) nlm_arg->nlm_async_args.nlm_async_grant.alock.l_len,
buffer);
}
retval = nlm_send_async(NLMPROC4_GRANTED_MSG,
nlm_arg->nlm_async_host,
&(nlm_arg->nlm_async_args.nlm_async_grant),
nlm_arg->nlm_async_key);
dec_nlm_client_ref(nlm_arg->nlm_async_host);
free_grant_arg(arg);
/* If success, we are done. */
if(retval == RPC_SUCCESS)
return;
/*
* We are not able call granted callback. Some client may retry
* the lock again. So remove the existing blocked nlm entry
*/
LogMajor(COMPONENT_NLM,
"GRANTED_MSG RPC call failed with return code %d. Removing the blocking lock",
retval);
if(state_find_grant(nlm_arg->nlm_async_args.nlm_async_grant.cookie.n_bytes,
nlm_arg->nlm_async_args.nlm_async_grant.cookie.n_len,
&cookie_entry,
&state_status) != STATE_SUCCESS)
{
/* This must be an old NLM_GRANTED_RES */
LogFullDebug(COMPONENT_NLM,
"Could not find cookie=%s status=%s",
buffer, state_err_str(state_status));
return;
}
PTHREAD_RWLOCK_WRLOCK(&cookie_entry->sce_pentry->state_lock);
if(cookie_entry->sce_lock_entry->sle_block_data == NULL ||
!nlm_block_data_to_fsal_context(cookie_entry->sce_lock_entry->sle_block_data,
pcontext))
{
/* Wow, we're not doing well... */
PTHREAD_RWLOCK_UNLOCK(&cookie_entry->sce_pentry->state_lock);
LogFullDebug(COMPONENT_NLM,
"Could not find block data for cookie=%s (must be an old NLM_GRANTED_RES)",
buffer);
return;
}
PTHREAD_RWLOCK_UNLOCK(&cookie_entry->sce_pentry->state_lock);
if(state_release_grant(pcontext,
cookie_entry,
&state_status) != STATE_SUCCESS)
{
/* Huh? */
LogFullDebug(COMPONENT_NLM,
"Could not release cookie=%s status=%s",
buffer, state_err_str(state_status));
}
}
static void nfs_Init(const nfs_start_info_t *p_start_info)
{
cache_inode_status_t cache_status;
state_status_t state_status;
int rc = 0;
#ifdef _HAVE_GSSAPI
gss_buffer_desc gss_service_buf;
OM_uint32 maj_stat, min_stat;
char GssError[MAXNAMLEN + 1];
#endif
#ifdef USE_DBUS
/* DBUS init */
gsh_dbus_pkginit();
#ifdef USE_DBUS_STATS
dbus_export_init();
dbus_client_init();
#endif
#endif
/* Cache Inode Initialisation */
cache_status = cache_inode_init();
if (cache_status != CACHE_INODE_SUCCESS) {
LogFatal(COMPONENT_INIT,
"Cache Inode Layer could not be initialized, status=%s",
cache_inode_err_str(cache_status));
}
state_status = state_lock_init(nfs_param.cache_param.cookie_param);
if (state_status != STATE_SUCCESS) {
LogFatal(COMPONENT_INIT,
"State Lock Layer could not be initialized, status=%s",
state_err_str(state_status));
}
LogInfo(COMPONENT_INIT, "Cache Inode library successfully initialized");
/* Cache Inode LRU (call this here, rather than as part of
cache_inode_init() so the GC policy has been set */
rc = cache_inode_lru_pkginit();
if (rc != 0) {
LogFatal(COMPONENT_INIT,
"Unable to initialize LRU subsystem: %d.", rc);
}
/* finish the job with exports by caching the root entries
*/
exports_pkginit();
nfs41_session_pool =
pool_init("NFSv4.1 session pool", sizeof(nfs41_session_t),
pool_basic_substrate, NULL, NULL, NULL);
request_pool =
pool_init("Request pool", sizeof(request_data_t),
pool_basic_substrate, NULL,
NULL /* FASTER constructor_request_data_t */ ,
NULL);
if (!request_pool) {
LogCrit(COMPONENT_INIT, "Error while allocating request pool");
LogError(COMPONENT_INIT, ERR_SYS, ERR_MALLOC, errno);
Fatal();
}
request_data_pool =
pool_init("Request Data Pool", sizeof(nfs_request_data_t),
pool_basic_substrate, NULL,
NULL /* FASTER constructor_nfs_request_data_t */ ,
NULL);
if (!request_data_pool) {
LogCrit(COMPONENT_INIT,
"Error while allocating request data pool");
LogError(COMPONENT_INIT, ERR_SYS, ERR_MALLOC, errno);
Fatal();
}
dupreq_pool =
pool_init("Duplicate Request Pool", sizeof(dupreq_entry_t),
pool_basic_substrate, NULL, NULL, NULL);
if (!(dupreq_pool)) {
LogCrit(COMPONENT_INIT,
"Error while allocating duplicate request pool");
LogError(COMPONENT_INIT, ERR_SYS, ERR_MALLOC, errno);
Fatal();
}
#ifdef _USE_ASYNC_CACHE_INODE
/* Start the TAD and synclets for writeback cache inode */
cache_inode_async_init(nfs_param.cache_layers_param.
cache_inode_client_param);
#endif
/* If rpcsec_gss is used, set the path to the keytab */
#ifdef _HAVE_GSSAPI
#ifdef HAVE_KRB5
if (nfs_param.krb5_param.active_krb5) {
OM_uint32 gss_status = GSS_S_COMPLETE;
if (nfs_param.krb5_param.keytab[0] != '\0')
gss_status =
krb5_gss_register_acceptor_identity(nfs_param.
krb5_param.
keytab);
if (gss_status != GSS_S_COMPLETE) {
log_sperror_gss(GssError, gss_status, 0);
LogFatal(COMPONENT_INIT,
"Error setting krb5 keytab to value %s is %s",
nfs_param.krb5_param.keytab, GssError);
}
LogInfo(COMPONENT_INIT,
"krb5 keytab path successfully set to %s",
nfs_param.krb5_param.keytab);
#endif /* HAVE_KRB5 */
/* Set up principal to be use for GSSAPPI within GSSRPC/KRB5 */
gss_service_buf.value = nfs_param.krb5_param.svc.principal;
gss_service_buf.length =
strlen(nfs_param.krb5_param.svc.principal) + 1;
/* The '+1' is not to be forgotten, for the '\0' at the end */
maj_stat = gss_import_name(&min_stat, &gss_service_buf,
(gss_OID) GSS_C_NT_HOSTBASED_SERVICE,
&nfs_param.krb5_param.svc.gss_name);
if (maj_stat != GSS_S_COMPLETE) {
log_sperror_gss(GssError, maj_stat, min_stat);
LogFatal(COMPONENT_INIT,
"Error importing gss principal %s is %s",
nfs_param.krb5_param.svc.principal, GssError);
}
if (nfs_param.krb5_param.svc.gss_name == GSS_C_NO_NAME)
LogInfo(COMPONENT_INIT,
"Regression: svc.gss_name == GSS_C_NO_NAME");
LogInfo(COMPONENT_INIT, "gss principal \"%s\" successfully set",
nfs_param.krb5_param.svc.principal);
/* Set the principal to GSSRPC */
if (!svcauth_gss_set_svc_name
(nfs_param.krb5_param.svc.gss_name)) {
LogFatal(COMPONENT_INIT,
"Impossible to set gss principal to GSSRPC");
}
/* Don't release name until shutdown, it will be used by the
* backchannel. */
#ifdef HAVE_KRB5
} /* if( nfs_param.krb5_param.active_krb5 ) */
#endif /* HAVE_KRB5 */
#endif /* _HAVE_GSSAPI */
/* RPC Initialisation - exits on failure */
nfs_Init_svc();
LogInfo(COMPONENT_INIT, "RPC ressources successfully initialized");
/* Admin initialisation */
nfs_Init_admin_thread();
LogEvent(COMPONENT_INIT, "Initializing ID Mapper.");
if (!idmapper_init())
LogFatal(COMPONENT_INIT, "Failed initializing ID Mapper.");
else
LogEvent(COMPONENT_INIT, "ID Mapper successfully initialized.");
/* Init the NFSv4 Clientid cache */
LogDebug(COMPONENT_INIT, "Now building NFSv4 clientid cache");
if (nfs_Init_client_id(&nfs_param.client_id_param) !=
CLIENT_ID_SUCCESS) {
LogFatal(COMPONENT_INIT,
"Error while initializing NFSv4 clientid cache");
}
LogInfo(COMPONENT_INIT,
"NFSv4 clientid cache successfully initialized");
/* Init duplicate request cache */
dupreq2_pkginit();
LogInfo(COMPONENT_INIT,
"duplicate request hash table cache successfully initialized");
/* Init the IP/name cache */
LogDebug(COMPONENT_INIT, "Now building IP/name cache");
if (nfs_Init_ip_name(nfs_param.ip_name_param) != IP_NAME_SUCCESS) {
LogFatal(COMPONENT_INIT,
"Error while initializing IP/name cache");
}
LogInfo(COMPONENT_INIT, "IP/name cache successfully initialized");
/* Init The NFSv4 State id cache */
LogDebug(COMPONENT_INIT, "Now building NFSv4 State Id cache");
if (nfs4_Init_state_id(&nfs_param.state_id_param) != 0) {
LogFatal(COMPONENT_INIT,
"Error while initializing NFSv4 State Id cache");
}
LogInfo(COMPONENT_INIT,
"NFSv4 State Id cache successfully initialized");
/* Init The NFSv4 Open Owner cache */
LogDebug(COMPONENT_INIT, "Now building NFSv4 Owner cache");
if (Init_nfs4_owner(&nfs_param.nfs4_owner_param) != 0) {
LogFatal(COMPONENT_INIT,
"Error while initializing NFSv4 Owner cache");
}
LogInfo(COMPONENT_INIT,
"NFSv4 Open Owner cache successfully initialized");
if (nfs_param.core_param.enable_NLM) {
/* Init The NLM Owner cache */
LogDebug(COMPONENT_INIT, "Now building NLM Owner cache");
if (Init_nlm_hash() != 0) {
LogFatal(COMPONENT_INIT,
"Error while initializing NLM Owner cache");
}
LogInfo(COMPONENT_INIT,
"NLM Owner cache successfully initialized");
nlm_init();
}
#ifdef _USE_9P
/* Init the 9P lock owner cache */
LogDebug(COMPONENT_INIT, "Now building 9P Owner cache");
if (Init_9p_hash() != 0) {
LogFatal(COMPONENT_INIT,
"Error while initializing 9P Owner cache");
}
LogInfo(COMPONENT_INIT, "9P Owner cache successfully initialized");
#endif
LogDebug(COMPONENT_INIT, "Now building NFSv4 Session Id cache");
if (nfs41_Init_session_id(&nfs_param.session_id_param) != 0) {
LogFatal(COMPONENT_INIT,
"Error while initializing NFSv4 Session Id cache");
}
LogInfo(COMPONENT_INIT,
"NFSv4 Session Id cache successfully initialized");
LogDebug(COMPONENT_INIT, "Now building NFSv4 ACL cache");
if (nfs4_acls_init() != 0) {
LogCrit(COMPONENT_INIT, "Error while initializing NFSv4 ACLs");
exit(1);
}
LogInfo(COMPONENT_INIT, "NFSv4 ACL cache successfully initialized");
#ifdef _USE_9P
LogDebug(COMPONENT_INIT, "Now building 9P resources");
if (_9p_init(&nfs_param._9p_param)) {
LogCrit(COMPONENT_INIT,
"Error while initializing 9P Resources");
exit(1);
}
LogInfo(COMPONENT_INIT, "9P resources successfully initialized");
#endif /* _USE_9P */
/* Creates the pseudo fs */
LogDebug(COMPONENT_INIT, "Now building pseudo fs");
rc = nfs4_ExportToPseudoFS();
if (rc != 0)
LogFatal(COMPONENT_INIT,
"Error %d while initializing NFSv4 pseudo file system",
rc);
LogInfo(COMPONENT_INIT,
"NFSv4 pseudo file system successfully initialized");
/* Save Ganesha thread credentials with Frank's routine for later use */
fsal_save_ganesha_credentials();
/* Create stable storage directory, this needs to be done before
* starting the recovery thread.
*/
nfs4_create_recov_dir();
/* initialize grace and read in the client IDs */
nfs4_init_grace();
nfs4_load_recov_clids(NULL);
/* Start grace period */
nfs4_start_grace(NULL);
/* callback dispatch */
nfs_rpc_cb_pkginit();
#ifdef _USE_CB_SIMULATOR
nfs_rpc_cbsim_pkginit();
#endif /* _USE_CB_SIMULATOR */
} /* nfs_Init */
int nfs4_op_lock(struct nfs_argop4 *op, compound_data_t *data,
struct nfs_resop4 *resp)
{
/* Shorter alias for arguments */
LOCK4args * const arg_LOCK4 = &op->nfs_argop4_u.oplock;
/* Shorter alias for response */
LOCK4res * const res_LOCK4 = &resp->nfs_resop4_u.oplock;
/* Status code from state calls */
state_status_t state_status = STATE_SUCCESS;
/* Data for lock state to be created */
union state_data candidate_data;
/* Status code for protocol functions */
nfsstat4 nfs_status = 0;
/* Created or found lock state */
state_t *lock_state = NULL;
/* Associated open state */
state_t *state_open = NULL;
/* The lock owner */
state_owner_t *lock_owner = NULL;
/* The open owner */
state_owner_t *open_owner = NULL;
/* The owner of a conflicting lock */
state_owner_t *conflict_owner = NULL;
/* The owner in which to store the response for NFSv4.0 */
state_owner_t *resp_owner = NULL;
/* Sequence ID, for NFSv4.0 */
seqid4 seqid = 0;
/* The client performing these operations */
nfs_client_id_t *clientid = NULL;
/* Name for the lock owner */
state_nfs4_owner_name_t owner_name;
/* Description of requrested lock */
fsal_lock_param_t lock_desc;
/* Description of conflicting lock */
fsal_lock_param_t conflict_desc;
/* Whether to block */
state_blocking_t blocking = STATE_NON_BLOCKING;
/* Tracking data for the lock state */
struct state_refer refer;
/* Indicate if we let FSAL to handle requests during grace. */
bool_t fsal_grace = false;
int rc;
LogDebug(COMPONENT_NFS_V4_LOCK,
"Entering NFS v4 LOCK handler ----------------------");
/* Initialize to sane starting values */
resp->resop = NFS4_OP_LOCK;
res_LOCK4->status = NFS4_OK;
/* Record the sequence info */
if (data->minorversion > 0) {
memcpy(refer.session,
data->session->session_id,
sizeof(sessionid4));
refer.sequence = data->sequence;
refer.slot = data->slot;
}
res_LOCK4->status = nfs4_sanity_check_FH(data, REGULAR_FILE, false);
if (res_LOCK4->status != NFS4_OK)
return res_LOCK4->status;
/* Convert lock parameters to internal types */
switch (arg_LOCK4->locktype) {
case READW_LT:
blocking = STATE_NFSV4_BLOCKING;
/* Fall through */
case READ_LT:
lock_desc.lock_type = FSAL_LOCK_R;
break;
case WRITEW_LT:
blocking = STATE_NFSV4_BLOCKING;
/* Fall through */
case WRITE_LT:
lock_desc.lock_type = FSAL_LOCK_W;
break;
default:
LogDebug(COMPONENT_NFS_V4_LOCK,
"Invalid lock type");
res_LOCK4->status = NFS4ERR_INVAL;
return res_LOCK4->status;
}
lock_desc.lock_start = arg_LOCK4->offset;
lock_desc.lock_sle_type = FSAL_POSIX_LOCK;
lock_desc.lock_reclaim = arg_LOCK4->reclaim;
if (arg_LOCK4->length != STATE_LOCK_OFFSET_EOF)
lock_desc.lock_length = arg_LOCK4->length;
else
lock_desc.lock_length = 0;
if (arg_LOCK4->locker.new_lock_owner) {
/* Check stateid correctness and get pointer to state */
nfs_status = nfs4_Check_Stateid(
&arg_LOCK4->locker.locker4_u.open_owner.open_stateid,
data->current_obj,
&state_open,
data,
STATEID_SPECIAL_FOR_LOCK,
arg_LOCK4->locker.locker4_u.open_owner.open_seqid,
data->minorversion == 0,
lock_tag);
if (nfs_status != NFS4_OK) {
if (nfs_status == NFS4ERR_REPLAY) {
open_owner = get_state_owner_ref(state_open);
LogStateOwner("Open: ", open_owner);
if (open_owner != NULL) {
resp_owner = open_owner;
seqid = arg_LOCK4->locker.locker4_u
.open_owner.open_seqid;
goto check_seqid;
}
}
res_LOCK4->status = nfs_status;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed nfs4_Check_Stateid for open owner");
return res_LOCK4->status;
}
open_owner = get_state_owner_ref(state_open);
LogStateOwner("Open: ", open_owner);
if (open_owner == NULL) {
/* State is going stale. */
res_LOCK4->status = NFS4ERR_STALE;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed nfs4_Check_Stateid, stale open owner");
goto out2;
}
lock_state = NULL;
lock_owner = NULL;
resp_owner = open_owner;
seqid = arg_LOCK4->locker.locker4_u.open_owner.open_seqid;
LogLock(COMPONENT_NFS_V4_LOCK, NIV_FULL_DEBUG,
"LOCK New lock owner from open owner",
data->current_obj, open_owner, &lock_desc);
/* Check is the clientid is known or not */
rc = nfs_client_id_get_confirmed(
data->minorversion == 0 ? arg_LOCK4->locker.
locker4_u.open_owner.lock_owner.clientid
: data->session->clientid,
&clientid);
if (rc != CLIENT_ID_SUCCESS) {
res_LOCK4->status = clientid_error_to_nfsstat(rc);
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed nfs_client_id_get");
goto out2;
}
if (isDebug(COMPONENT_CLIENTID) && (clientid !=
open_owner->so_owner.so_nfs4_owner.so_clientrec)) {
char str_open[LOG_BUFF_LEN / 2];
struct display_buffer dspbuf_open = {
sizeof(str_open), str_open, str_open};
char str_lock[LOG_BUFF_LEN / 2];
struct display_buffer dspbuf_lock = {
sizeof(str_lock), str_lock, str_lock};
display_client_id_rec(&dspbuf_open,
open_owner->so_owner
.so_nfs4_owner.so_clientrec);
display_client_id_rec(&dspbuf_lock, clientid);
LogDebug(COMPONENT_CLIENTID,
"Unexpected, new lock owner clientid {%s} doesn't match open owner clientid {%s}",
str_lock, str_open);
}
/* The related stateid is already stored in state_open */
/* An open state has been found. Check its type */
if (state_open->state_type != STATE_TYPE_SHARE) {
res_LOCK4->status = NFS4ERR_BAD_STATEID;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed open stateid is not a SHARE");
goto out2;
}
/* Is this lock_owner known ? */
convert_nfs4_lock_owner(&arg_LOCK4->locker.locker4_u.open_owner.
lock_owner, &owner_name);
LogStateOwner("Lock: ", lock_owner);
} else {
/* Existing lock owner Find the lock stateid From
* that, get the open_owner
*
* There was code here before to handle all-0 stateid,
* but that really doesn't apply - when we handle
* temporary locks for I/O operations (which is where
* we will see all-0 or all-1 stateid, those will not
* come in through nfs4_op_lock.
*
* Check stateid correctness and get pointer to state
*/
nfs_status = nfs4_Check_Stateid(
&arg_LOCK4->locker.locker4_u.lock_owner.lock_stateid,
data->current_obj,
&lock_state,
data,
STATEID_SPECIAL_FOR_LOCK,
arg_LOCK4->locker.locker4_u.lock_owner.lock_seqid,
data->minorversion == 0,
lock_tag);
if (nfs_status != NFS4_OK) {
if (nfs_status == NFS4ERR_REPLAY) {
lock_owner = get_state_owner_ref(lock_state);
LogStateOwner("Lock: ", lock_owner);
if (lock_owner != NULL) {
open_owner = lock_owner->so_owner
.so_nfs4_owner.so_related_owner;
inc_state_owner_ref(open_owner);
resp_owner = lock_owner;
seqid = arg_LOCK4->locker.locker4_u
.lock_owner.lock_seqid;
goto check_seqid;
}
}
res_LOCK4->status = nfs_status;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed nfs4_Check_Stateid for existing lock owner");
return res_LOCK4->status;
}
/* Check if lock state belongs to same export */
if (!state_same_export(lock_state, op_ctx->ctx_export)) {
LogEvent(COMPONENT_STATE,
"Lock Owner Export Conflict, Lock held for export %"
PRIu16" request for export %"PRIu16,
state_export_id(lock_state),
op_ctx->ctx_export->export_id);
res_LOCK4->status = NFS4ERR_INVAL;
goto out2;
}
/* A lock state has been found. Check its type */
if (lock_state->state_type != STATE_TYPE_LOCK) {
res_LOCK4->status = NFS4ERR_BAD_STATEID;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed existing lock owner, state type is not LOCK");
goto out2;
}
/* Get the old lockowner. We can do the following
* 'cast', in NFSv4 lock_owner4 and open_owner4 are
* different types but with the same definition
*/
lock_owner = get_state_owner_ref(lock_state);
LogStateOwner("Lock: ", lock_owner);
if (lock_owner == NULL) {
/* State is going stale. */
res_LOCK4->status = NFS4ERR_STALE;
LogDebug(COMPONENT_NFS_V4_LOCK,
"LOCK failed nfs4_Check_Stateid, stale open owner");
goto out2;
}
open_owner =
lock_owner->so_owner.so_nfs4_owner.so_related_owner;
LogStateOwner("Open: ", open_owner);
inc_state_owner_ref(open_owner);
state_open = lock_state->state_data.lock.openstate;
inc_state_t_ref(state_open);
resp_owner = lock_owner;
seqid = arg_LOCK4->locker.locker4_u.lock_owner.lock_seqid;
LogLock(COMPONENT_NFS_V4_LOCK, NIV_FULL_DEBUG,
"LOCK Existing lock owner", data->current_obj,
lock_owner, &lock_desc);
/* Get the client for this open owner */
clientid = open_owner->so_owner.so_nfs4_owner.so_clientrec;
inc_client_id_ref(clientid);
}
check_seqid:
/* Check seqid (lock_seqid or open_seqid) */
if (data->minorversion == 0) {
if (!Check_nfs4_seqid(resp_owner,
seqid,
op,
data->current_obj,
resp,
lock_tag)) {
/* Response is all setup for us and LogDebug
* told what was wrong
*/
goto out2;
}
}
/* Lock length should not be 0 */
if (arg_LOCK4->length == 0LL) {
res_LOCK4->status = NFS4ERR_INVAL;
LogDebug(COMPONENT_NFS_V4_LOCK, "LOCK failed length == 0");
goto out;
}
/* Check for range overflow. Comparing beyond 2^64 is not
* possible int 64 bits precision, but off+len > 2^64-1 is
* equivalent to len > 2^64-1 - off
*/
if (lock_desc.lock_length >
(STATE_LOCK_OFFSET_EOF - lock_desc.lock_start)) {
res_LOCK4->status = NFS4ERR_INVAL;
LogDebug(COMPONENT_NFS_V4_LOCK, "LOCK failed length overflow");
goto out;
}
/* Check if open state has correct access for type of lock.
*
* Don't need to check for conflicting states since this open
* state assures there are no conflicting states.
*/
if (((arg_LOCK4->locktype == WRITE_LT ||
arg_LOCK4->locktype == WRITEW_LT)
&&
((state_open->state_data.share.share_access &
OPEN4_SHARE_ACCESS_WRITE) == 0))
||
((arg_LOCK4->locktype == READ_LT ||
arg_LOCK4->locktype == READW_LT)
&&
((state_open->state_data.share.share_access &
OPEN4_SHARE_ACCESS_READ) == 0))) {
/* The open state doesn't allow access based on the
* type of lock
*/
LogLock(COMPONENT_NFS_V4_LOCK, NIV_DEBUG,
"LOCK failed, SHARE doesn't allow access",
data->current_obj, lock_owner, &lock_desc);
res_LOCK4->status = NFS4ERR_OPENMODE;
goto out;
}
/* Do grace period checking (use resp_owner below since a new
* lock request with a new lock owner doesn't have a lock owner
* yet, but does have an open owner - resp_owner is always one or
* the other and non-NULL at this point - so makes for a better log).
*/
if (nfs_in_grace()) {
if (op_ctx->fsal_export->exp_ops.
fs_supports(op_ctx->fsal_export, fso_grace_method))
fsal_grace = true;
if (!fsal_grace && !arg_LOCK4->reclaim) {
LogLock(COMPONENT_NFS_V4_LOCK, NIV_DEBUG,
"LOCK failed, non-reclaim while in grace",
data->current_obj, resp_owner, &lock_desc);
res_LOCK4->status = NFS4ERR_GRACE;
goto out;
}
if (!fsal_grace && arg_LOCK4->reclaim
&& !clientid->cid_allow_reclaim) {
LogLock(COMPONENT_NFS_V4_LOCK, NIV_DEBUG,
"LOCK failed, invalid reclaim while in grace",
data->current_obj, resp_owner, &lock_desc);
res_LOCK4->status = NFS4ERR_NO_GRACE;
goto out;
}
} else {
if (arg_LOCK4->reclaim) {
LogLock(COMPONENT_NFS_V4_LOCK, NIV_DEBUG,
"LOCK failed, reclaim while not in grace",
data->current_obj, resp_owner, &lock_desc);
res_LOCK4->status = NFS4ERR_NO_GRACE;
goto out;
}
}
/* Test if this request is attempting to create a new lock owner */
if (arg_LOCK4->locker.new_lock_owner) {
bool_t isnew;
/* A lock owner is always associated with a previously
made open which has itself a previously made
stateid */
/* This lock owner is not known yet, allocated and set
up a new one */
lock_owner = create_nfs4_owner(&owner_name,
clientid,
STATE_LOCK_OWNER_NFSV4,
open_owner,
0,
&isnew,
CARE_ALWAYS);
LogStateOwner("Lock: ", lock_owner);
if (lock_owner == NULL) {
res_LOCK4->status = NFS4ERR_RESOURCE;
LogLock(COMPONENT_NFS_V4_LOCK, NIV_EVENT,
"LOCK failed to create new lock owner",
data->current_obj, open_owner, &lock_desc);
goto out2;
}
if (!isnew) {
PTHREAD_MUTEX_lock(&lock_owner->so_mutex);
/* Check lock_seqid if it has attached locks. */
if (!glist_empty(&lock_owner->so_lock_list)
&& (data->minorversion == 0)
&& !Check_nfs4_seqid(lock_owner,
arg_LOCK4->locker.locker4_u.
open_owner.lock_seqid,
op,
data->current_obj,
resp,
lock_tag)) {
LogLock(COMPONENT_NFS_V4_LOCK, NIV_DEBUG,
"LOCK failed to create new lock owner, re-use",
data->current_obj,
open_owner, &lock_desc);
dump_all_locks(
"All locks (re-use of lock owner)");
PTHREAD_MUTEX_unlock(&lock_owner->so_mutex);
/* Response is all setup for us and
* LogDebug told what was wrong
*/
goto out2;
}
PTHREAD_MUTEX_unlock(&lock_owner->so_mutex);
/* Lock owner is known, see if we also already have
* a stateid. Do this here since it's impossible for
* there to be such a state if the lock owner was
* previously unknown.
*/
lock_state = nfs4_State_Get_Obj(data->current_obj,
lock_owner);
}
if (lock_state == NULL) {
/* Prepare state management structure */
memset(&candidate_data, 0, sizeof(candidate_data));
candidate_data.lock.openstate = state_open;
/* Add the lock state to the lock table */
state_status = state_add(data->current_obj,
STATE_TYPE_LOCK,
&candidate_data,
lock_owner,
&lock_state,
data->minorversion > 0 ?
&refer : NULL);
if (state_status != STATE_SUCCESS) {
res_LOCK4->status = NFS4ERR_RESOURCE;
LogLock(COMPONENT_NFS_V4_LOCK, NIV_DEBUG,
"LOCK failed to add new stateid",
data->current_obj, lock_owner,
&lock_desc);
goto out2;
}
glist_init(&lock_state->state_data.lock.state_locklist);
/* Add lock state to the list of lock states belonging
to the open state */
glist_add_tail(
&state_open->state_data.share.share_lockstates,
&lock_state->state_data.lock.state_sharelist);
}
}
if (data->minorversion == 0) {
op_ctx->clientid =
&lock_owner->so_owner.so_nfs4_owner.so_clientid;
}
/* Now we have a lock owner and a stateid. Go ahead and push
* lock into SAL (and FSAL). */
state_status = state_lock(data->current_obj,
lock_owner,
lock_state,
blocking,
NULL, /* No block data for now */
&lock_desc,
&conflict_owner,
&conflict_desc);
if (state_status != STATE_SUCCESS) {
if (state_status == STATE_LOCK_CONFLICT) {
/* A conflicting lock from a different
lock_owner, returns NFS4ERR_DENIED */
Process_nfs4_conflict(&res_LOCK4->LOCK4res_u.denied,
conflict_owner,
&conflict_desc);
}
LogDebug(COMPONENT_NFS_V4_LOCK, "LOCK failed with status %s",
state_err_str(state_status));
res_LOCK4->status = nfs4_Errno_state(state_status);
/* Save the response in the lock or open owner */
if (res_LOCK4->status != NFS4ERR_RESOURCE
&& res_LOCK4->status != NFS4ERR_BAD_STATEID
&& data->minorversion == 0) {
Copy_nfs4_state_req(resp_owner,
seqid,
op,
data->current_obj,
resp,
lock_tag);
}
if (arg_LOCK4->locker.new_lock_owner) {
/* Need to destroy new state */
state_del(lock_state);
}
goto out2;
}
if (data->minorversion == 0)
op_ctx->clientid = NULL;
res_LOCK4->status = NFS4_OK;
/* Handle stateid/seqid for success */
update_stateid(lock_state,
&res_LOCK4->LOCK4res_u.resok4.lock_stateid,
data,
lock_tag);
if (arg_LOCK4->locker.new_lock_owner) {
/* Also save the response in the lock owner */
Copy_nfs4_state_req(lock_owner,
arg_LOCK4->locker.locker4_u.open_owner.
lock_seqid,
op,
data->current_obj,
resp,
lock_tag);
}
if (isFullDebug(COMPONENT_NFS_V4_LOCK)) {
char str[LOG_BUFF_LEN];
struct display_buffer dspbuf = {sizeof(str), str, str};
display_stateid(&dspbuf, lock_state);
LogFullDebug(COMPONENT_NFS_V4_LOCK, "LOCK stateid %s", str);
}
LogLock(COMPONENT_NFS_V4_LOCK, NIV_FULL_DEBUG, "LOCK applied",
data->current_obj, lock_owner, &lock_desc);
out:
if (data->minorversion == 0) {
/* Save the response in the lock or open owner */
Copy_nfs4_state_req(resp_owner,
seqid,
op,
data->current_obj,
resp,
lock_tag);
}
out2:
if (state_open != NULL)
dec_state_t_ref(state_open);
if (lock_state != NULL)
dec_state_t_ref(lock_state);
LogStateOwner("Open: ", open_owner);
LogStateOwner("Lock: ", lock_owner);
if (open_owner != NULL)
dec_state_owner_ref(open_owner);
if (lock_owner != NULL)
dec_state_owner_ref(lock_owner);
if (clientid != NULL)
dec_client_id_ref(clientid);
return res_LOCK4->status;
} /* nfs4_op_lock */
/**
* @brief Create a new delegation state then get the delegation.
*
* Create a new delegation state for this client and file.
* Then attempt to get a LEASE lock to delegate the file
* according to whether the client opened READ or READ/WRITE.
*
* @note state_lock must be held for WRITE
*
* @param[in] data Compound data for this request
* @param[in] op NFS arguments for the request
* @param[in] open_state Open state for the inode to be delegated.
* @param[in] openowner Open owner of the open state.
* @param[in] client Client that will own the delegation.
* @param[in/out] resok Delegation attempt result to be returned to client.
* @param[in] prerecall flag for reclaims.
*/
static void get_delegation(compound_data_t *data, OPEN4args *args,
state_t *open_state, state_owner_t *openowner,
nfs_client_id_t *client, OPEN4resok *resok,
bool prerecall)
{
state_status_t state_status;
union state_data state_data;
open_delegation_type4 deleg_type;
state_owner_t *clientowner = &client->cid_owner;
struct state_refer refer;
state_t *new_state = NULL;
struct state_hdl *ostate;
open_write_delegation4 *writeres =
&resok->delegation.open_delegation4_u.write;
open_read_delegation4 *readres =
&resok->delegation.open_delegation4_u.read;
open_none_delegation4 *whynone =
&resok->delegation.open_delegation4_u.od_whynone;
ostate = data->current_obj->state_hdl;
if (!ostate) {
LogFullDebug(COMPONENT_NFS_V4_LOCK, "Could not get file state");
whynone->ond_why = WND4_RESOURCE;
return;
}
/* Record the sequence info */
if (data->minorversion > 0) {
memcpy(refer.session,
data->session->session_id,
sizeof(sessionid4));
refer.sequence = data->sequence;
refer.slot = data->slot;
}
if (args->share_access & OPEN4_SHARE_ACCESS_WRITE) {
deleg_type = OPEN_DELEGATE_WRITE;
} else {
assert(args->share_access & OPEN4_SHARE_ACCESS_READ);
deleg_type = OPEN_DELEGATE_READ;
}
LogDebug(COMPONENT_STATE, "Attempting to grant %s delegation",
deleg_type == OPEN_DELEGATE_WRITE ? "WRITE" : "READ");
init_new_deleg_state(&state_data, deleg_type, client);
/* Add the delegation state */
state_status = state_add_impl(data->current_obj, STATE_TYPE_DELEG,
&state_data,
clientowner, &new_state,
data->minorversion > 0 ? &refer : NULL);
if (state_status != STATE_SUCCESS) {
LogDebug(COMPONENT_NFS_V4_LOCK,
"get delegation call failed to add state with status %s",
state_err_str(state_status));
whynone->ond_why = WND4_RESOURCE;
return;
}
new_state->state_seqid++;
LogFullDebugOpaque(COMPONENT_STATE,
"delegation state added, stateid: %s",
100, new_state->stateid_other, OTHERSIZE);
/* acquire_lease_lock() gets the delegation from FSAL */
state_status = acquire_lease_lock(ostate, clientowner, new_state);
if (state_status != STATE_SUCCESS) {
if (args->claim.claim != CLAIM_PREVIOUS) {
LogDebug(COMPONENT_NFS_V4_LOCK,
"get delegation call added state but failed to lock with status %s",
state_err_str(state_status));
state_del_locked(new_state);
dec_state_t_ref(new_state);
if (state_status == STATE_LOCK_CONFLICT)
whynone->ond_why = WND4_CONTENTION;
else
whynone->ond_why = WND4_RESOURCE;
return;
}
prerecall = true;
}
resok->delegation.delegation_type = deleg_type;
ostate->file.fdeleg_stats.fds_deleg_type = deleg_type;
if (deleg_type == OPEN_DELEGATE_WRITE) {
nfs_space_limit4 *space_limit = &writeres->space_limit;
space_limit->limitby = NFS_LIMIT_SIZE;
space_limit->nfs_space_limit4_u.filesize =
DELEG_SPACE_LIMIT_FILESZ;
COPY_STATEID(&writeres->stateid, new_state);
writeres->recall = prerecall;
get_deleg_perm(&writeres->permissions, deleg_type);
} else {
assert(deleg_type == OPEN_DELEGATE_READ);
COPY_STATEID(&readres->stateid, new_state);
readres->recall = prerecall;
get_deleg_perm(&readres->permissions, deleg_type);
}
if (isDebug(COMPONENT_NFS_V4_LOCK)) {
char str1[LOG_BUFF_LEN / 2] = "\0";
char str2[LOG_BUFF_LEN / 2] = "\0";
struct display_buffer dspbuf1 = {sizeof(str1), str1, str1};
struct display_buffer dspbuf2 = {sizeof(str2), str2, str2};
display_nfs4_owner(&dspbuf1, openowner);
display_nfs4_owner(&dspbuf2, clientowner);
LogDebug(COMPONENT_NFS_V4_LOCK,
"get delegation openowner %s clientowner %s status %s",
str1, str2, state_err_str(state_status));
}
dec_state_t_ref(new_state);
}
/**
*
* nlm4_send_grant_msg: Send NLMPROC4_GRANTED_MSG
*
* This runs in the nlm_asyn_thread context.
*/
static void nlm4_send_grant_msg(state_async_queue_t *arg)
{
int retval;
char buffer[1024];
state_status_t state_status = STATE_SUCCESS;
state_cookie_entry_t *cookie_entry;
state_nlm_async_data_t *nlm_arg =
&arg->state_async_data.state_nlm_async_data;
struct root_op_context root_op_context;
struct gsh_export *export;
if (isDebug(COMPONENT_NLM)) {
netobj_to_string(&nlm_arg->nlm_async_args.nlm_async_grant.
cookie, buffer, sizeof(buffer));
LogDebug(COMPONENT_NLM,
"Sending GRANTED for arg=%p svid=%d start=%llx len=%llx cookie=%s",
arg,
nlm_arg->nlm_async_args.nlm_async_grant.alock.svid,
(unsigned long long)nlm_arg->nlm_async_args.
nlm_async_grant.alock.l_offset,
(unsigned long long)nlm_arg->nlm_async_args.
nlm_async_grant.alock.l_len, buffer);
}
retval = nlm_send_async(NLMPROC4_GRANTED_MSG,
nlm_arg->nlm_async_host,
&nlm_arg->nlm_async_args.nlm_async_grant,
nlm_arg->nlm_async_key);
dec_nlm_client_ref(nlm_arg->nlm_async_host);
/* If success, we are done. */
if (retval == RPC_SUCCESS)
goto out;
/*
* We are not able call granted callback. Some client may retry
* the lock again. So remove the existing blocked nlm entry
*/
LogMajor(COMPONENT_NLM,
"GRANTED_MSG RPC call failed with return code %d. Removing the blocking lock",
retval);
state_status = state_find_grant(
nlm_arg->nlm_async_args.nlm_async_grant.cookie.n_bytes,
nlm_arg->nlm_async_args.nlm_async_grant.cookie.n_len,
&cookie_entry);
if (state_status != STATE_SUCCESS) {
/* This must be an old NLM_GRANTED_RES */
LogFullDebug(COMPONENT_NLM,
"Could not find cookie=%s status=%s", buffer,
state_err_str(state_status));
goto out;
}
if (cookie_entry->sce_lock_entry->sle_block_data == NULL) {
/* Wow, we're not doing well... */
LogFullDebug(COMPONENT_NLM,
"Could not find block data for cookie=%s (must be an old NLM_GRANTED_RES)",
buffer);
goto out;
}
/* Initialize a context, it is ok if the export is stale because
* we must clean up the cookie_entry.
*/
export = cookie_entry->sce_lock_entry->sle_export;
