/**
* @brief Adds a new state to a file
*
* @param[in,out] obj File to operate on
* @param[in] state_type State to be defined
* @param[in] state_data Data related to this state
* @param[in] owner_input Related open_owner
* @param[out] state The new state
* @param[in] refer Reference to compound creating state
*
* @return Operation status
*/
state_status_t state_add(struct fsal_obj_handle *obj,
enum state_type state_type,
union state_data *state_data,
state_owner_t *owner_input,
state_t **state, struct state_refer *refer)
{
state_status_t status = 0;
/* Ensure that states are are associated only with the appropriate
owners */
if (((state_type == STATE_TYPE_SHARE)
&& (owner_input->so_type != STATE_OPEN_OWNER_NFSV4))
|| ((state_type == STATE_TYPE_LOCK)
&& (owner_input->so_type != STATE_LOCK_OWNER_NFSV4))
||
(((state_type == STATE_TYPE_DELEG)
|| (state_type == STATE_TYPE_LAYOUT))
&& (owner_input->so_type != STATE_CLIENTID_OWNER_NFSV4))) {
return STATE_BAD_TYPE;
}
PTHREAD_RWLOCK_wrlock(&obj->state_hdl->state_lock);
status =
state_add_impl(obj, state_type, state_data, owner_input, state,
refer);
PTHREAD_RWLOCK_unlock(&obj->state_hdl->state_lock);
return status;
}
static void open4_ex(OPEN4args *arg,
compound_data_t *data,
OPEN4res *res_OPEN4,
nfs_client_id_t *clientid,
state_owner_t *owner,
state_t **file_state,
bool *new_state)
{
/* Parent directory in which to open the file. */
struct fsal_obj_handle *parent = NULL;
/* The entry we associated with the desired file before open. */
struct fsal_obj_handle *file_obj = NULL;
/* Indicator that file_obj came from lookup. */
bool looked_up_file_obj = false;
/* The in_obj to pass to fsal_open2. */
struct fsal_obj_handle *in_obj = NULL;
/* The entry open associated with the file. */
struct fsal_obj_handle *out_obj = NULL;
fsal_openflags_t openflags = 0;
fsal_openflags_t old_openflags = 0;
enum fsal_create_mode createmode = FSAL_NO_CREATE;
/* The filename to create */
char *filename = NULL;
/* The supplied calim type */
open_claim_type4 claim = arg->claim.claim;
fsal_verifier_t verifier;
struct attrlist sattr;
/* Status for fsal calls */
fsal_status_t status = {0, 0};
/* The open state for the file */
bool state_lock_held = false;
/* Make sure the attributes are initialized */
memset(&sattr, 0, sizeof(sattr));
/* Make sure... */
*file_state = NULL;
*new_state = false;
/* Pre-process the claim type */
switch (claim) {
case CLAIM_NULL:
/* Check parent */
parent = data->current_obj;
in_obj = parent;
/* Parent must be a directory */
if (parent->type != DIRECTORY) {
if (parent->type == SYMBOLIC_LINK) {
res_OPEN4->status = NFS4ERR_SYMLINK;
goto out;
} else {
res_OPEN4->status = NFS4ERR_NOTDIR;
goto out;
}
}
/* Validate and convert the utf8 filename */
res_OPEN4->status =
nfs4_utf8string2dynamic(&arg->claim.open_claim4_u.file,
UTF8_SCAN_ALL, &filename);
if (res_OPEN4->status != NFS4_OK)
goto out;
/* Set the createmode if appropriate) */
if (arg->openhow.opentype == OPEN4_CREATE) {
open4_ex_create_args(arg, data, res_OPEN4, verifier,
&createmode, &sattr);
if (res_OPEN4->status != NFS4_OK)
goto out;
}
status = fsal_lookup(parent, filename, &file_obj, NULL);
if (!FSAL_IS_ERROR(status)) {
/* Check create situations. */
if (arg->openhow.opentype == OPEN4_CREATE) {
if (createmode >= FSAL_EXCLUSIVE) {
/* Could be a replay, need to continue.
*/
LogFullDebug(COMPONENT_STATE,
"EXCLUSIVE open with existing file %s",
filename);
} else if (createmode == FSAL_GUARDED) {
/* This will be a failure no matter'
* what.
*/
looked_up_file_obj = true;
res_OPEN4->status = NFS4ERR_EXIST;
goto out;
} else {
/* FSAL_UNCHECKED, may be a truncate
* and we need to pass in the case
* of fsal_reopen2 case.
*/
if (FSAL_TEST_MASK(sattr.valid_mask,
ATTR_SIZE) &&
sattr.filesize == 0) {
LogFullDebug(COMPONENT_STATE,
"Truncate");
openflags |= FSAL_O_TRUNC;
}
}
}
/* We found the file by lookup, discard the filename
* and remember that we found the entry by lookup.
*/
looked_up_file_obj = true;
gsh_free(filename);
filename = NULL;
} else if (status.major != ERR_FSAL_NOENT ||
arg->openhow.opentype != OPEN4_CREATE) {
/* A real error occurred */
res_OPEN4->status = nfs4_Errno_status(status);
goto out;
}
break;
/* Both of these just use the current filehandle. */
case CLAIM_PREVIOUS:
owner->so_owner.so_nfs4_owner.so_confirmed = true;
if (!nfs4_check_deleg_reclaim(clientid, &data->currentFH)) {
/* It must have been revoked. Can't reclaim.*/
LogInfo(COMPONENT_NFS_V4, "Can't reclaim delegation");
res_OPEN4->status = NFS4ERR_RECLAIM_BAD;
goto out;
}
openflags |= FSAL_O_RECLAIM;
file_obj = data->current_obj;
break;
case CLAIM_FH:
file_obj = data->current_obj;
break;
case CLAIM_DELEGATE_PREV:
/* FIXME: Remove this when we have full support
* for CLAIM_DELEGATE_PREV and delegpurge operations
*/
res_OPEN4->status = NFS4ERR_NOTSUPP;
goto out;
case CLAIM_DELEGATE_CUR:
res_OPEN4->status = open4_claim_deleg(arg, data);
if (res_OPEN4->status != NFS4_OK)
goto out;
openflags |= FSAL_O_RECLAIM;
file_obj = data->current_obj;
break;
default:
LogFatal(COMPONENT_STATE,
"Programming error. Invalid claim after check.");
}
if ((arg->share_access & OPEN4_SHARE_ACCESS_READ) != 0)
openflags |= FSAL_O_READ;
if ((arg->share_access & OPEN4_SHARE_ACCESS_WRITE) != 0)
openflags |= FSAL_O_WRITE;
if ((arg->share_deny & OPEN4_SHARE_DENY_READ) != 0)
openflags |= FSAL_O_DENY_READ;
if ((arg->share_deny & OPEN4_SHARE_DENY_WRITE) != 0)
openflags |= FSAL_O_DENY_WRITE_MAND;
/* Check if file_obj a REGULAR_FILE */
if (file_obj != NULL && file_obj->type != REGULAR_FILE) {
LogDebug(COMPONENT_NFS_V4,
"Wrong file type expected REGULAR_FILE actual %s",
object_file_type_to_str(file_obj->type));
if (file_obj->type == DIRECTORY) {
res_OPEN4->status = NFS4ERR_ISDIR;
} else {
/* All special nodes must return NFS4ERR_SYMLINK for
* proper client behavior per this linux-nfs post:
* http://marc.info/?l=linux-nfs&m=131342421825436&w=2
*/
res_OPEN4->status = NFS4ERR_SYMLINK;
}
goto out;
}
if (file_obj != NULL) {
/* Go ahead and take the state lock now. */
PTHREAD_RWLOCK_wrlock(&file_obj->state_hdl->state_lock);
state_lock_held = true;
in_obj = file_obj;
/* Check if any existing delegations conflict with this open.
* Delegation recalls will be scheduled if there is a conflict.
*/
if (state_deleg_conflict(file_obj,
(arg->share_access &
OPEN4_SHARE_ACCESS_WRITE) != 0)) {
res_OPEN4->status = NFS4ERR_DELAY;
goto out;
}
/* Check if there is already a state for this entry and owner.
*/
*file_state = nfs4_State_Get_Obj(file_obj, owner);
if (isFullDebug(COMPONENT_STATE) && *file_state != NULL) {
char str[LOG_BUFF_LEN] = "\0";
struct display_buffer dspbuf = {sizeof(str), str, str};
display_stateid(&dspbuf, *file_state);
LogFullDebug(COMPONENT_STATE,
"Found existing state %s",
str);
}
/* Check if open from another export */
if (*file_state != NULL &&
!state_same_export(*file_state, op_ctx->ctx_export)) {
LogEvent(COMPONENT_STATE,
"Lock Owner Export Conflict, Lock held for export %"
PRIu16" request for export %"PRIu16,
state_export_id(*file_state),
op_ctx->ctx_export->export_id);
res_OPEN4->status = NFS4ERR_INVAL;
goto out;
}
}
/* If that did not succeed, allocate a state from the FSAL. */
if (*file_state == NULL) {
*file_state = op_ctx->fsal_export->exp_ops.alloc_state(
op_ctx->fsal_export,
STATE_TYPE_SHARE,
NULL);
/* Remember we allocated a new state */
*new_state = true;
/* We are ready to perform the open (with possible create).
* in_obj has been set to the file itself or the parent.
* filename is NULL if in_obj is the file itself.
*
* Permission check has been done on directory if appropriate,
* otherwise fsal_open2 will do a directory permission
* check.
*
* fsal_open2 handles the permission check on the file
* itself and also handles all the share reservation stuff.
*
* fsal_open2 returns with a ref on out_obj, which should be
* passed to the state.
*/
LogFullDebug(COMPONENT_STATE,
"Calling open2 for %s", filename);
status = fsal_open2(in_obj,
*file_state,
openflags,
createmode,
filename,
&sattr,
verifier,
&out_obj,
NULL);
if (FSAL_IS_ERROR(status)) {
res_OPEN4->status = nfs4_Errno_status(status);
goto out;
}
} else if (createmode >= FSAL_EXCLUSIVE) {
/* We have an EXCLUSIVE create with an existing
* state. We still need to verify it, but no need
* to call reopen2.
*/
LogFullDebug(COMPONENT_STATE, "Calling verify2 ");
status = fsal_verify2(file_obj, verifier);
if (FSAL_IS_ERROR(status)) {
res_OPEN4->status = nfs4_Errno_status(status);
goto out;
}
/* We need an extra reference below. */
file_obj->obj_ops->get_ref(file_obj);
} else {
old_openflags =
file_obj->obj_ops->status2(file_obj, *file_state);
/* Open upgrade */
LogFullDebug(COMPONENT_STATE, "Calling reopen2");
status = fsal_reopen2(file_obj, *file_state,
openflags | old_openflags,
false);
if (FSAL_IS_ERROR(status)) {
res_OPEN4->status = nfs4_Errno_status(status);
goto out;
}
/* We need an extra reference below. */
file_obj->obj_ops->get_ref(file_obj);
}
if (file_obj == NULL) {
/* We have a new cache inode entry, take the state lock. */
file_obj = out_obj;
PTHREAD_RWLOCK_wrlock(&file_obj->state_hdl->state_lock);
state_lock_held = true;
}
/* Now the state_lock is held for sure and we have an extra LRU
* reference to file_obj, which is the opened file.
*/
if (*new_state) {
/* The state data to be added */
union state_data candidate_data;
/* Tracking data for the open state */
struct state_refer refer, *p_refer = NULL;
state_status_t state_status;
candidate_data.share.share_access =
arg->share_access & OPEN4_SHARE_ACCESS_BOTH;
candidate_data.share.share_deny = arg->share_deny;
candidate_data.share.share_access_prev =
(1 << candidate_data.share.share_access);
candidate_data.share.share_deny_prev =
(1 << candidate_data.share.share_deny);
LogFullDebug(COMPONENT_STATE,
"Creating new state access=%x deny=%x access_prev=%x deny_prev=%x",
candidate_data.share.share_access,
candidate_data.share.share_deny,
candidate_data.share.share_access_prev,
candidate_data.share.share_deny_prev);
/* 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;
p_refer = &refer;
}
/* We need to register this state now. */
state_status = state_add_impl(file_obj,
STATE_TYPE_SHARE,
&candidate_data,
owner,
file_state,
p_refer);
if (state_status != STATE_SUCCESS) {
/* state_add_impl failure closed and freed state.
* file_state will also be NULL at this point. Also
* release the ref on file_obj, since the state add
* failed.
*/
file_obj->obj_ops->put_ref(file_obj);
res_OPEN4->status = nfs4_Errno_state(state_status);
*new_state = false;
goto out;
}
glist_init(&(*file_state)->state_data.share.share_lockstates);
}
res_OPEN4->status = open4_create_fh(data, file_obj, true);
if (res_OPEN4->status != NFS4_OK) {
if (*new_state) {
/* state_del_locked will close the file. */
state_del_locked(*file_state);
*file_state = NULL;
*new_state = false;
} else {
/*Do an open downgrade to the old open flags */
status = file_obj->obj_ops->reopen2(file_obj,
*file_state,
old_openflags);
if (FSAL_IS_ERROR(status)) {
LogCrit(COMPONENT_NFS_V4,
"Failed to allocate handle, reopen2 failed with %s",
fsal_err_txt(status));
}
/* Need to release the state_lock before the put_ref
* call.
*/
PTHREAD_RWLOCK_unlock(&file_obj->state_hdl->state_lock);
state_lock_held = false;
/* Release the extra LRU reference on file_obj. */
file_obj->obj_ops->put_ref(file_obj);
goto out;
}
}
/* Since open4_create_fh succeeded the LRU reference to file_obj was
* consumed by data->current_obj.
*/
if (!(*new_state)) {
LogFullDebug(COMPONENT_STATE,
"Open upgrade old access=%x deny=%x access_prev=%x deny_prev=%x",
(*file_state)->state_data.share.share_access,
(*file_state)->state_data.share.share_deny,
(*file_state)->state_data.share.share_access_prev,
(*file_state)->state_data.share.share_deny_prev);
LogFullDebug(COMPONENT_STATE,
"Open upgrade to access=%x deny=%x",
arg->share_access,
arg->share_deny);
/* Update share_access and share_deny */
(*file_state)->state_data.share.share_access |=
arg->share_access & OPEN4_SHARE_ACCESS_BOTH;
(*file_state)->state_data.share.share_deny |=
arg->share_deny;
/* Update share_access_prev and share_deny_prev */
(*file_state)->state_data.share.share_access_prev |=
(1 << (arg->share_access & OPEN4_SHARE_ACCESS_BOTH));
(*file_state)->state_data.share.share_deny_prev |=
(1 << arg->share_deny);
LogFullDebug(COMPONENT_STATE,
"Open upgrade new access=%x deny=%x access_prev=%x deny_prev=%x",
(*file_state)->state_data.share.share_access,
(*file_state)->state_data.share.share_deny,
(*file_state)->state_data.share.share_access_prev,
(*file_state)->state_data.share.share_deny_prev);
}
do_delegation(arg, res_OPEN4, data, owner, *file_state, clientid);
out:
/* Release the attributes (may release an inherited ACL) */
fsal_release_attrs(&sattr);
if (state_lock_held)
PTHREAD_RWLOCK_unlock(&file_obj->state_hdl->state_lock);
if (filename)
gsh_free(filename);
if (res_OPEN4->status != NFS4_OK) {
/* Cleanup state on error */
if (*new_state)
(*file_state)
->state_exp->exp_ops.free_state(
(*file_state)->state_exp, *file_state);
else if (*file_state != NULL)
dec_state_t_ref(*file_state);
*file_state = NULL;
}
if (looked_up_file_obj) {
/* We got file_obj via lookup, we need to unref it. */
file_obj->obj_ops->put_ref(file_obj);
}
}
/**
* @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);
}
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;
bool lock_held = false;
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_obj,
&supplied_state,
data,
STATEID_SPECIAL_CURRENT,
0,
false,
tag);
if (nfs_status != NFS4_OK) {
/* The supplied stateid was invalid */
return nfs_status;
}
if (supplied_state->state_type == STATE_TYPE_LAYOUT) {
/* If the state supplied is a layout state, we can
* simply use it, return with the reference we just
* acquired.
*/
*layout_state = supplied_state;
return nfs_status;
} 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. */
union state_data layout_data;
memset(&layout_data, 0, sizeof(layout_data));
PTHREAD_RWLOCK_wrlock(
&data->current_obj->state_hdl->state_lock);
lock_held = true;
/* See if a layout state already exists */
state_status =
state_lookup_layout_state(data->current_obj,
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;
dec_state_t_ref(condemned_state);
goto out;
}
nfs_status =
nfs4_return_one_state(data->current_obj,
0,
circumstance_forgotten,
condemned_state,
entire,
0,
NULL,
&deleted);
dec_state_t_ref(condemned_state);
if (nfs_status != NFS4_OK)
goto out;
if (!deleted) {
nfs_status = NFS4ERR_SERVERFAULT;
goto out;
}
condemned_state = NULL;
}
layout_data.layout.state_layout_type = layout_type;
layout_data.layout.state_return_on_close = false;
state_status = state_add_impl(data->current_obj,
STATE_TYPE_LAYOUT,
&layout_data,
clientid_owner,
layout_state,
&refer);
if (state_status != STATE_SUCCESS) {
nfs_status = nfs4_Errno_state(state_status);
goto out;
}
glist_init(&(*layout_state)->state_data.layout.state_segments);
} else {
