int nfs3_commit(nfs_arg_t *arg, struct svc_req *req, nfs_res_t *res)
{
cache_inode_status_t cache_status;
cache_entry_t *entry = NULL;
int rc = NFS_REQ_OK;
if (isDebug(COMPONENT_NFSPROTO)) {
char str[LEN_FH_STR];
sprint_fhandle3(str, &(arg->arg_commit3.file));
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs3_commit handle: %s",
str);
}
/* To avoid setting it on each error case */
res->res_commit3.COMMIT3res_u.resfail.file_wcc.before.
attributes_follow = FALSE;
res->res_commit3.COMMIT3res_u.resfail.file_wcc.after.attributes_follow =
FALSE;
entry = nfs3_FhandleToCache(&arg->arg_commit3.file,
&res->res_commit3.status,
&rc);
if (entry == NULL) {
/* Status and rc have been set by nfs3_FhandleToCache */
goto out;
}
cache_status = cache_inode_commit(entry,
arg->arg_commit3.offset,
arg->arg_commit3.count);
if (cache_status != CACHE_INODE_SUCCESS) {
res->res_commit3.status = nfs3_Errno(cache_status);
nfs_SetWccData(NULL, entry,
&(res->res_commit3.COMMIT3res_u.resfail.
file_wcc));
rc = NFS_REQ_OK;
goto out;
}
nfs_SetWccData(NULL, entry,
&(res->res_commit3.COMMIT3res_u.resok.file_wcc));
/* Set the write verifier */
memcpy(res->res_commit3.COMMIT3res_u.resok.verf, NFS3_write_verifier,
sizeof(writeverf3));
res->res_commit3.status = NFS3_OK;
out:
if (entry)
cache_inode_put(entry);
return rc;
} /* nfs3_commit */
int _9p_fsync(struct _9p_request_data *req9p, void *worker_data,
u32 *plenout, char *preply)
{
char *cursor = req9p->_9pmsg + _9P_HDR_SIZE + _9P_TYPE_SIZE;
u16 *msgtag = NULL;
u32 *fid = NULL;
struct _9p_fid *pfid = NULL;
cache_inode_status_t cache_status = CACHE_INODE_SUCCESS;
/* Get data */
_9p_getptr(cursor, msgtag, u16);
_9p_getptr(cursor, fid, u32);
LogDebug(COMPONENT_9P, "TFSYNC: tag=%u fid=%u", (u32) *msgtag, *fid);
if (*fid >= _9P_FID_PER_CONN)
return _9p_rerror(req9p, worker_data, msgtag, ERANGE, plenout,
preply);
pfid = req9p->pconn->fids[*fid];
/* Check that it is a valid open file */
if (pfid == NULL || pfid->pentry == NULL) {
LogDebug(COMPONENT_9P, "request on invalid fid=%u", *fid);
return _9p_rerror(req9p, worker_data, msgtag, EIO, plenout,
preply);
}
cache_status =
cache_inode_commit(pfid->pentry,
0LL, /* start at beginning of file */
0LL, /* Mimic sync_file_range's behavior:
* count=0 means "whole file" */
&pfid->op_context);
if (cache_status != CACHE_INODE_SUCCESS)
return _9p_rerror(req9p, worker_data, msgtag,
_9p_tools_errno(cache_status), plenout,
preply);
/* Build the reply */
_9p_setinitptr(cursor, preply, _9P_RFSYNC);
_9p_setptr(cursor, msgtag, u16);
_9p_setendptr(cursor, preply);
_9p_checkbound(cursor, preply, plenout);
LogDebug(COMPONENT_9P, "RFSYNC: tag=%u fid=%u", (u32) *msgtag, *fid);
return 1;
}
int nfs3_Commit(nfs_arg_t * parg,
exportlist_t * pexport,
fsal_op_context_t * pcontext,
cache_inode_client_t * pclient,
hash_table_t * ht, struct svc_req *preq, nfs_res_t * pres)
{
static char __attribute__ ((__unused__)) funcName[] = "nfs3_Access";
cache_inode_status_t cache_status;
cache_entry_t *pentry = NULL;
cache_inode_fsal_data_t fsal_data;
fsal_attrib_list_t pre_attr;
fsal_attrib_list_t *ppre_attr;
uint64_t typeofcommit;
if(isDebug(COMPONENT_NFSPROTO))
{
char str[LEN_FH_STR];
sprint_fhandle3(str, &(parg->arg_commit3.file));
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs3_Commit handle: %s", str);
}
/* to avoid setting it on each error case */
pres->res_commit3.COMMIT3res_u.resfail.file_wcc.before.attributes_follow = FALSE;
pres->res_commit3.COMMIT3res_u.resfail.file_wcc.after.attributes_follow = FALSE;
ppre_attr = NULL;
/* Convert file handle into a fsal_handle */
if(nfs3_FhandleToFSAL(&(parg->arg_commit3.file), &fsal_data.handle, pcontext) == 0)
return NFS_REQ_DROP;
/* Set cookie to 0 */
fsal_data.cookie = DIR_START;
/* Get the entry in the cache_inode */
if((pentry = cache_inode_get( &fsal_data,
pexport->cache_inode_policy,
&pre_attr,
ht,
pclient,
pcontext,
&cache_status)) == NULL)
{
/* Stale NFS FH ? */
pres->res_commit3.status = NFS3ERR_STALE;
return NFS_REQ_OK;
}
if((pexport->use_commit == TRUE) &&
(pexport->use_ganesha_write_buffer == FALSE))
typeofcommit = FSAL_UNSAFE_WRITE_TO_FS_BUFFER;
else if((pexport->use_commit == TRUE) &&
(pexport->use_ganesha_write_buffer == TRUE))
typeofcommit = FSAL_UNSAFE_WRITE_TO_GANESHA_BUFFER;
else
/* We only do stable writes with this export so no need to execute a commit */
return NFS_REQ_OK;
/* Do not use DC if data cache is enabled, the data is kept synchronous is the DC */
if(cache_inode_commit(pentry,
parg->arg_commit3.offset,
parg->arg_commit3.count,
&pre_attr,
ht, pclient, pcontext, typeofcommit, &cache_status) != CACHE_INODE_SUCCESS)
{
pres->res_commit3.status = NFS3ERR_IO;;
nfs_SetWccData(pcontext,
pexport,
pentry,
ppre_attr,
ppre_attr, &(pres->res_commit3.COMMIT3res_u.resfail.file_wcc));
return NFS_REQ_OK;
}
/* Set the pre_attr */
ppre_attr = &pre_attr;
nfs_SetWccData(pcontext,
pexport,
pentry,
ppre_attr, ppre_attr, &(pres->res_commit3.COMMIT3res_u.resok.file_wcc));
/* Set the write verifier */
memcpy(pres->res_commit3.COMMIT3res_u.resok.verf, NFS3_write_verifier,
sizeof(writeverf3));
pres->res_commit3.status = NFS3_OK;
return NFS_REQ_OK;
} /* nfs3_Commit */