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 */
int nfs4_op_setattr(struct nfs_argop4 *op, compound_data_t *data,
struct nfs_resop4 *resp)
{
SETATTR4args * const arg_SETATTR4 = &op->nfs_argop4_u.opsetattr;
SETATTR4res * const res_SETATTR4 = &resp->nfs_resop4_u.opsetattr;
struct attrlist sattr;
cache_inode_status_t cache_status = CACHE_INODE_SUCCESS;
const char *tag = "SETATTR";
state_t *state_found = NULL;
state_t *state_open = NULL;
cache_entry_t *entry = NULL;
bool anonymous_started = false;
resp->resop = NFS4_OP_SETATTR;
res_SETATTR4->status = NFS4_OK;
/* Do basic checks on a filehandle */
res_SETATTR4->status = nfs4_sanity_check_FH(data, NO_FILE_TYPE, false);
if (res_SETATTR4->status != NFS4_OK)
return res_SETATTR4->status;
/* Don't allow attribute change while we are in grace period.
* Required for delegation reclaims and may be needed for other
* reclaimable states as well.
*/
if (nfs_in_grace()) {
res_SETATTR4->status = NFS4ERR_GRACE;
return res_SETATTR4->status;
}
/* Get only attributes that are allowed to be read */
if (!nfs4_Fattr_Check_Access
(&arg_SETATTR4->obj_attributes, FATTR4_ATTR_WRITE)) {
res_SETATTR4->status = NFS4ERR_INVAL;
return res_SETATTR4->status;
}
/* Ask only for supported attributes */
if (!nfs4_Fattr_Supported(&arg_SETATTR4->obj_attributes)) {
res_SETATTR4->status = NFS4ERR_ATTRNOTSUPP;
return res_SETATTR4->status;
}
/* Convert the fattr4 in the request to a fsal sattr structure */
res_SETATTR4->status =
nfs4_Fattr_To_FSAL_attr(&sattr,
&arg_SETATTR4->obj_attributes,
data);
if (res_SETATTR4->status != NFS4_OK)
return res_SETATTR4->status;
/* Trunc may change Xtime so we have to start with trunc and
* finish by the mtime and atime
*/
if ((FSAL_TEST_MASK(sattr.mask, ATTR_SIZE))
|| (FSAL_TEST_MASK(sattr.mask, ATTR4_SPACE_RESERVED))) {
/* Setting the size of a directory is prohibited */
if (data->current_filetype == DIRECTORY) {
res_SETATTR4->status = NFS4ERR_ISDIR;
return res_SETATTR4->status;
}
/* Object should be a file */
if (data->current_entry->type != REGULAR_FILE) {
res_SETATTR4->status = NFS4ERR_INVAL;
return res_SETATTR4->status;
}
entry = data->current_entry;
/* Check stateid correctness and get pointer to state */
res_SETATTR4->status =
nfs4_Check_Stateid(&arg_SETATTR4->stateid,
data->current_entry,
&state_found,
data,
STATEID_SPECIAL_ANY,
0,
false,
tag);
if (res_SETATTR4->status != NFS4_OK)
return res_SETATTR4->status;
/* NB: After this point, if state_found == NULL, then
* the stateid is all-0 or all-1
*/
if (state_found != NULL) {
switch (state_found->state_type) {
case STATE_TYPE_SHARE:
state_open = state_found;
/* Note this causes an extra refcount, but it
* simplifies logic below.
*/
inc_state_t_ref(state_open);
break;
case STATE_TYPE_LOCK:
state_open =
state_found->state_data.lock.openstate;
inc_state_t_ref(state_open);
break;
case STATE_TYPE_DELEG:
state_open = NULL;
break;
default:
res_SETATTR4->status = NFS4ERR_BAD_STATEID;
return res_SETATTR4->status;
}
/* This is a size operation, this means that
* the file MUST have been opened for writing
*/
if (state_open != NULL &&
(state_open->state_data.share.share_access &
OPEN4_SHARE_ACCESS_WRITE) == 0) {
/* Bad open mode, return NFS4ERR_OPENMODE */
res_SETATTR4->status = NFS4ERR_OPENMODE;
return res_SETATTR4->status;
}
} else {
/* Special stateid, no open state, check to
* see if any share conflicts
*/
state_open = NULL;
/* Special stateid, no open state, check to see if
* any share conflicts The stateid is all-0 or all-1
*/
res_SETATTR4->status = nfs4_Errno_state(
state_share_anonymous_io_start(
entry,
OPEN4_SHARE_ACCESS_WRITE,
SHARE_BYPASS_NONE));
if (res_SETATTR4->status != NFS4_OK)
return res_SETATTR4->status;
anonymous_started = true;
}
}
const time_t S_NSECS = 1000000000UL;
/* Set the atime and mtime (ctime is not setable) */
/* A carry into seconds considered invalid */
if (sattr.atime.tv_nsec >= S_NSECS) {
res_SETATTR4->status = NFS4ERR_INVAL;
goto done;
}
if (sattr.mtime.tv_nsec >= S_NSECS) {
res_SETATTR4->status = NFS4ERR_INVAL;
goto done;
}
/* If owner or owner_group are set, and the credential was
* squashed, then we must squash the set owner and owner_group.
*/
squash_setattr(&sattr);
/* If a SETATTR comes with an open stateid, and size is being
* set, then the open MUST be for write (checked above), so
* is_open_write is simple at this stage, it's just a check that
* we have an open owner.
*/
cache_status = cache_inode_setattr(data->current_entry,
&sattr,
state_open != NULL);
if (cache_status != CACHE_INODE_SUCCESS) {
res_SETATTR4->status = nfs4_Errno(cache_status);
goto done;
}
/* Set the replyed structure */
res_SETATTR4->attrsset = arg_SETATTR4->obj_attributes.attrmask;
/* Exit with no error */
res_SETATTR4->status = NFS4_OK;
done:
if (anonymous_started)
state_share_anonymous_io_done(entry, OPEN4_SHARE_ACCESS_WRITE);
if (state_found != NULL)
dec_state_t_ref(state_found);
if (state_open != NULL)
dec_state_t_ref(state_open);
return res_SETATTR4->status;
} /* nfs4_op_setattr */
static nfsstat4 acquire_layout_state(compound_data_t *data,
stateid4 *supplied_stateid,
layouttype4 layout_type,
state_t **layout_state, const char *tag)
{
/* State associated with the client-supplied stateid */
state_t *supplied_state = NULL;
/* State owner for per-clientid states */
state_owner_t *clientid_owner = NULL;
/* Return from this function */
nfsstat4 nfs_status = 0;
/* Return from state functions */
state_status_t state_status = 0;
/* Layout state, forgotten about by caller */
state_t *condemned_state = NULL;
/* Tracking data for the layout state */
struct state_refer refer;
memcpy(refer.session, data->session->session_id, sizeof(sessionid4));
refer.sequence = data->sequence;
refer.slot = data->slot;
clientid_owner = &data->session->clientid_record->cid_owner;
/* Retrieve state corresponding to supplied ID, inspect it
* and, if necessary, create a new layout state
*/
nfs_status = nfs4_Check_Stateid(supplied_stateid,
data->current_entry,
&supplied_state,
data,
STATEID_SPECIAL_CURRENT,
0,
false,
tag);
if (nfs_status != NFS4_OK)
goto out;
if (supplied_state->state_type == STATE_TYPE_LAYOUT) {
/* If the state supplied is a layout state, we can
* simply use it */
*layout_state = supplied_state;
} else if ((supplied_state->state_type == STATE_TYPE_SHARE)
|| (supplied_state->state_type == STATE_TYPE_DELEG)
|| (supplied_state->state_type == STATE_TYPE_LOCK)) {
/* For share, delegation, and lock states, create a
new layout state. */
state_data_t layout_data;
memset(&layout_data, 0, sizeof(state_data_t));
/* See if a layout state already exists */
state_status =
state_lookup_layout_state(data->current_entry,
clientid_owner,
layout_type,
&condemned_state);
/* If it does, we assume that the client is using the
* forgetful model and has forgotten it had any
* layouts. Free all layouts associated with the
* state and delete it.
*/
if (state_status == STATE_SUCCESS) {
/* Flag indicating whether all layouts were returned
* and the state was deleted
*/
bool deleted = false;
struct pnfs_segment entire = {
.io_mode = LAYOUTIOMODE4_ANY,
.offset = 0,
.length = NFS4_UINT64_MAX
};
if (condemned_state->state_data.layout.granting) {
nfs_status = NFS4ERR_DELAY;
goto out;
}
nfs_status =
nfs4_return_one_state(data->current_entry,
0,
circumstance_forgotten,
condemned_state,
entire,
0,
NULL,
&deleted,
false);
if (nfs_status != NFS4_OK)
goto out;
if (!deleted) {
nfs_status = NFS4ERR_SERVERFAULT;
goto out;
}
condemned_state = NULL;
} else if (state_status != STATE_NOT_FOUND) {
int nfs41_op_locku(struct nfs_argop4 *op, compound_data_t * data, struct nfs_resop4 *resp)
{
char __attribute__ ((__unused__)) funcname[] = "nfs41_op_locku";
cache_inode_status_t cache_status;
cache_inode_state_t *pstate_found = NULL;
cache_inode_state_t *pstate_open = NULL;
unsigned int rc = 0;
/* Lock are not supported */
resp->resop = NFS4_OP_LOCKU;
#ifdef _WITH_NO_NFSV4_LOCKS
res_LOCKU4.status = NFS4ERR_LOCK_NOTSUPP;
return res_LOCKU4.status;
#else
/* If there is no FH */
if(nfs4_Is_Fh_Empty(&(data->currentFH)))
{
res_LOCKU4.status = NFS4ERR_NOFILEHANDLE;
return res_LOCKU4.status;
}
/* If the filehandle is invalid */
if(nfs4_Is_Fh_Invalid(&(data->currentFH)))
{
res_LOCKU4.status = NFS4ERR_BADHANDLE;
return res_LOCKU4.status;
}
/* Tests if the Filehandle is expired (for volatile filehandle) */
if(nfs4_Is_Fh_Expired(&(data->currentFH)))
{
res_LOCKU4.status = NFS4ERR_FHEXPIRED;
return res_LOCKU4.status;
}
/* Commit is done only on a file */
if(data->current_filetype != REGULAR_FILE)
{
/* Type of the entry is not correct */
switch (data->current_filetype)
{
case DIR_BEGINNING:
case DIR_CONTINUE:
res_LOCKU4.status = NFS4ERR_ISDIR;
break;
default:
res_LOCKU4.status = NFS4ERR_INVAL;
break;
}
}
/* Lock length should not be 0 */
if(arg_LOCKU4.length == 0LL)
{
res_LOCKU4.status = NFS4ERR_INVAL;
return res_LOCKU4.status;
}
/* Check for range overflow
* Remember that a length with all bits set to 1 means "lock until the end of file" (RFC3530, page 157) */
if(arg_LOCKU4.length != 0xffffffffffffffffLL)
{
/* Comparing beyond 2^64 is not possible int 64 bits precision, but off+len > 2^64 is equivalent to len > 2^64 - off */
if(arg_LOCKU4.length > (0xffffffffffffffffLL - arg_LOCKU4.offset))
{
res_LOCKU4.status = NFS4ERR_INVAL;
return res_LOCKU4.status;
}
}
/* Check for correctness of the provided stateid */
if((rc = nfs4_Check_Stateid(&arg_LOCKU4.lock_stateid,
data->current_entry, data->psession->clientid)) != NFS4_OK)
{
res_LOCKU4.status = rc;
return res_LOCKU4.status;
}
/* Get the related state */
if(cache_inode_get_state(arg_LOCKU4.lock_stateid.other,
&pstate_found,
data->pclient, &cache_status) != CACHE_INODE_SUCCESS)
{
if(cache_status == CACHE_INODE_NOT_FOUND)
res_LOCKU4.status = NFS4ERR_LOCK_RANGE;
else
res_LOCKU4.status = nfs4_Errno(cache_status);
return res_LOCKU4.status;
}
pstate_open = (cache_inode_state_t *) (pstate_found->state_data.lock.popenstate);
memcpy(res_LOCKU4.LOCKU4res_u.lock_stateid.other, pstate_found->stateid_other, 12);
/* update the lock counter in the related open-stateid */
pstate_open->state_data.share.lockheld -= 1;
/* Remove the state associated with the lock */
if(cache_inode_del_state(pstate_found,
data->pclient, &cache_status) != CACHE_INODE_SUCCESS)
{
res_LOCKU4.status = nfs4_Errno(cache_status);
return res_LOCKU4.status;
}
/* Successful exit */
res_LOCKU4.status = NFS4_OK;
return res_LOCKU4.status;
#endif
} /* nfs41_op_locku */
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 */
int nfs41_op_layoutget(struct nfs_argop4 *op, compound_data_t * data,
struct nfs_resop4 *resp)
{
#ifdef _USE_PNFS
cache_inode_state_data_t candidate_data;
cache_inode_state_type_t candidate_type;
cache_inode_state_t *file_state = NULL;
cache_inode_status_t cache_status;
cache_inode_state_t *pstate_exists = NULL;
int rc;
#endif
char __attribute__ ((__unused__)) funcname[] = "nfs41_op_layoutget";
#ifndef _USE_PNFS
resp->resop = NFS4_OP_LAYOUTGET;
res_LAYOUTGET4.logr_status = NFS4ERR_NOTSUPP;
return res_LAYOUTGET4.logr_status;
#else
char *buff = NULL;
unsigned int lenbuff = 0;
/* Lock are not supported */
resp->resop = NFS4_OP_LAYOUTGET;
if((buff = Mem_Alloc(1024)) == NULL)
{
res_LAYOUTGET4.logr_status = NFS4ERR_SERVERFAULT;
return res_LAYOUTGET4.logr_status;
}
/* Lock are not supported */
resp->resop = NFS4_OP_LAYOUTGET;
if((buff = Mem_Alloc(1024)) == NULL)
{
res_LAYOUTGET4.logr_status = NFS4ERR_SERVERFAULT;
return res_LAYOUTGET4.logr_status;
}
/* If there is no FH */
if(nfs4_Is_Fh_Empty(&(data->currentFH)))
{
res_LAYOUTGET4.logr_status = NFS4ERR_NOFILEHANDLE;
return res_LAYOUTGET4.logr_status;
}
/* If the filehandle is invalid */
if(nfs4_Is_Fh_Invalid(&(data->currentFH)))
{
res_LAYOUTGET4.logr_status = NFS4ERR_BADHANDLE;
return res_LAYOUTGET4.logr_status;
}
/* Tests if the Filehandle is expired (for volatile filehandle) */
if(nfs4_Is_Fh_Expired(&(data->currentFH)))
{
res_LAYOUTGET4.logr_status = NFS4ERR_FHEXPIRED;
return res_LAYOUTGET4.logr_status;
}
/* Commit is done only on a file */
if(data->current_filetype != REGULAR_FILE)
{
/* Type of the entry is not correct */
switch (data->current_filetype)
{
case DIR_BEGINNING:
case DIR_CONTINUE:
res_LAYOUTGET4.logr_status = NFS4ERR_ISDIR;
break;
default:
res_LAYOUTGET4.logr_status = NFS4ERR_INVAL;
break;
}
return res_LAYOUTGET4.logr_status;
}
/* Parameters's consistency */
if(arg_LAYOUTGET4.loga_length < arg_LAYOUTGET4.loga_minlength)
{
res_LAYOUTGET4.logr_status = NFS4ERR_INVAL;
return res_LAYOUTGET4.logr_status;
}
/* Check stateid correctness and get pointer to state */
if((rc = nfs4_Check_Stateid(&arg_LAYOUTGET4.loga_stateid,
data->current_entry,
data->psession->clientid,
&pstate_exists,
data,
STATEID_SPECIAL_FOR_LOCK,
"LAYOUTGET")) != NFS4_OK)
{
res_LAYOUTGET4.logr_status = rc;
return res_LAYOUTGET4.logr_status;
}
/* For the moment, only LAYOUT4_FILE is supported */
switch (arg_LAYOUTGET4.loga_layout_type)
{
case LAYOUT4_NFSV4_1_FILES:
/* Continue on proceeding the request */
break;
default:
res_LAYOUTGET4.logr_status = NFS4ERR_NOTSUPP;
return res_LAYOUTGET4.logr_status;
break;
} /* switch( arg_LAYOUTGET4.loga_layout_type ) */
/* Add a pstate */
candidate_type = CACHE_INODE_STATE_LAYOUT;
#if 0
candidate_data.layout.layout_type = arg_LAYOUTGET4.loga_layout_type;
candidate_data.layout.iomode = arg_LAYOUTGET4.loga_iomode;
candidate_data.layout.offset = arg_LAYOUTGET4.loga_offset;
candidate_data.layout.length = arg_LAYOUTGET4.loga_length;
candidate_data.layout.minlength = arg_LAYOUTGET4.loga_minlength;
#endif
/* Add the layout state to the table */
if(state_add(data->current_entry,
candidate_type,
&candidate_data,
pstate_exists->powner,
data->pclient,
data->pcontext,
&file_state, &cache_status) != CACHE_INODE_SUCCESS)
{
res_LAYOUTGET4.logr_status = NFS4ERR_STALE_STATEID;
return res_LAYOUTGET4.logr_status;
}
/* set the returned status */
/* No return on close for the moment */
res_LAYOUTGET4.LAYOUTGET4res_u.logr_resok4.logr_return_on_close = FALSE;
/* Manages the stateid */
res_LAYOUTGET4.LAYOUTGET4res_u.logr_resok4.logr_stateid.seqid = 1;
memcpy(res_LAYOUTGET4.LAYOUTGET4res_u.logr_resok4.logr_stateid.other,
arg_LAYOUTGET4.loga_stateid.other, OTHERSIZE);
//file_state->stateid_other, OTHERSIZE);
/* Now the layout specific information */
res_LAYOUTGET4.LAYOUTGET4res_u.logr_resok4.logr_layout.logr_layout_len = 1; /** @todo manages more than one segment */
res_LAYOUTGET4.LAYOUTGET4res_u.logr_resok4.logr_layout.logr_layout_val =
(layout4 *) Mem_Alloc(sizeof(layout4));
res_LAYOUTGET4.LAYOUTGET4res_u.logr_resok4.logr_layout.logr_layout_val[0].lo_offset =
arg_LAYOUTGET4.loga_offset;
res_LAYOUTGET4.LAYOUTGET4res_u.logr_resok4.logr_layout.logr_layout_val[0].lo_length = 0xFFFFFFFFFFFFFFFFLL; /* Whole file */
res_LAYOUTGET4.LAYOUTGET4res_u.logr_resok4.logr_layout.logr_layout_val[0].lo_iomode =
arg_LAYOUTGET4.loga_iomode;
res_LAYOUTGET4.LAYOUTGET4res_u.logr_resok4.logr_layout.logr_layout_val[0].
lo_content.loc_type = LAYOUT4_NFSV4_1_FILES;
res_LAYOUTGET4.LAYOUTGET4res_u.logr_resok4.logr_layout.logr_layout_val[0].
lo_content.loc_body.loc_body_len = 1024 ;
res_LAYOUTGET4.LAYOUTGET4res_u.logr_resok4.logr_layout.logr_layout_val[0].
lo_content.loc_body.loc_body_val = buff;
if( ( rc = pnfs_layoutget( &arg_LAYOUTGET4, data, &res_LAYOUTGET4 ) ) != NFS4_OK )
{
res_LAYOUTGET4.logr_status = rc ;
return res_LAYOUTGET4.logr_status;
}
res_LAYOUTGET4.logr_status = NFS4_OK;
return res_LAYOUTGET4.logr_status;
#endif /* _USE_PNFS */
} /* nfs41_op_layoutget */
int nfs4_op_locku(struct nfs_argop4 *op, compound_data_t * data, struct nfs_resop4 *resp)
{
#ifndef _WITH_NFSV4_LOCKS
resp->resop = NFS4_OP_LOCKU;
res_LOCKU4.status = NFS4ERR_LOCK_NOTSUPP;
return res_LOCKU4.status;
#else
char __attribute__ ((__unused__)) funcname[] = "nfs4_op_locku";
state_status_t state_status;
state_t * pstate_found = NULL;
state_owner_t * plock_owner;
state_lock_desc_t lock_desc;
unsigned int rc = 0;
const char * tag = "LOCKU";
LogDebug(COMPONENT_NFS_V4_LOCK,
"Entering NFS v4 LOCKU handler -----------------------------------------------------");
/* Initialize to sane default */
resp->resop = NFS4_OP_LOCKU;
/* If there is no FH */
if(nfs4_Is_Fh_Empty(&(data->currentFH)))
{
res_LOCKU4.status = NFS4ERR_NOFILEHANDLE;
return res_LOCKU4.status;
}
/* If the filehandle is invalid */
if(nfs4_Is_Fh_Invalid(&(data->currentFH)))
{
res_LOCKU4.status = NFS4ERR_BADHANDLE;
return res_LOCKU4.status;
}
/* Tests if the Filehandle is expired (for volatile filehandle) */
if(nfs4_Is_Fh_Expired(&(data->currentFH)))
{
res_LOCKU4.status = NFS4ERR_FHEXPIRED;
return res_LOCKU4.status;
}
/* LOCKU 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_LOCKU4.status = NFS4ERR_ISDIR;
return res_LOCKU4.status;
default:
res_LOCKU4.status = NFS4ERR_INVAL;
return res_LOCKU4.status;
}
}
/* Convert lock parameters to internal types */
switch(arg_LOCKU4.locktype)
{
case READ_LT:
case READW_LT:
lock_desc.sld_type = STATE_LOCK_R;
break;
case WRITE_LT:
case WRITEW_LT:
lock_desc.sld_type = STATE_LOCK_W;
break;
}
lock_desc.sld_offset = arg_LOCKU4.offset;
if(arg_LOCKU4.length != STATE_LOCK_OFFSET_EOF)
lock_desc.sld_length = arg_LOCKU4.length;
else
lock_desc.sld_length = 0;
/* Check stateid correctness and get pointer to state */
if((rc = nfs4_Check_Stateid(&arg_LOCKU4.lock_stateid,
data->current_entry,
0LL,
&pstate_found,
data,
STATEID_SPECIAL_FOR_LOCK,
tag)) != NFS4_OK)
{
res_LOCKU4.status = rc;
return res_LOCKU4.status;
}
plock_owner = pstate_found->state_powner;
/* Check seqid (lock_seqid or open_seqid) */
if(!Check_nfs4_seqid(plock_owner,
arg_LOCKU4.seqid,
op,
data,
resp,
tag))
{
/* Response is all setup for us and LogDebug told what was wrong */
return res_LOCKU4.status;
}
/* Lock length should not be 0 */
if(arg_LOCKU4.length == 0LL)
{
res_LOCKU4.status = NFS4ERR_INVAL;
/* Save the response in the lock owner */
Copy_nfs4_state_req(plock_owner, arg_LOCKU4.seqid, op, data, resp, tag);
return res_LOCKU4.status;
}
/* Check for range overflow
* Remember that a length with all bits set to 1 means "lock until the end of file" (RFC3530, page 157) */
if(lock_desc.sld_length > (STATE_LOCK_OFFSET_EOF - lock_desc.sld_offset))
{
res_LOCKU4.status = NFS4ERR_INVAL;
/* Save the response in the lock owner */
Copy_nfs4_state_req(plock_owner, arg_LOCKU4.seqid, op, data, resp, tag);
return res_LOCKU4.status;
}
LogLock(COMPONENT_NFS_V4_LOCK, NIV_FULL_DEBUG,
tag,
data->current_entry,
data->pcontext,
plock_owner,
&lock_desc);
/* Now we have a lock owner and a stateid.
* Go ahead and push unlock into SAL (and FSAL).
*/
if(state_unlock(data->current_entry,
data->pcontext,
plock_owner,
pstate_found,
&lock_desc,
data->pclient,
&state_status) != STATE_SUCCESS)
{
res_LOCKU4.status = nfs4_Errno_state(state_status);
/* Save the response in the lock owner */
Copy_nfs4_state_req(plock_owner, arg_LOCKU4.seqid, op, data, resp, tag);
return res_LOCKU4.status;
}
/* Successful exit */
res_LOCKU4.status = NFS4_OK;
/* Handle stateid/seqid for success */
update_stateid(pstate_found,
&res_LOCKU4.LOCKU4res_u.lock_stateid,
data,
tag);
/* Save the response in the lock owner */
Copy_nfs4_state_req(plock_owner, arg_LOCKU4.seqid, op, data, resp, tag);
return res_LOCKU4.status;
#endif
} /* nfs4_op_locku */
int nfs4_op_close(struct nfs_argop4 *op, compound_data_t * data, struct nfs_resop4 *resp)
{
int rc = 0;
char __attribute__ ((__unused__)) funcname[] = "nfs4_op_close";
cache_inode_state_t *pstate_found = NULL;
cache_inode_status_t cache_status;
memset(&res_CLOSE4, 0, sizeof(res_CLOSE4));
resp->resop = NFS4_OP_CLOSE;
/* If the filehandle is Empty */
if(nfs4_Is_Fh_Empty(&(data->currentFH)))
{
res_CLOSE4.status = NFS4ERR_NOFILEHANDLE;
return res_CLOSE4.status;
}
/* If the filehandle is invalid */
if(nfs4_Is_Fh_Invalid(&(data->currentFH)))
{
res_CLOSE4.status = NFS4ERR_BADHANDLE;
return res_CLOSE4.status;
}
/* Tests if the Filehandle is expired (for volatile filehandle) */
if(nfs4_Is_Fh_Expired(&(data->currentFH)))
{
res_CLOSE4.status = NFS4ERR_FHEXPIRED;
return res_CLOSE4.status;
}
if(data->current_entry == NULL)
{
res_CLOSE4.status = NFS4ERR_SERVERFAULT;
return res_CLOSE4.status;
}
/* Should not operate on directories */
if(data->current_entry->internal_md.type == DIR_BEGINNING ||
data->current_entry->internal_md.type == DIR_CONTINUE)
{
res_CLOSE4.status = NFS4ERR_ISDIR;
return res_CLOSE4.status;
}
/* Object should be a file */
if(data->current_entry->internal_md.type != REGULAR_FILE)
{
res_CLOSE4.status = NFS4ERR_INVAL;
return res_CLOSE4.status;
}
/* Does the stateid match ? */
if((rc =
nfs4_Check_Stateid(&arg_CLOSE4.open_stateid, data->current_entry, 0LL)) != NFS4_OK)
{
res_CLOSE4.status = rc;
return res_CLOSE4.status;
}
/* Get the related state */
if(cache_inode_get_state(arg_CLOSE4.open_stateid.other,
&pstate_found,
data->pclient, &cache_status) != CACHE_INODE_SUCCESS)
{
if(cache_status == CACHE_INODE_NOT_FOUND)
res_CLOSE4.status = NFS4ERR_BAD_STATEID;
else
res_CLOSE4.status = NFS4ERR_INVAL;
return res_CLOSE4.status;
}
/* Check is held locks remain */
if(pstate_found->state_data.share.lockheld > 0)
{
res_CLOSE4.status = NFS4ERR_LOCKS_HELD;
return res_CLOSE4.status;
}
/* Update the seqid for the open_owner */
P(pstate_found->powner->lock);
pstate_found->powner->seqid += 1;
V(pstate_found->powner->lock);
/* Prepare the result */
res_CLOSE4.CLOSE4res_u.open_stateid.seqid = pstate_found->seqid + 1;
/* File is closed, release the corresponding state */
if(cache_inode_del_state_by_key(arg_CLOSE4.open_stateid.other,
data->pclient, &cache_status) != CACHE_INODE_SUCCESS)
{
res_CLOSE4.status = nfs4_Errno(cache_status);
return res_CLOSE4.status;
}
memcpy(res_CLOSE4.CLOSE4res_u.open_stateid.other, arg_CLOSE4.open_stateid.other, 12);;
/* Close the file in FSAL through the cache inode */
P_w(&data->current_entry->lock);
if(cache_inode_close(data->current_entry,
data->pclient, &cache_status) != CACHE_INODE_SUCCESS)
{
V_w(&data->current_entry->lock);
res_CLOSE4.status = nfs4_Errno(cache_status);
return res_CLOSE4.status;
}
V_w(&data->current_entry->lock);
res_CLOSE4.status = NFS4_OK;
return NFS4_OK;
} /* nfs4_op_close */
int nfs4_op_open_downgrade(struct nfs_argop4 *op, compound_data_t *data,
struct nfs_resop4 *resp)
{
OPEN_DOWNGRADE4args * const arg_OPEN_DOWNGRADE4 =
&op->nfs_argop4_u.opopen_downgrade;
OPEN_DOWNGRADE4res * const res_OPEN_DOWNGRADE4 =
&resp->nfs_resop4_u.opopen_downgrade;
OPEN_DOWNGRADE4resok *resok =
&res_OPEN_DOWNGRADE4->OPEN_DOWNGRADE4res_u.resok4;
state_t *state_found = NULL;
state_owner_t *open_owner;
int rc;
const char *tag = "OPEN_DOWNGRADE";
char *cause = "";
resp->resop = NFS4_OP_OPEN_DOWNGRADE;
res_OPEN_DOWNGRADE4->status = NFS4_OK;
/* Do basic checks on a filehandle */
res_OPEN_DOWNGRADE4->status =
nfs4_sanity_check_FH(data, NO_FILE_TYPE, false);
if (res_OPEN_DOWNGRADE4->status != NFS4_OK)
return res_OPEN_DOWNGRADE4->status;
/* Open downgrade is done only on a file */
if (data->current_filetype != REGULAR_FILE) {
res_OPEN_DOWNGRADE4->status = NFS4ERR_INVAL;
return res_OPEN_DOWNGRADE4->status;
}
/* Check stateid correctness and get pointer to state */
rc = nfs4_Check_Stateid(&arg_OPEN_DOWNGRADE4->open_stateid,
data->current_obj,
&state_found,
data,
STATEID_SPECIAL_FOR_LOCK,
arg_OPEN_DOWNGRADE4->seqid,
data->minorversion == 0,
tag);
if (rc != NFS4_OK && rc != NFS4ERR_REPLAY) {
res_OPEN_DOWNGRADE4->status = rc;
LogDebug(COMPONENT_STATE,
"OPEN_DOWNGRADE failed nfs4_Check_Stateid");
return res_OPEN_DOWNGRADE4->status;
}
open_owner = get_state_owner_ref(state_found);
if (open_owner == NULL) {
/* Unexpected, but something just went stale. */
res_OPEN_DOWNGRADE4->status = NFS4ERR_STALE;
goto out2;
}
PTHREAD_MUTEX_lock(&open_owner->so_mutex);
/* Check seqid */
if (data->minorversion == 0 &&
!Check_nfs4_seqid(open_owner,
arg_OPEN_DOWNGRADE4->seqid,
op,
data->current_obj,
resp,
tag)) {
/* Response is all setup for us and LogDebug told what was wrong
*/
PTHREAD_MUTEX_unlock(&open_owner->so_mutex);
goto out;
}
PTHREAD_MUTEX_unlock(&open_owner->so_mutex);
/* What kind of open is it ? */
LogFullDebug(COMPONENT_STATE,
"OPEN_DOWNGRADE: Share Deny = %d Share Access = %d ",
arg_OPEN_DOWNGRADE4->share_deny,
arg_OPEN_DOWNGRADE4->share_access);
res_OPEN_DOWNGRADE4->status = nfs4_do_open_downgrade(op,
data,
open_owner,
state_found,
&cause);
if (res_OPEN_DOWNGRADE4->status != NFS4_OK) {
LogEvent(COMPONENT_STATE,
"Failed to open downgrade: %s",
cause);
goto out;
}
/* Successful exit */
res_OPEN_DOWNGRADE4->status = NFS4_OK;
/* Handle stateid/seqid for success */
update_stateid(state_found, &resok->open_stateid, data, tag);
/* Save the response in the open owner */
if (data->minorversion == 0) {
Copy_nfs4_state_req(open_owner,
arg_OPEN_DOWNGRADE4->seqid,
op,
data->current_obj,
resp,
tag);
}
out:
dec_state_owner_ref(open_owner);
out2:
dec_state_t_ref(state_found);
return res_OPEN_DOWNGRADE4->status;
} /* nfs4_op_opendowngrade */
int nfs4_op_seek(struct nfs_argop4 *op, compound_data_t *data,
struct nfs_resop4 *resp)
{
SEEK4args * const arg_SEEK = &op->nfs_argop4_u.opseek;
SEEK4res * const res_SEEK = &resp->nfs_resop4_u.opseek;
fsal_status_t fsal_status = { 0, 0 };
state_t *state_found = NULL;
struct fsal_obj_handle *obj = NULL;
struct io_info info;
/* Say we are managing NFS4_OP_SEEK */
resp->resop = NFS4_OP_SEEK;
if (data->minorversion < 2) {
res_SEEK->sr_status = NFS4ERR_NOTSUPP;
goto done;
}
res_SEEK->sr_status = NFS4_OK;
/* Do basic checks on a filehandle Only files can be set */
res_SEEK->sr_status = nfs4_sanity_check_FH(data, REGULAR_FILE, true);
if (res_SEEK->sr_status != NFS4_OK)
goto done;
obj = data->current_obj;
/* Check stateid correctness and get pointer to state (also
checks for special stateids) */
res_SEEK->sr_status =
nfs4_Check_Stateid(&arg_SEEK->sa_stateid, obj,
&state_found, data, STATEID_SPECIAL_ANY,
0, false, "SEEK");
if (res_SEEK->sr_status != NFS4_OK)
goto done;
if (state_found != NULL) {
info.io_advise = state_found->state_data.io_advise;
info.io_content.what = arg_SEEK->sa_what;
if (arg_SEEK->sa_what == NFS4_CONTENT_DATA ||
arg_SEEK->sa_what == NFS4_CONTENT_HOLE) {
info.io_content.hole.di_offset = arg_SEEK->sa_offset;
}
else
info.io_content.adb.adb_offset = arg_SEEK->sa_offset;
fsal_status = obj->obj_ops.seek(obj, &info);
if (FSAL_IS_ERROR(fsal_status)) {
res_SEEK->sr_status = NFS4ERR_NXIO;
goto done;
}
res_SEEK->sr_resok4.sr_eof = info.io_eof;
res_SEEK->sr_resok4.sr_offset = info.io_content.hole.di_offset;
}
done:
LogDebug(COMPONENT_NFS_V4,
"Status %s type %d offset %" PRIu64,
nfsstat4_to_str(res_SEEK->sr_status), arg_SEEK->sa_what,
arg_SEEK->sa_offset);
if (state_found != NULL)
dec_state_t_ref(state_found);
return res_SEEK->sr_status;
}
int nfs4_op_open_confirm(struct nfs_argop4 *op,
compound_data_t * data, struct nfs_resop4 *resp)
{
char __attribute__ ((__unused__)) funcname[] = "nfs4_op_open_confirm";
int rc = 0;
cache_inode_state_t *pstate_found = NULL;
cache_inode_status_t cache_status;
resp->resop = NFS4_OP_OPEN_CONFIRM;
res_OPEN_CONFIRM4.status = NFS4_OK;
/* If there is no FH */
if(nfs4_Is_Fh_Empty(&(data->currentFH)))
{
res_OPEN_CONFIRM4.status = NFS4ERR_NOFILEHANDLE;
return res_OPEN_CONFIRM4.status;
}
/* If the filehandle is invalid */
if(nfs4_Is_Fh_Invalid(&(data->currentFH)))
{
res_OPEN_CONFIRM4.status = NFS4ERR_BADHANDLE;
return res_OPEN_CONFIRM4.status;
}
/* Tests if the Filehandle is expired (for volatile filehandle) */
if(nfs4_Is_Fh_Expired(&(data->currentFH)))
{
res_OPEN_CONFIRM4.status = NFS4ERR_FHEXPIRED;
return res_OPEN_CONFIRM4.status;
}
/* Should not operate on non-file objects */
if(data->current_entry->internal_md.type != REGULAR_FILE)
{
switch (data->current_entry->internal_md.type)
{
case DIR_BEGINNING:
case DIR_CONTINUE:
res_OPEN_CONFIRM4.status = NFS4ERR_ISDIR;
return res_OPEN_CONFIRM4.status;
break;
default:
res_OPEN_CONFIRM4.status = NFS4ERR_INVAL;
return res_OPEN_CONFIRM4.status;
break;
}
}
/* Does the stateid match ? */
if((rc =
nfs4_Check_Stateid(&arg_OPEN_CONFIRM4.open_stateid, data->current_entry,
0LL)) != NFS4_OK)
{
res_OPEN_CONFIRM4.status = rc;
return res_OPEN_CONFIRM4.status;
}
/* Get the related state */
if(cache_inode_get_state(arg_OPEN_CONFIRM4.open_stateid.other,
&pstate_found,
data->pclient, &cache_status) != CACHE_INODE_SUCCESS)
{
res_OPEN_CONFIRM4.status = nfs4_Errno(cache_status);
return res_OPEN_CONFIRM4.status;
}
/* If opened file is already confirmed, retrun NFS4ERR_BAD_STATEID */
P(pstate_found->powner->lock);
if(pstate_found->powner->confirmed == TRUE)
{
V(pstate_found->powner->lock);
res_OPEN_CONFIRM4.status = NFS4ERR_BAD_STATEID;
return res_OPEN_CONFIRM4.status;
}
if(pstate_found->powner->seqid != arg_OPEN_CONFIRM4.seqid)
{
if(pstate_found->powner->seqid + 1 != arg_OPEN_CONFIRM4.seqid)
{
V(pstate_found->powner->lock);
res_OPEN_CONFIRM4.status = NFS4ERR_BAD_SEQID;
return res_OPEN_CONFIRM4.status;
}
}
/* Set the state as confirmed */
pstate_found->powner->confirmed = TRUE;
pstate_found->powner->seqid += 1;
V(pstate_found->powner->lock);
/* Update the state */
pstate_found->seqid += 1;
if(cache_inode_update_state(pstate_found,
data->pclient, &cache_status) != CACHE_INODE_SUCCESS)
{
res_OPEN_CONFIRM4.status = nfs4_Errno(cache_status);
return res_OPEN_CONFIRM4.status;
}
/* Return the stateid to the client */
res_OPEN_CONFIRM4.OPEN_CONFIRM4res_u.resok4.open_stateid.seqid =
arg_OPEN_CONFIRM4.seqid;
memcpy(res_OPEN_CONFIRM4.OPEN_CONFIRM4res_u.resok4.open_stateid.other,
pstate_found->stateid_other, 12);
return res_OPEN_CONFIRM4.status;
} /* nfs4_op_open_confirm */
int nfs4_op_io_advise(struct nfs_argop4 *op, compound_data_t *data,
struct nfs_resop4 *resp)
{
IO_ADVISE4args * const arg_IO_ADVISE = &op->nfs_argop4_u.opio_advise;
IO_ADVISE4res * const res_IO_ADVISE = &resp->nfs_resop4_u.opio_advise;
fsal_status_t fsal_status = { 0, 0 };
struct io_hints hints;
state_t *state_found = NULL;
struct fsal_obj_handle *obj = NULL;
/* Say we are managing NFS4_OP_IO_ADVISE */
resp->resop = NFS4_OP_IO_ADVISE;
res_IO_ADVISE->iaa_status = NFS4_OK;
hints.hints = 0;
hints.offset = 0;
hints.count = 0;
if (data->minorversion < 2) {
res_IO_ADVISE->iaa_status = NFS4ERR_NOTSUPP;
goto done;
}
/* Do basic checks on a filehandle Only files can be set */
res_IO_ADVISE->iaa_status = nfs4_sanity_check_FH(data, REGULAR_FILE,
true);
if (res_IO_ADVISE->iaa_status != NFS4_OK)
goto done;
obj = data->current_obj;
/* Check stateid correctness and get pointer to state (also
checks for special stateids) */
res_IO_ADVISE->iaa_status =
nfs4_Check_Stateid(&arg_IO_ADVISE->iaa_stateid, obj,
&state_found, data, STATEID_SPECIAL_ANY,
0, false, "IO_ADVISE");
if (res_IO_ADVISE->iaa_status != NFS4_OK)
goto done;
if (state_found && obj) {
hints.hints = arg_IO_ADVISE->iaa_hints.map[0];
hints.offset = arg_IO_ADVISE->iaa_offset;
hints.count = arg_IO_ADVISE->iaa_count;
fsal_status = obj->obj_ops.io_advise(obj, &hints);
if (FSAL_IS_ERROR(fsal_status)) {
res_IO_ADVISE->iaa_status = NFS4ERR_NOTSUPP;
goto done;
}
/* save hints to use with other operations */
state_found->state_data.io_advise = hints.hints;
res_IO_ADVISE->iaa_status = NFS4_OK;
res_IO_ADVISE->iaa_hints.bitmap4_len = 1;
res_IO_ADVISE->iaa_hints.map[0] = hints.hints;
}
done:
LogDebug(COMPONENT_NFS_V4,
"Status %s hints 0x%X offset %" PRIu64 " count %" PRIu64,
nfsstat4_to_str(res_IO_ADVISE->iaa_status),
hints.hints, hints.offset, hints.count);
if (state_found != NULL)
dec_state_t_ref(state_found);
return res_IO_ADVISE->iaa_status;
} /* nfs4_op_io_advise */
static int nfs4_read(struct nfs_argop4 *op, compound_data_t *data,
struct nfs_resop4 *resp, fsal_io_direction_t io,
struct io_info *info)
{
READ4args * const arg_READ4 = &op->nfs_argop4_u.opread;
READ4res * const res_READ4 = &resp->nfs_resop4_u.opread;
uint64_t size = 0;
size_t read_size = 0;
uint64_t offset = 0;
bool eof_met = false;
void *bufferdata = NULL;
fsal_status_t fsal_status = {0, 0};
state_t *state_found = NULL;
state_t *state_open = NULL;
struct fsal_obj_handle *obj = NULL;
bool sync = false;
bool anonymous_started = false;
state_owner_t *owner = NULL;
bool bypass = false;
uint64_t MaxRead = atomic_fetch_uint64_t(&op_ctx->ctx_export->MaxRead);
uint64_t MaxOffsetRead =
atomic_fetch_uint64_t(
&op_ctx->ctx_export->MaxOffsetRead);
/* Say we are managing NFS4_OP_READ */
resp->resop = NFS4_OP_READ;
res_READ4->status = NFS4_OK;
/* Do basic checks on a filehandle Only files can be read */
if ((data->minorversion > 0)
&& nfs4_Is_Fh_DSHandle(&data->currentFH)) {
if (io == FSAL_IO_READ)
return op_dsread(op, data, resp);
else
return op_dsread_plus(op, data, resp, info);
}
res_READ4->status = nfs4_sanity_check_FH(data, REGULAR_FILE, true);
if (res_READ4->status != NFS4_OK)
return res_READ4->status;
obj = data->current_obj;
/* Check stateid correctness and get pointer to state (also
checks for special stateids) */
res_READ4->status =
nfs4_Check_Stateid(&arg_READ4->stateid, obj, &state_found, data,
STATEID_SPECIAL_ANY, 0, false, "READ");
if (res_READ4->status != NFS4_OK)
return res_READ4->status;
/* NB: After this point, if state_found == NULL, then the
stateid is all-0 or all-1 */
if (state_found != NULL) {
struct state_deleg *sdeleg;
if (info)
info->io_advise = state_found->state_data.io_advise;
switch (state_found->state_type) {
case STATE_TYPE_SHARE:
state_open = state_found;
/* Note this causes an extra refcount, but it
* simplifies logic below.
*/
inc_state_t_ref(state_open);
/**
* @todo FSF: need to check against existing locks
*/
break;
case STATE_TYPE_LOCK:
state_open = state_found->state_data.lock.openstate;
inc_state_t_ref(state_open);
/**
* @todo FSF: should check that write is in
* range of an byte range lock...
*/
break;
case STATE_TYPE_DELEG:
/* Check if the delegation state allows READ */
sdeleg = &state_found->state_data.deleg;
if (!(sdeleg->sd_type & OPEN_DELEGATE_READ) ||
(sdeleg->sd_state != DELEG_GRANTED)) {
/* Invalid delegation for this operation. */
LogDebug(COMPONENT_STATE,
"Delegation type:%d state:%d",
sdeleg->sd_type,
sdeleg->sd_state);
res_READ4->status = NFS4ERR_BAD_STATEID;
goto out;
}
state_open = NULL;
break;
default:
res_READ4->status = NFS4ERR_BAD_STATEID;
LogDebug(COMPONENT_NFS_V4_LOCK,
"READ with invalid statid of type %d",
state_found->state_type);
goto out;
}
/* This is a read operation, this means that the file
MUST have been opened for reading */
if (state_open != NULL
&& (state_open->state_data.share.
share_access & OPEN4_SHARE_ACCESS_READ) == 0) {
/* Even if file is open for write, the client
* may do accidently read operation (caching).
* Because of this, READ is allowed if not
* explicitly denied. See page 112 in RFC 7530
* for more details.
*/
if (state_open->state_data.share.
share_deny & OPEN4_SHARE_DENY_READ) {
/* Bad open mode, return NFS4ERR_OPENMODE */
res_READ4->status = NFS4ERR_OPENMODE;
if (isDebug(COMPONENT_NFS_V4_LOCK)) {
char str[LOG_BUFF_LEN] = "\0";
struct display_buffer dspbuf = {
sizeof(str), str, str};
display_stateid(&dspbuf, state_found);
LogDebug(COMPONENT_NFS_V4_LOCK,
"READ %s doesn't have OPEN4_SHARE_ACCESS_READ",
str);
}
goto out;
}
}
/**
* @todo : this piece of code looks a bit suspicious
* (see Rong's mail)
*
* @todo: ACE: This works for now. How do we want to
* handle owner confirmation across NFSv4.0/NFSv4.1?
* Do we want to mark every NFSv4.1 owner
* pre-confirmed, or make the check conditional on
* minorversion like we do here?
*/
switch (state_found->state_type) {
case STATE_TYPE_SHARE:
if (data->minorversion == 0 &&
!state_owner_confirmed(state_found)) {
res_READ4->status = NFS4ERR_BAD_STATEID;
goto out;
}
break;
case STATE_TYPE_LOCK:
case STATE_TYPE_DELEG:
break;
default:
/* Sanity check: all other types are illegal.
* we should not got that place (similar check
* above), anyway it costs nothing to add this
* test */
res_READ4->status = NFS4ERR_BAD_STATEID;
goto out;
}
} else {
/* Special stateid, no open state, check to see if any
share conflicts */
state_open = NULL;
/* Special stateid, no open state, check to see if any share
* conflicts The stateid is all-0 or all-1
*/
bypass = arg_READ4->stateid.seqid != 0;
res_READ4->status = nfs4_Errno_state(
state_share_anonymous_io_start(
obj,
OPEN4_SHARE_ACCESS_READ,
arg_READ4->stateid.seqid != 0
? SHARE_BYPASS_READ
: SHARE_BYPASS_NONE));
if (res_READ4->status != NFS4_OK)
goto out;
anonymous_started = true;
}
/* Need to permission check the read. */
fsal_status = obj->obj_ops.test_access(obj, FSAL_READ_ACCESS,
NULL, NULL, true);
if (fsal_status.major == ERR_FSAL_ACCESS) {
/* Test for execute permission */
fsal_status = fsal_access(obj,
FSAL_MODE_MASK_SET(FSAL_X_OK) |
FSAL_ACE4_MASK_SET
(FSAL_ACE_PERM_EXECUTE));
}
if (FSAL_IS_ERROR(fsal_status)) {
res_READ4->status = nfs4_Errno_status(fsal_status);
goto done;
}
/* Get the size and offset of the read operation */
offset = arg_READ4->offset;
size = arg_READ4->count;
if (MaxOffsetRead < UINT64_MAX) {
LogFullDebug(COMPONENT_NFS_V4,
"Read offset=%" PRIu64
" size=%" PRIu64 " MaxOffSet=%" PRIu64,
offset, size,
MaxOffsetRead);
if ((offset + size) > MaxOffsetRead) {
LogEvent(COMPONENT_NFS_V4,
"A client tryed to violate max file size %"
PRIu64 " for exportid #%hu",
MaxOffsetRead,
op_ctx->ctx_export->export_id);
res_READ4->status = NFS4ERR_FBIG;
goto done;
}
}
if (size > MaxRead) {
/* the client asked for too much data, this should normally
not happen because client will get FATTR4_MAXREAD value
at mount time */
if (info == NULL ||
info->io_content.what != NFS4_CONTENT_HOLE) {
LogFullDebug(COMPONENT_NFS_V4,
"read requested size = %"PRIu64
" read allowed size = %" PRIu64,
size, MaxRead);
size = MaxRead;
}
}
/* If size == 0, no I/O is to be made and everything is
alright */
if (size == 0) {
/* A size = 0 can not lead to EOF */
res_READ4->READ4res_u.resok4.eof = false;
res_READ4->READ4res_u.resok4.data.data_len = 0;
res_READ4->READ4res_u.resok4.data.data_val = NULL;
res_READ4->status = NFS4_OK;
goto done;
}
/* Some work is to be done */
bufferdata = gsh_malloc_aligned(4096, size);
if (!anonymous_started && data->minorversion == 0) {
owner = get_state_owner_ref(state_found);
if (owner != NULL) {
op_ctx->clientid =
&owner->so_owner.so_nfs4_owner.so_clientid;
}
}
if (obj->fsal->m_ops.support_ex(obj)) {
/* Call the new fsal_read2 */
fsal_status = fsal_read2(obj, bypass, state_found, offset, size,
&read_size, bufferdata, &eof_met,
info);
} else {
/* Call legacy fsal_rdwr */
fsal_status = fsal_rdwr(obj, io, offset, size, &read_size,
bufferdata, &eof_met, &sync, info);
}
if (FSAL_IS_ERROR(fsal_status)) {
res_READ4->status = nfs4_Errno_status(fsal_status);
gsh_free(bufferdata);
res_READ4->READ4res_u.resok4.data.data_val = NULL;
goto done;
}
if (!eof_met) {
/** @todo FSF: add a config option for this behavior?
*/
/* Need to check against filesize for ESXi clients */
struct attrlist attrs;
fsal_prepare_attrs(&attrs, ATTR_SIZE);
if (!FSAL_IS_ERROR(obj->obj_ops.getattrs(obj, &attrs)))
eof_met = (offset + read_size) >= attrs.filesize;
/* Done with the attrs */
fsal_release_attrs(&attrs);
}
if (!anonymous_started && data->minorversion == 0)
op_ctx->clientid = NULL;
res_READ4->READ4res_u.resok4.data.data_len = read_size;
res_READ4->READ4res_u.resok4.data.data_val = bufferdata;
LogFullDebug(COMPONENT_NFS_V4,
"NFS4_OP_READ: offset = %" PRIu64
" read length = %zu eof=%u", offset, read_size, eof_met);
/* Is EOF met or not ? */
res_READ4->READ4res_u.resok4.eof = eof_met;
/* Say it is ok */
res_READ4->status = NFS4_OK;
done:
if (anonymous_started)
state_share_anonymous_io_done(obj, OPEN4_SHARE_ACCESS_READ);
server_stats_io_done(size, read_size,
(res_READ4->status == NFS4_OK) ? true : false,
false);
out:
if (owner != NULL)
dec_state_owner_ref(owner);
if (state_found != NULL)
dec_state_t_ref(state_found);
if (state_open != NULL)
dec_state_t_ref(state_open);
return res_READ4->status;
} /* nfs4_op_read */
static int nfs4_write(struct nfs_argop4 *op, compound_data_t *data,
struct nfs_resop4 *resp, fsal_io_direction_t io,
struct io_info *info)
{
WRITE4args * const arg_WRITE4 = &op->nfs_argop4_u.opwrite;
WRITE4res * const res_WRITE4 = &resp->nfs_resop4_u.opwrite;
uint64_t size = 0;
size_t written_size = 0;
uint64_t offset;
bool eof_met;
bool sync = false;
void *bufferdata;
stable_how4 stable_how;
state_t *state_found = NULL;
state_t *state_open = NULL;
fsal_status_t fsal_status = {0, 0};
struct fsal_obj_handle *obj = NULL;
bool anonymous_started = false;
struct gsh_buffdesc verf_desc;
state_owner_t *owner = NULL;
uint64_t MaxWrite =
atomic_fetch_uint64_t(&op_ctx->ctx_export->MaxWrite);
uint64_t MaxOffsetWrite =
atomic_fetch_uint64_t(&op_ctx->ctx_export->MaxOffsetWrite);
/* Lock are not supported */
resp->resop = NFS4_OP_WRITE;
res_WRITE4->status = NFS4_OK;
if ((data->minorversion > 0)
&& (nfs4_Is_Fh_DSHandle(&data->currentFH))) {
if (io == FSAL_IO_WRITE)
return op_dswrite(op, data, resp);
else
return op_dswrite_plus(op, data, resp, info);
}
/*
* Do basic checks on a filehandle
* Only files can be written
*/
res_WRITE4->status = nfs4_sanity_check_FH(data, REGULAR_FILE, true);
if (res_WRITE4->status != NFS4_OK)
return res_WRITE4->status;
/* if quota support is active, then we should check is the FSAL
allows inode creation or not */
fsal_status = op_ctx->fsal_export->exp_ops.check_quota(
op_ctx->fsal_export,
op_ctx->ctx_export->fullpath,
FSAL_QUOTA_INODES);
if (FSAL_IS_ERROR(fsal_status)) {
res_WRITE4->status = NFS4ERR_DQUOT;
return res_WRITE4->status;
}
/* vnode to manage is the current one */
obj = data->current_obj;
/* Check stateid correctness and get pointer to state
* (also checks for special stateids)
*/
res_WRITE4->status = nfs4_Check_Stateid(&arg_WRITE4->stateid,
obj,
&state_found,
data,
STATEID_SPECIAL_ANY,
0,
false,
"WRITE");
if (res_WRITE4->status != NFS4_OK)
return res_WRITE4->status;
/* NB: After this points, if state_found == NULL, then
* the stateid is all-0 or all-1
*/
if (state_found != NULL) {
struct state_deleg *sdeleg;
if (info)
info->io_advise = state_found->state_data.io_advise;
switch (state_found->state_type) {
case STATE_TYPE_SHARE:
state_open = state_found;
/* Note this causes an extra refcount, but it
* simplifies logic below.
*/
inc_state_t_ref(state_open);
/** @todo FSF: need to check against existing locks */
break;
case STATE_TYPE_LOCK:
state_open = state_found->state_data.lock.openstate;
inc_state_t_ref(state_open);
/**
* @todo FSF: should check that write is in range of an
* exclusive lock...
*/
break;
case STATE_TYPE_DELEG:
/* Check if the delegation state allows READ */
sdeleg = &state_found->state_data.deleg;
if (!(sdeleg->sd_type & OPEN_DELEGATE_WRITE) ||
(sdeleg->sd_state != DELEG_GRANTED)) {
/* Invalid delegation for this operation. */
LogDebug(COMPONENT_STATE,
"Delegation type:%d state:%d",
sdeleg->sd_type,
sdeleg->sd_state);
res_WRITE4->status = NFS4ERR_BAD_STATEID;
return res_WRITE4->status;
}
state_open = NULL;
break;
case STATE_TYPE_LAYOUT:
state_open = NULL;
break;
default:
res_WRITE4->status = NFS4ERR_BAD_STATEID;
LogDebug(COMPONENT_NFS_V4_LOCK,
"WRITE with invalid stateid of type %d",
(int)state_found->state_type);
return res_WRITE4->status;
}
/* This is a write operation, this means that the file
* MUST have been opened for writing
*/
if (state_open != NULL &&
(state_open->state_data.share.share_access &
OPEN4_SHARE_ACCESS_WRITE) == 0) {
/* Bad open mode, return NFS4ERR_OPENMODE */
res_WRITE4->status = NFS4ERR_OPENMODE;
if (isDebug(COMPONENT_NFS_V4_LOCK)) {
char str[LOG_BUFF_LEN] = "\0";
struct display_buffer dspbuf = {
sizeof(str), str, str};
display_stateid(&dspbuf, state_found);
LogDebug(COMPONENT_NFS_V4_LOCK,
"WRITE %s doesn't have OPEN4_SHARE_ACCESS_WRITE",
str);
}
goto out;
}
} else {
/* Special stateid, no open state, check to see if any
* share conflicts
*/
state_open = NULL;
/* Special stateid, no open state, check to see if any share
* conflicts The stateid is all-0 or all-1
*/
res_WRITE4->status = nfs4_Errno_state(
state_share_anonymous_io_start(
obj,
OPEN4_SHARE_ACCESS_WRITE,
SHARE_BYPASS_NONE));
if (res_WRITE4->status != NFS4_OK)
goto out;
anonymous_started = true;
}
/* Need to permission check the write. */
fsal_status = obj->obj_ops.test_access(obj, FSAL_WRITE_ACCESS,
NULL, NULL, true);
if (FSAL_IS_ERROR(fsal_status)) {
res_WRITE4->status = nfs4_Errno_status(fsal_status);
goto done;
}
/* Get the characteristics of the I/O to be made */
offset = arg_WRITE4->offset;
size = arg_WRITE4->data.data_len;
stable_how = arg_WRITE4->stable;
LogFullDebug(COMPONENT_NFS_V4,
"offset = %" PRIu64 " length = %" PRIu64 " stable = %d",
offset, size, stable_how);
if (MaxOffsetWrite < UINT64_MAX) {
LogFullDebug(COMPONENT_NFS_V4,
"Write offset=%" PRIu64 " count=%" PRIu64
" MaxOffSet=%" PRIu64, offset, size,
MaxOffsetWrite);
if ((offset + size) > MaxOffsetWrite) {
LogEvent(COMPONENT_NFS_V4,
"A client tryed to violate max file size %"
PRIu64 " for exportid #%hu",
MaxOffsetWrite,
op_ctx->ctx_export->export_id);
res_WRITE4->status = NFS4ERR_FBIG;
goto done;
}
}
if (size > MaxWrite) {
/*
* The client asked for too much data, we
* must restrict him
*/
if (info == NULL ||
info->io_content.what != NFS4_CONTENT_HOLE) {
LogFullDebug(COMPONENT_NFS_V4,
"write requested size = %" PRIu64
" write allowed size = %" PRIu64,
size, MaxWrite);
size = MaxWrite;
}
}
/* Where are the data ? */
bufferdata = arg_WRITE4->data.data_val;
LogFullDebug(COMPONENT_NFS_V4,
"offset = %" PRIu64 " length = %" PRIu64,
offset, size);
/* if size == 0 , no I/O) are actually made and everything is alright */
if (size == 0) {
res_WRITE4->WRITE4res_u.resok4.count = 0;
res_WRITE4->WRITE4res_u.resok4.committed = FILE_SYNC4;
verf_desc.addr = res_WRITE4->WRITE4res_u.resok4.writeverf;
verf_desc.len = sizeof(verifier4);
op_ctx->fsal_export->exp_ops.get_write_verifier(
op_ctx->fsal_export, &verf_desc);
res_WRITE4->status = NFS4_OK;
goto done;
}
if (arg_WRITE4->stable == UNSTABLE4)
sync = false;
else
sync = true;
if (!anonymous_started && data->minorversion == 0) {
owner = get_state_owner_ref(state_found);
if (owner != NULL) {
op_ctx->clientid =
&owner->so_owner.so_nfs4_owner.so_clientid;
}
}
if (obj->fsal->m_ops.support_ex(obj)) {
/* Call the new fsal_write */
fsal_status = fsal_write2(obj, false, state_found, offset, size,
&written_size, bufferdata, &sync,
info);
} else {
/* Call legacy fsal_rdwr */
fsal_status = fsal_rdwr(obj, io, offset, size, &written_size,
bufferdata, &eof_met, &sync, info);
}
if (FSAL_IS_ERROR(fsal_status)) {
LogDebug(COMPONENT_NFS_V4, "write returned %s",
fsal_err_txt(fsal_status));
res_WRITE4->status = nfs4_Errno_status(fsal_status);
goto done;
}
if (!anonymous_started && data->minorversion == 0)
op_ctx->clientid = NULL;
/* Set the returned value */
if (sync)
res_WRITE4->WRITE4res_u.resok4.committed = FILE_SYNC4;
else
res_WRITE4->WRITE4res_u.resok4.committed = UNSTABLE4;
res_WRITE4->WRITE4res_u.resok4.count = written_size;
verf_desc.addr = res_WRITE4->WRITE4res_u.resok4.writeverf;
verf_desc.len = sizeof(verifier4);
op_ctx->fsal_export->exp_ops.get_write_verifier(op_ctx->fsal_export,
&verf_desc);
res_WRITE4->status = NFS4_OK;
done:
if (anonymous_started)
state_share_anonymous_io_done(obj, OPEN4_SHARE_ACCESS_WRITE);
server_stats_io_done(size, written_size,
(res_WRITE4->status == NFS4_OK) ? true : false,
true);
out:
if (owner != NULL)
dec_state_owner_ref(owner);
if (state_found != NULL)
dec_state_t_ref(state_found);
if (state_open != NULL)
dec_state_t_ref(state_open);
return res_WRITE4->status;
} /* nfs4_op_write */
int nfs4_op_read(struct nfs_argop4 *op, compound_data_t * data, struct nfs_resop4 *resp)
{
char __attribute__ ((__unused__)) funcname[] = "nfs4_op_read";
fsal_seek_t seek_descriptor;
fsal_size_t size;
fsal_size_t read_size;
fsal_off_t offset;
fsal_boolean_t eof_met;
caddr_t bufferdata;
cache_inode_status_t cache_status;
state_status_t state_status;
state_t * pstate_found = NULL;
state_t * pstate_open = NULL;
cache_content_status_t content_status;
fsal_attrib_list_t attr;
cache_entry_t * entry = NULL;
state_t * pstate_iterate = NULL;
state_t * pstate_previous_iterate = NULL;
int rc = 0;
cache_content_policy_data_t datapol;
datapol.UseMaxCacheSize = FALSE;
/* Say we are managing NFS4_OP_READ */
resp->resop = NFS4_OP_READ;
res_READ4.status = NFS4_OK;
/* If there is no FH */
if(nfs4_Is_Fh_Empty(&(data->currentFH)))
{
res_READ4.status = NFS4ERR_NOFILEHANDLE;
return res_READ4.status;
}
/* If the filehandle is invalid */
if(nfs4_Is_Fh_Invalid(&(data->currentFH)))
{
res_READ4.status = NFS4ERR_BADHANDLE;
return res_READ4.status;
}
/* Tests if the Filehandle is expired (for volatile filehandle) */
if(nfs4_Is_Fh_Expired(&(data->currentFH)))
{
res_READ4.status = NFS4ERR_FHEXPIRED;
return res_READ4.status;
}
/* If Filehandle points to a xattr object, manage it via the xattrs specific functions */
if(nfs4_Is_Fh_Xattr(&(data->currentFH)))
return nfs4_op_read_xattr(op, data, resp);
/* Manage access type MDONLY */
if(data->pexport->access_type == ACCESSTYPE_MDONLY)
{
res_READ4.status = NFS4ERR_DQUOT;
return res_READ4.status;
}
/* Only files can be read */
if(data->current_filetype != REGULAR_FILE)
{
/* If the source is no file, return EISDIR if it is a directory and EINAVL otherwise */
if(data->current_filetype == DIR_BEGINNING
|| data->current_filetype == DIR_CONTINUE)
res_READ4.status = NFS4ERR_ISDIR;
else
res_READ4.status = NFS4ERR_INVAL;
return res_READ4.status;
}
/* vnode to manage is the current one */
entry = data->current_entry;
/* Check stateid correctness and get pointer to state
* (also checks for special stateids)
*/
if((rc = nfs4_Check_Stateid(&arg_READ4.stateid,
data->current_entry,
0LL,
&pstate_found,
data,
STATEID_SPECIAL_ANY,
"READ")) != NFS4_OK)
{
res_READ4.status = rc;
return res_READ4.status;
}
/* NB: After this points, if pstate_found == NULL, then the stateid is all-0 or all-1 */
if(pstate_found != NULL)
{
switch(pstate_found->state_type)
{
case STATE_TYPE_SHARE:
pstate_open = pstate_found;
break;
case STATE_TYPE_LOCK:
pstate_open = pstate_found->state_data.lock.popenstate;
break;
case STATE_TYPE_DELEG:
pstate_open = NULL;
break;
default:
res_READ4.status = NFS4ERR_BAD_STATEID;
LogDebug(COMPONENT_NFS_V4_LOCK,
"READ with invalid statid of type %d",
(int) pstate_found->state_type);
return res_READ4.status;
}
/* This is a read operation, this means that the file MUST have been opened for reading */
if(pstate_open != NULL &&
(pstate_open->state_data.share.share_access & OPEN4_SHARE_ACCESS_READ) == 0)
{
/* Bad open mode, return NFS4ERR_OPENMODE */
res_READ4.status = NFS4ERR_OPENMODE;
LogDebug(COMPONENT_NFS_V4_LOCK,
"READ state %p doesn't have OPEN4_SHARE_ACCESS_READ",
pstate_found);
return res_READ4.status;
}
/* If NFSv4::Use_OPEN_CONFIRM is set to TRUE in the configuration file, check is state is confirmed */
if(nfs_param.nfsv4_param.use_open_confirm == TRUE)
{
if(pstate_found->state_powner->so_owner.so_nfs4_owner.so_confirmed == FALSE)
{
res_READ4.status = NFS4ERR_BAD_STATEID;
return res_READ4.status;
}
}
}
/* Iterate through file's state to look for conflicts */
pstate_iterate = NULL;
pstate_previous_iterate = NULL;
do
{
state_iterate(data->current_entry,
&pstate_iterate,
pstate_previous_iterate,
data->pclient,
data->pcontext,
&state_status);
if(state_status == STATE_STATE_ERROR)
break; /* Get out of the loop */
if(state_status == STATE_INVALID_ARGUMENT)
{
res_READ4.status = NFS4ERR_INVAL;
return res_READ4.status;
}
cache_status = CACHE_INODE_SUCCESS;
if(pstate_iterate != NULL)
{
if(pstate_iterate->state_type == STATE_TYPE_SHARE)
{
if(pstate_found != pstate_iterate &&
pstate_open != pstate_iterate)
{
if(pstate_iterate->state_data.share.share_deny & OPEN4_SHARE_DENY_READ)
{
/* Writing to this file if prohibited, file is write-denied */
LogDebug(COMPONENT_NFS_V4_LOCK,
"READ is denied by state %p",
pstate_iterate);
res_READ4.status = NFS4ERR_LOCKED;
return res_READ4.status;
}
}
}
}
pstate_previous_iterate = pstate_iterate;
}
while(pstate_iterate != NULL);
/* Get the size and offset of the read operation */
offset = arg_READ4.offset;
size = arg_READ4.count;
LogFullDebug(COMPONENT_NFS_V4,
" NFS4_OP_READ: offset = %"PRIu64" length = %llu",
offset, size);
if((data->pexport->options & EXPORT_OPTION_MAXOFFSETREAD) ==
EXPORT_OPTION_MAXOFFSETREAD)
if((fsal_off_t) (offset + size) > data->pexport->MaxOffsetRead)
{
res_READ4.status = NFS4ERR_DQUOT;
return res_READ4.status;
}
/* Do not read more than FATTR4_MAXREAD */
if((data->pexport->options & EXPORT_OPTION_MAXREAD) == EXPORT_OPTION_MAXREAD &&
size > data->pexport->MaxRead)
{
/* the client asked for too much data,
* this should normally not happen because
* client will get FATTR4_MAXREAD value at mount time */
size = data->pexport->MaxRead;
}
/* If size == 0 , no I/O is to be made and everything is alright */
if(size == 0)
{
res_READ4.READ4res_u.resok4.eof = FALSE; /* end of file was not reached because READ occured, and a size = 0 can not lead to eof */
res_READ4.READ4res_u.resok4.data.data_len = 0;
res_READ4.READ4res_u.resok4.data.data_val = NULL;
res_READ4.status = NFS4_OK;
return res_READ4.status;
}
if((data->pexport->options & EXPORT_OPTION_USE_DATACACHE) &&
(entry->object.file.pentry_content == NULL))
{
/* Entry is not in datacache, but should be in, cache it .
* Several threads may call this function at the first time and a race condition can occur here
* in order to avoid this, cache_inode_add_data_cache is "mutex protected"
* The first call will create the file content cache entry, the further will return
* with error CACHE_INODE_CACHE_CONTENT_EXISTS which is not a pathological thing here */
datapol.UseMaxCacheSize = data->pexport->options & EXPORT_OPTION_MAXCACHESIZE;
datapol.MaxCacheSize = data->pexport->MaxCacheSize;
/* Status is set in last argument */
cache_inode_add_data_cache(entry, data->ht, data->pclient, data->pcontext,
&cache_status);
if((cache_status != CACHE_INODE_SUCCESS) &&
(cache_content_cache_behaviour(entry,
&datapol,
(cache_content_client_t *) (data->pclient->
pcontent_client),
&content_status) == CACHE_CONTENT_FULLY_CACHED)
&& (cache_status != CACHE_INODE_CACHE_CONTENT_EXISTS))
{
res_READ4.status = NFS4ERR_SERVERFAULT;
return res_READ4.status;
}
}
/* Some work is to be done */
if((bufferdata = (char *)Mem_Alloc(size)) == NULL)
{
res_READ4.status = NFS4ERR_SERVERFAULT;
return res_READ4.status;
}
memset((char *)bufferdata, 0, size);
seek_descriptor.whence = FSAL_SEEK_SET;
seek_descriptor.offset = offset;
if(cache_inode_rdwr(entry,
CACHE_CONTENT_READ,
&seek_descriptor,
size,
&read_size,
&attr,
bufferdata,
&eof_met,
data->ht,
data->pclient,
data->pcontext, TRUE, &cache_status) != CACHE_INODE_SUCCESS)
{
res_READ4.status = nfs4_Errno(cache_status);
return res_READ4.status;
}
/* What is the filesize ? */
if((offset + read_size) > attr.filesize)
res_READ4.READ4res_u.resok4.eof = TRUE;
res_READ4.READ4res_u.resok4.data.data_len = read_size;
res_READ4.READ4res_u.resok4.data.data_val = bufferdata;
LogFullDebug(COMPONENT_NFS_V4,
" NFS4_OP_READ: offset = %"PRIu64" read length = %llu eof=%u",
offset, read_size, eof_met);
/* Is EOF met or not ? */
if(eof_met == TRUE)
res_READ4.READ4res_u.resok4.eof = TRUE;
else
res_READ4.READ4res_u.resok4.eof = FALSE;
/* Say it is ok */
res_READ4.status = NFS4_OK;
return res_READ4.status;
} /* nfs4_op_read */
/**
* @brief NFS4_OP_OPEN_CONFIRM
*
* This function implements the NFS4_OP_OPEN_CONFIRM operation.
*
* @param[in] op Arguments for nfs4_op
* @param[in,out] data Compound request's data
* @param[out] resp Results for nfs4_op
*
* @retval NFS4_OK or errors for NFSv4.0
* @retval NFS4ERR_NOTSUPP for NFSv4.1
*
*/
int nfs4_op_open_confirm(struct nfs_argop4 *op, compound_data_t *data,
struct nfs_resop4 *resp)
{
OPEN_CONFIRM4args * const arg_OPEN_CONFIRM4 =
&op->nfs_argop4_u.opopen_confirm;
OPEN_CONFIRM4res * const res_OPEN_CONFIRM4 =
&resp->nfs_resop4_u.opopen_confirm;
OPEN_CONFIRM4resok *resok =
&res_OPEN_CONFIRM4->OPEN_CONFIRM4res_u.resok4;
int rc = 0;
state_t *state_found = NULL;
state_owner_t *open_owner;
const char *tag = "OPEN_CONFIRM";
resp->resop = NFS4_OP_OPEN_CONFIRM;
res_OPEN_CONFIRM4->status = NFS4_OK;
if (data->minorversion > 0) {
res_OPEN_CONFIRM4->status = NFS4ERR_NOTSUPP;
return res_OPEN_CONFIRM4->status;
}
/* Do basic checks on a filehandle
* Should not operate on non-file objects
*/
res_OPEN_CONFIRM4->status =
nfs4_sanity_check_FH(data, REGULAR_FILE, false);
if (res_OPEN_CONFIRM4->status != NFS4_OK)
return res_OPEN_CONFIRM4->status;
/* Check stateid correctness and get pointer to state */
rc = nfs4_Check_Stateid(&arg_OPEN_CONFIRM4->open_stateid,
data->current_obj,
&state_found,
data,
STATEID_SPECIAL_FOR_LOCK,
arg_OPEN_CONFIRM4->seqid,
data->minorversion == 0,
tag);
if (rc != NFS4_OK && rc != NFS4ERR_REPLAY) {
res_OPEN_CONFIRM4->status = rc;
return res_OPEN_CONFIRM4->status;
}
open_owner = get_state_owner_ref(state_found);
if (open_owner == NULL) {
/* State is going stale. */
res_OPEN_CONFIRM4->status = NFS4ERR_STALE;
LogDebug(COMPONENT_NFS_V4,
"OPEN CONFIRM failed nfs4_Check_Stateid, stale open owner");
goto out2;
}
PTHREAD_MUTEX_lock(&open_owner->so_mutex);
/* Check seqid */
if (!Check_nfs4_seqid(open_owner,
arg_OPEN_CONFIRM4->seqid,
op,
data->current_obj,
resp,
tag)) {
/* Response is all setup for us and LogDebug
* told what was wrong
*/
PTHREAD_MUTEX_unlock(&open_owner->so_mutex);
goto out;
}
/* If opened file is already confirmed, retrun NFS4ERR_BAD_STATEID */
if (open_owner->so_owner.so_nfs4_owner.so_confirmed) {
PTHREAD_MUTEX_unlock(&open_owner->so_mutex);
res_OPEN_CONFIRM4->status = NFS4ERR_BAD_STATEID;
goto out;
}
/* Set the state as confirmed */
open_owner->so_owner.so_nfs4_owner.so_confirmed = true;
PTHREAD_MUTEX_unlock(&open_owner->so_mutex);
/* Handle stateid/seqid for success */
update_stateid(state_found, &resok->open_stateid, data, tag);
/* Save the response in the open owner */
Copy_nfs4_state_req(open_owner,
arg_OPEN_CONFIRM4->seqid,
op,
data->current_obj,
resp,
tag);
out:
dec_state_owner_ref(open_owner);
out2:
dec_state_t_ref(state_found);
return res_OPEN_CONFIRM4->status;
} /* nfs4_op_open_confirm */
