int nfs3_getattr(nfs_arg_t *arg,
nfs_worker_data_t *worker,
struct svc_req *req, nfs_res_t *res)
{
cache_entry_t *entry = NULL;
int rc = NFS_REQ_OK;
if (isDebug(COMPONENT_NFSPROTO)) {
char str[LEN_FH_STR];
nfs_FhandleToStr(req->rq_vers, &(arg->arg_getattr3.object),
NULL, str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs3_getattr handle: %s",
str);
}
entry = nfs3_FhandleToCache(&arg->arg_getattr3.object,
&res->res_getattr3.status,
&rc);
if (entry == NULL) {
/* Status and rc have been set by nfs3_FhandleToCache */
LogFullDebug(COMPONENT_NFSPROTO,
"nfs_Getattr returning %d",
rc);
goto out;
}
if (!cache_entry_to_nfs3_Fattr(
entry,
&res->res_getattr3.GETATTR3res_u.resok.obj_attributes)) {
res->res_getattr3.status =
nfs3_Errno(CACHE_INODE_INVALID_ARGUMENT);
LogFullDebug(COMPONENT_NFSPROTO,
"nfs_Getattr set failed status v3");
rc = NFS_REQ_OK;
goto out;
}
res->res_getattr3.status = NFS3_OK;
LogFullDebug(COMPONENT_NFSPROTO, "nfs_Getattr succeeded");
rc = NFS_REQ_OK;
out:
/* return references */
if (entry)
cache_inode_put(entry);
return rc;
}
int nfs3_readdir(nfs_arg_t *arg, struct svc_req *req, nfs_res_t *res)
{
struct fsal_obj_handle *dir_obj = NULL;
struct fsal_obj_handle *parent_dir_obj = NULL;
unsigned long count = 0;
uint64_t cookie = 0;
uint64_t fsal_cookie = 0;
cookieverf3 cookie_verifier;
unsigned int num_entries = 0;
unsigned long estimated_num_entries = 0;
object_file_type_t dir_filetype = 0;
bool eod_met = false;
fsal_status_t fsal_status = {0, 0};
fsal_status_t fsal_status_gethandle = {0, 0};
int rc = NFS_REQ_OK;
struct nfs3_readdir_cb_data tracker = { NULL };
bool use_cookie_verifier = op_ctx_export_has_option(
EXPORT_OPTION_USE_COOKIE_VERIFIER);
if (isDebug(COMPONENT_NFSPROTO) || isDebug(COMPONENT_NFS_READDIR)) {
char str[LEN_FH_STR];
log_components_t component;
nfs_FhandleToStr(req->rq_vers,
&(arg->arg_readdir3.dir),
NULL,
str);
if (isDebug(COMPONENT_NFSPROTO))
component = COMPONENT_NFSPROTO;
else
component = COMPONENT_NFS_READDIR;
LogDebug(component,
"REQUEST PROCESSING: Calling nfs_Readdir handle: %s",
str);
}
READDIR3resok * const RES_READDIR3_OK =
&res->res_readdir3.READDIR3res_u.resok;
/* to avoid setting it on each error case */
res->res_readdir3.READDIR3res_u.resfail.dir_attributes.
attributes_follow = FALSE;
/* Look up object for filehandle */
dir_obj = nfs3_FhandleToCache(&(arg->arg_readdir3.dir),
&(res->res_readdir3.status),
&rc);
if (dir_obj == NULL) {
/* Status and rc have been set by nfs3_FhandleToCache */
goto out;
}
/* Extract the filetype */
dir_filetype = dir_obj->type;
/* Sanity checks -- must be a directory */
if (dir_filetype != DIRECTORY) {
res->res_readdir3.status = NFS3ERR_NOTDIR;
rc = NFS_REQ_OK;
goto out;
}
/* Parse out request arguments and decide how many entries we
* want. For NFSv3, deal with the cookie verifier.
*/
count = arg->arg_readdir3.count;
cookie = arg->arg_readdir3.cookie;
estimated_num_entries =
MIN(count / (sizeof(entry3) - sizeof(char *)), 120);
LogFullDebug(COMPONENT_NFS_READDIR,
"---> nfs3_readdir: count=%lu cookie=%" PRIu64
" estimated_num_entries=%lu",
count, cookie, estimated_num_entries);
if (estimated_num_entries == 0) {
res->res_readdir3.status = NFS3ERR_TOOSMALL;
rc = NFS_REQ_OK;
goto out;
}
/* To make or check the cookie verifier */
memset(cookie_verifier, 0, sizeof(cookieverf3));
/* If cookie verifier is used, then a
* non-trivial value is returned to the
* client.
*
* This value is the ctime of the directory. If verifier is
* unused (as in many NFS Servers) then only a set of zeros
* is returned (trivial value).
*/
if (use_cookie_verifier) {
struct attrlist attrs;
fsal_prepare_attrs(&attrs, ATTR_CTIME);
fsal_status = dir_obj->obj_ops.getattrs(dir_obj, &attrs);
if (FSAL_IS_ERROR(fsal_status)) {
res->res_readdir3.status =
nfs3_Errno_status(fsal_status);
LogFullDebug(COMPONENT_NFS_READDIR,
"getattrs returned %s",
msg_fsal_err(fsal_status.major));
goto out;
}
memcpy(cookie_verifier,
&attrs.ctime.tv_sec,
sizeof(attrs.ctime.tv_sec));
/* Done with the attrs */
fsal_release_attrs(&attrs);
}
if (cookie != 0 && use_cookie_verifier) {
/* Not the first call, so we have to check the cookie
* verifier
*/
if (memcmp(cookie_verifier,
arg->arg_readdir3.cookieverf,
NFS3_COOKIEVERFSIZE) != 0) {
res->res_readdir3.status = NFS3ERR_BAD_COOKIE;
rc = NFS_REQ_OK;
goto out;
}
}
tracker.entries = gsh_calloc(estimated_num_entries, sizeof(entry3));
tracker.total_entries = estimated_num_entries;
tracker.mem_left = count - sizeof(READDIR3resok);
tracker.count = 0;
tracker.error = NFS3_OK;
/* Adjust the cookie we supply to fsal */
if (cookie > 2) { /* it is not the cookie for "." nor ".." */
fsal_cookie = cookie;
} else {
fsal_cookie = 0;
}
/* Fills "." */
if (cookie == 0) {
res->res_readdir3.status = nfs_readdir_dot_entry(dir_obj, ".",
1, nfs3_readdir_callback, &tracker);
if (res->res_readdir3.status != NFS3_OK) {
rc = NFS_REQ_OK;
goto out;
}
}
/* Fills ".." */
if ((cookie <= 1) && (estimated_num_entries > 1)) {
/* Get parent pentry */
fsal_status_gethandle = fsal_lookupp(dir_obj,
&parent_dir_obj,
NULL);
if (parent_dir_obj == NULL) {
res->res_readdir3.status =
nfs3_Errno_status(fsal_status_gethandle);
rc = NFS_REQ_OK;
goto out;
}
res->res_readdir3.status = nfs_readdir_dot_entry(parent_dir_obj,
"..", 2, nfs3_readdir_callback, &tracker);
if (res->res_readdir3.status != NFS3_OK) {
rc = NFS_REQ_OK;
goto out;
}
parent_dir_obj->obj_ops.put_ref(parent_dir_obj);
parent_dir_obj = NULL;
}
/* Call readdir */
fsal_status = fsal_readdir(dir_obj, fsal_cookie, &num_entries, &eod_met,
0, /* no attr */
nfs3_readdir_callback, &tracker);
if (FSAL_IS_ERROR(fsal_status)) {
if (nfs_RetryableError(fsal_status.major)) {
rc = NFS_REQ_DROP;
goto out;
}
res->res_readdir3.status = nfs3_Errno_status(fsal_status);
nfs_SetPostOpAttr(dir_obj,
&res->res_readdir3.READDIR3res_u.resfail.
dir_attributes,
NULL);
goto out;
}
if (tracker.error != NFS3_OK) {
res->res_readdir3.status = tracker.error;
nfs_SetPostOpAttr(dir_obj,
&res->res_readdir3.READDIR3res_u.resfail.
dir_attributes,
NULL);
goto out;
}
LogFullDebug(COMPONENT_NFS_READDIR,
"-- Readdir -> Call to fsal_readdir(cookie=%"
PRIu64 ")",
fsal_cookie);
if ((num_entries == 0) && (cookie > 1)) {
RES_READDIR3_OK->reply.entries = NULL;
RES_READDIR3_OK->reply.eof = TRUE;
} else {
RES_READDIR3_OK->reply.entries = tracker.entries;
RES_READDIR3_OK->reply.eof = eod_met;
}
nfs_SetPostOpAttr(dir_obj, &RES_READDIR3_OK->dir_attributes, NULL);
memcpy(RES_READDIR3_OK->cookieverf, cookie_verifier,
sizeof(cookieverf3));
res->res_readdir3.status = NFS3_OK;
rc = NFS_REQ_OK;
out:
/* return references */
if (dir_obj)
dir_obj->obj_ops.put_ref(dir_obj);
if (parent_dir_obj)
parent_dir_obj->obj_ops.put_ref(parent_dir_obj);
/* Deallocate memory in the event of an error */
if (((res->res_readdir3.status != NFS3_OK) || (rc != NFS_REQ_OK) ||
((num_entries == 0) && (cookie > 1))) &&
(tracker.entries != NULL)) {
free_entry3s(tracker.entries);
RES_READDIR3_OK->reply.entries = NULL;
}
return rc;
} /* nfs3_readdir */
int nfs_Create(nfs_arg_t *parg,
exportlist_t *pexport,
fsal_op_context_t *pcontext,
nfs_worker_data_t *pworker,
struct svc_req *preq,
nfs_res_t *pres)
{
char *str_file_name = NULL;
fsal_name_t file_name;
fsal_accessmode_t mode = 0;
cache_entry_t *file_pentry = NULL;
cache_entry_t *parent_pentry = NULL;
fsal_attrib_list_t parent_attr;
fsal_attrib_list_t attr;
fsal_attrib_list_t attr_parent_after;
fsal_attrib_list_t attr_newfile;
fsal_attrib_list_t attributes_create;
fsal_attrib_list_t *ppre_attr;
cache_inode_status_t cache_status = CACHE_INODE_SUCCESS;
cache_inode_status_t cache_status_lookup;
cache_inode_file_type_t parent_filetype;
int rc = NFS_REQ_OK;
#ifdef _USE_QUOTA
fsal_status_t fsal_status ;
#endif
if(isDebug(COMPONENT_NFSPROTO))
{
char str[LEN_FH_STR];
switch (preq->rq_vers)
{
case NFS_V2:
str_file_name = parg->arg_create2.where.name;
break;
case NFS_V3:
str_file_name = parg->arg_create3.where.name;
break;
}
nfs_FhandleToStr(preq->rq_vers,
&(parg->arg_create2.where.dir),
&(parg->arg_create3.where.dir),
NULL,
str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs_Create handle: %s name: %s",
str, str_file_name);
}
if((preq->rq_vers == NFS_V3) && (nfs3_Is_Fh_Xattr(&(parg->arg_create3.where.dir))))
{
rc = nfs3_Create_Xattr(parg, pexport, pcontext, preq, pres);
goto out;
}
if(preq->rq_vers == NFS_V3)
{
/* to avoid setting it on each error case */
pres->res_create3.CREATE3res_u.resfail.dir_wcc.before.attributes_follow = FALSE;
pres->res_create3.CREATE3res_u.resfail.dir_wcc.after.attributes_follow = FALSE;
ppre_attr = NULL;
}
if((parent_pentry = nfs_FhandleToCache(preq->rq_vers,
&(parg->arg_create2.where.dir),
&(parg->arg_create3.where.dir),
NULL,
&(pres->res_dirop2.status),
&(pres->res_create3.status),
NULL,
&parent_attr,
pcontext, &rc)) == NULL)
{
/* Stale NFS FH ? */
goto out;
}
/* get directory attributes before action (for V3 reply) */
ppre_attr = &parent_attr;
/* Extract the filetype */
parent_filetype = cache_inode_fsal_type_convert(parent_attr.type);
/*
* Sanity checks: new file name must be non-null; parent must be a
* directory.
*/
if(parent_filetype != DIRECTORY)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_NOTDIR;
break;
case NFS_V3:
pres->res_create3.status = NFS3ERR_NOTDIR;
break;
}
rc = NFS_REQ_OK;
goto out;
}
switch (preq->rq_vers)
{
case NFS_V2:
str_file_name = parg->arg_create2.where.name;
if(parg->arg_create2.attributes.mode != (unsigned int)-1)
{
mode = unix2fsal_mode(parg->arg_create2.attributes.mode);
}
else
{
mode = 0;
}
break;
case NFS_V3:
str_file_name = parg->arg_create3.where.name;
if(parg->arg_create3.how.mode == EXCLUSIVE)
{
/*
* Client has not provided mode information.
* If the create works, the client will issue
* a separate setattr request to fix up the
* file's mode, so pick arbitrary value for now.
*/
mode = 0;
}
else if(parg->arg_create3.how.createhow3_u.obj_attributes.mode.set_it == TRUE)
mode =
unix2fsal_mode(parg->arg_create3.how.createhow3_u.obj_attributes.mode.
set_mode3_u.mode);
else
mode = 0;
break;
}
#ifdef _USE_QUOTA
/* if quota support is active, then we should check is the FSAL allows inode creation or not */
fsal_status = FSAL_check_quota( pexport->fullpath,
FSAL_QUOTA_INODES,
FSAL_OP_CONTEXT_TO_UID( pcontext ) ) ;
if( FSAL_IS_ERROR( fsal_status ) )
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_DQUOT ;
break;
case NFS_V3:
pres->res_create3.status = NFS3ERR_DQUOT;
break;
}
rc = NFS_REQ_OK ;
goto out;
}
#endif /* _USE_QUOTA */
// if(str_file_name == NULL || strlen(str_file_name) == 0)
if(str_file_name == NULL || *str_file_name == '\0' )
{
if(preq->rq_vers == NFS_V2)
pres->res_dirop2.status = NFSERR_IO;
if(preq->rq_vers == NFS_V3)
pres->res_create3.status = NFS3ERR_INVAL;
}
else
{
if((cache_status = cache_inode_error_convert(FSAL_str2name(str_file_name,
FSAL_MAX_NAME_LEN,
&file_name))) ==
CACHE_INODE_SUCCESS)
{
/*
* Lookup file to see if it exists. If so, use it. Otherwise
* create a new one.
*/
file_pentry = cache_inode_lookup(parent_pentry,
&file_name,
&attr,
pcontext,
&cache_status_lookup);
if((cache_status_lookup == CACHE_INODE_NOT_FOUND) ||
((cache_status_lookup == CACHE_INODE_SUCCESS)
&& (parg->arg_create3.how.mode == UNCHECKED)))
{
/* Create the file */
if((parg->arg_create3.how.mode == UNCHECKED)
&& (cache_status_lookup == CACHE_INODE_SUCCESS))
{
cache_status = CACHE_INODE_SUCCESS;
attr_newfile = attr;
}
else
file_pentry = cache_inode_create(parent_pentry,
&file_name,
REGULAR_FILE,
mode,
NULL,
&attr_newfile,
pcontext, &cache_status);
if(file_pentry != NULL)
{
/*
* Look at sattr to see if some attributes are to be set at creation time
*/
attributes_create.asked_attributes = 0ULL;
switch (preq->rq_vers)
{
case NFS_V2:
if(nfs2_Sattr_To_FSALattr(&attributes_create,
&parg->arg_create2.attributes) == 0)
{
pres->res_dirop2.status = NFSERR_IO;
rc = NFS_REQ_OK;
goto out;
break;
}
break;
case NFS_V3:
if(nfs3_Sattr_To_FSALattr(&attributes_create,
&parg->arg_create3.how.createhow3_u.
obj_attributes) == 0)
{
pres->res_create3.status = NFS3ERR_INVAL;
rc = NFS_REQ_OK;
goto out;
}
break;
}
/* Mode is managed above (in cache_inode_create), there is no need
* to manage it */
if(attributes_create.asked_attributes & FSAL_ATTR_MODE)
attributes_create.asked_attributes &= ~FSAL_ATTR_MODE;
/* Some clients (like Solaris 10) try to set the size of the file to 0
* at creation time. The FSAL create empty file, so we ignore this */
if(attributes_create.asked_attributes & FSAL_ATTR_SIZE)
attributes_create.asked_attributes &= ~FSAL_ATTR_SIZE;
if(attributes_create.asked_attributes & FSAL_ATTR_SPACEUSED)
attributes_create.asked_attributes &= ~FSAL_ATTR_SPACEUSED;
/* Are there attributes to be set (additional to the mode) ? */
if(attributes_create.asked_attributes != 0ULL &&
attributes_create.asked_attributes != FSAL_ATTR_MODE)
{
/* A call to cache_inode_setattr is required */
if(cache_inode_setattr(file_pentry,
&attributes_create,
pcontext,
&cache_status) != CACHE_INODE_SUCCESS)
{
/* If we are here, there was an error */
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_dirop2.status,
&pres->res_create3.status,
NULL, NULL,
parent_pentry,
ppre_attr,
&(pres->res_create3.CREATE3res_u.resfail.
dir_wcc), NULL, NULL, NULL);
if(nfs_RetryableError(cache_status)) {
rc = NFS_REQ_DROP;
goto out;
}
rc = NFS_REQ_OK;
goto out;
}
/* Get the resulting attributes from the Cache Inode */
if(cache_inode_getattr(file_pentry,
&attr_newfile,
pcontext,
&cache_status) != CACHE_INODE_SUCCESS)
{
/* If we are here, there was an error */
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_dirop2.status,
&pres->res_create3.status,
NULL, NULL,
parent_pentry,
ppre_attr,
&(pres->res_create3.CREATE3res_u.resfail.
dir_wcc), NULL, NULL, NULL);
if(nfs_RetryableError(cache_status)) {
rc = NFS_REQ_DROP;
goto out;
}
rc = NFS_REQ_OK;
goto out;
}
}
switch (preq->rq_vers)
{
case NFS_V2:
/* Build file handle */
if(nfs2_FSALToFhandle(
&(pres->res_dirop2.DIROP2res_u.diropok.file),
&file_pentry->handle,
pexport) == 0)
pres->res_dirop2.status = NFSERR_IO;
else
{
if(!nfs2_FSALattr_To_Fattr(
pexport, &attr_newfile,
&(pres->res_dirop2.DIROP2res_u.
diropok.attributes)))
pres->res_dirop2.status = NFSERR_IO;
else
pres->res_dirop2.status = NFS_OK;
}
break;
case NFS_V3:
/* Build file handle */
pres->res_create3.status =
nfs3_AllocateFH(&pres->res_create3.CREATE3res_u
.resok.obj.post_op_fh3_u.handle);
if (pres->res_create3.status != NFS3_OK)
{
rc = NFS_REQ_OK;
goto out;
}
/* Set Post Op Fh3 structure */
if(nfs3_FSALToFhandle(
&(pres->res_create3.CREATE3res_u.resok
.obj.post_op_fh3_u.handle),
&file_pentry->handle, pexport) == 0)
{
gsh_free(pres->res_create3.CREATE3res_u.resok.obj.
post_op_fh3_u.handle.data.data_val);
pres->res_create3.status = NFS3ERR_BADHANDLE;
rc = NFS_REQ_OK;
goto out;
}
/* Set Post Op Fh3 structure */
pres->res_create3.CREATE3res_u.resok.obj.handle_follows
= TRUE;
/* Get the attributes of the parent after the
operation */
attr_parent_after = parent_pentry->attributes;
/* Build entry attributes */
nfs_SetPostOpAttr(pexport,
&attr_newfile,
&(pres->res_create3.CREATE3res_u.resok.
obj_attributes));
/*
* Build Weak Cache Coherency data
*/
nfs_SetWccData(pexport,
ppre_attr,
&attr_parent_after,
&(pres->res_create3.CREATE3res_u
.resok.dir_wcc));
pres->res_create3.status = NFS3_OK;
break;
} /* switch */
rc = NFS_REQ_OK;
goto out;
}
}
else
{
if(cache_status_lookup == CACHE_INODE_SUCCESS)
{
/* Trying to create a file that already exists */
cache_status = CACHE_INODE_ENTRY_EXISTS;
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_EXIST;
break;
case NFS_V3:
pres->res_create3.status = NFS3ERR_EXIST;
break;
}
}
else
{
/* Server fault */
cache_status = cache_status_lookup;
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_IO;
break;
case NFS_V3:
pres->res_create3.status = NFS3ERR_INVAL;
break;
}
}
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_dirop2.status,
&pres->res_create3.status,
NULL, NULL,
parent_pentry,
ppre_attr,
&(pres->res_create3.CREATE3res_u.resfail.dir_wcc),
NULL, NULL, NULL);
rc = NFS_REQ_OK;
goto out;
} /* if( cache_status_lookup == CACHE_INODE_NOT_FOUND ) */
}
}
/* Set the exit status */
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_dirop2.status,
&pres->res_create3.status,
NULL, NULL,
parent_pentry,
ppre_attr,
&(pres->res_create3.CREATE3res_u.resfail.dir_wcc),
NULL, NULL, NULL);
/* If we are here, there was an error */
if(nfs_RetryableError(cache_status))
{
rc = NFS_REQ_DROP;
goto out;
}
rc = NFS_REQ_OK;
out:
/* return references */
if (file_pentry)
cache_inode_put(file_pentry);
if (parent_pentry)
cache_inode_put(parent_pentry);
return (rc);
} /* nfs_Create */
int nfs3_link(nfs_arg_t *arg,
nfs_worker_data_t *worker,
struct svc_req *req, nfs_res_t *res)
{
const char *link_name = arg->arg_link3.link.name;
cache_entry_t *target_entry = NULL;
cache_entry_t *parent_entry = NULL;
pre_op_attr pre_parent = {
.attributes_follow = false
};
cache_inode_status_t cache_status = CACHE_INODE_SUCCESS;
short to_exportid = 0;
short from_exportid = 0;
int rc = NFS_REQ_OK;
if (isDebug(COMPONENT_NFSPROTO)) {
char strto[LEN_FH_STR], strfrom[LEN_FH_STR];
nfs_FhandleToStr(req->rq_vers,
&(arg->arg_link3.file),
NULL,
strfrom);
nfs_FhandleToStr(req->rq_vers,
&(arg->arg_link3.link.dir),
NULL,
strto);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs3_link handle: %s to "
"handle: %s name: %s", strfrom, strto, link_name);
}
/* to avoid setting it on each error case */
res->res_link3.LINK3res_u.resfail.file_attributes.attributes_follow =
FALSE;
res->res_link3.LINK3res_u.resfail.linkdir_wcc.before.attributes_follow =
FALSE;
res->res_link3.LINK3res_u.resfail.linkdir_wcc.after.attributes_follow =
FALSE;
/* Get the exportids for the two handles. */
to_exportid = nfs3_FhandleToExportId(&(arg->arg_link3.link.dir));
from_exportid = nfs3_FhandleToExportId(&(arg->arg_link3.file));
/* Validate the to_exportid */
if (to_exportid < 0 || from_exportid < 0) {
LogInfo(COMPONENT_DISPATCH,
"NFS%d LINK Request from client %s has badly formed handle for link dir",
req->rq_vers,
op_ctx->client
? op_ctx->client->hostaddr_str
: "unknown client");
/* Bad handle, report to client */
res->res_link3.status = NFS3ERR_BADHANDLE;
goto out;
}
/* Both objects have to be in the same filesystem */
if (to_exportid != from_exportid) {
res->res_link3.status = NFS3ERR_XDEV;
goto out;
}
/* Get entry for parent directory */
parent_entry = nfs3_FhandleToCache(&arg->arg_link3.link.dir,
&res->res_link3.status,
&rc);
if (parent_entry == NULL) {
/* Status and rc have been set by nfs3_FhandleToCache */
goto out;
}
nfs_SetPreOpAttr(parent_entry, &pre_parent);
target_entry = nfs3_FhandleToCache(&arg->arg_link3.file,
&res->res_link3.status,
&rc);
if (target_entry == NULL) {
/* Status and rc have been set by nfs3_FhandleToCache */
goto out;
}
/* Sanity checks: */
if (parent_entry->type != DIRECTORY) {
res->res_link3.status = NFS3ERR_NOTDIR;
rc = NFS_REQ_OK;
goto out;
}
if (link_name == NULL || *link_name == '\0')
res->res_link3.status = NFS3ERR_INVAL;
else {
/* Both objects have to be in the same filesystem */
if (to_exportid != from_exportid)
res->res_link3.status = NFS3ERR_XDEV;
else {
cache_status = cache_inode_link(target_entry,
parent_entry,
link_name);
if (cache_status == CACHE_INODE_SUCCESS) {
nfs_SetPostOpAttr(target_entry,
&(res->res_link3.LINK3res_u.
resok.file_attributes));
nfs_SetWccData(&pre_parent,
parent_entry,
&(res->res_link3.LINK3res_u.
resok.linkdir_wcc));
res->res_link3.status = NFS3_OK;
rc = NFS_REQ_OK;
goto out;
}
} /* else */
}
/* If we are here, there was an error */
if (nfs_RetryableError(cache_status)) {
rc = NFS_REQ_DROP;
goto out;
}
res->res_link3.status = nfs3_Errno(cache_status);
nfs_SetPostOpAttr(target_entry,
&(res->res_link3.LINK3res_u.resfail.file_attributes));
nfs_SetWccData(&pre_parent, parent_entry,
&res->res_link3.LINK3res_u.resfail.linkdir_wcc);
rc = NFS_REQ_OK;
out:
/* return references */
if (target_entry)
cache_inode_put(target_entry);
if (parent_entry)
cache_inode_put(parent_entry);
return rc;
} /* nfs3_link */
/**
* @brief Free the result structure allocated for nfs3_link
*
* This function frees the result structure allocated for nfs3_link.
*
* @param[in,out] resp Result structure
*
*/
void nfs3_link_free(nfs_res_t *resp)
{
return;
}
int nfs_Mkdir(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[] = "nfs_Mkdir";
char *str_dir_name = NULL;
fsal_accessmode_t mode = 0;
cache_entry_t *dir_pentry = NULL;
cache_entry_t *parent_pentry = NULL;
int rc = 0;
fsal_attrib_list_t parent_attr;
fsal_attrib_list_t attr;
fsal_attrib_list_t *ppre_attr;
fsal_attrib_list_t attr_parent_after;
cache_inode_file_type_t parent_filetype;
fsal_handle_t *pfsal_handle;
fsal_name_t dir_name;
cache_inode_status_t cache_status = CACHE_INODE_SUCCESS;
cache_inode_status_t cache_status_lookup;
if(isDebug(COMPONENT_NFSPROTO))
{
char str[LEN_FH_STR];
switch (preq->rq_vers)
{
case NFS_V2:
str_dir_name = parg->arg_mkdir2.where.name;
break;
case NFS_V3:
str_dir_name = parg->arg_mkdir3.where.name;
break;
}
nfs_FhandleToStr(preq->rq_vers,
&(parg->arg_mkdir2.where.dir),
&(parg->arg_mkdir3.where.dir),
NULL,
str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs_Mkdir handle: %s name: %s",
str, str_dir_name);
}
if(preq->rq_vers == NFS_V3)
{
/* to avoid setting it on each error case */
pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc.before.attributes_follow = FALSE;
pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc.after.attributes_follow = FALSE;
ppre_attr = NULL;
}
if((parent_pentry = nfs_FhandleToCache(preq->rq_vers,
&(parg->arg_mkdir2.where.dir),
&(parg->arg_mkdir3.where.dir),
NULL,
&(pres->res_dirop2.status),
&(pres->res_mkdir3.status),
NULL,
&parent_attr,
pcontext, pclient, ht, &rc)) == NULL)
{
/* Stale NFS FH ? */
return rc;
}
/* get directory attributes before action (for V3 reply) */
ppre_attr = &parent_attr;
/* Extract the filetype */
parent_filetype = cache_inode_fsal_type_convert(parent_attr.type);
/*
* Sanity checks:
*/
if(parent_filetype != DIRECTORY)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_NOTDIR;
break;
case NFS_V3:
pres->res_mkdir3.status = NFS3ERR_NOTDIR;
break;
}
return NFS_REQ_OK;
}
switch (preq->rq_vers)
{
case NFS_V2:
str_dir_name = parg->arg_mkdir2.where.name;
if(parg->arg_mkdir2.attributes.mode != (unsigned int)-1)
{
mode = (fsal_accessmode_t) parg->arg_mkdir2.attributes.mode;
}
else
{
mode = (fsal_accessmode_t) 0;
}
break;
case NFS_V3:
str_dir_name = parg->arg_mkdir3.where.name;
if(parg->arg_mkdir3.attributes.mode.set_it == TRUE)
mode = (fsal_accessmode_t) parg->arg_mkdir3.attributes.mode.set_mode3_u.mode;
else
mode = (fsal_accessmode_t) 0;
break;
}
//if(str_dir_name == NULL || strlen(str_dir_name) == 0)
if(str_dir_name == NULL || *str_dir_name == '\0' )
{
if(preq->rq_vers == NFS_V2)
pres->res_dirop2.status = NFSERR_IO;
if(preq->rq_vers == NFS_V3)
pres->res_mkdir3.status = NFS3ERR_INVAL;
}
else
{
/* Make the directory */
if((cache_status = cache_inode_error_convert(FSAL_str2name(str_dir_name,
FSAL_MAX_NAME_LEN,
&dir_name))) ==
CACHE_INODE_SUCCESS)
{
/*
* Lookup file to see if it exists. If so, use it. Otherwise
* create a new one.
*/
dir_pentry = cache_inode_lookup( parent_pentry,
&dir_name,
pexport->cache_inode_policy,
&attr,
ht,
pclient,
pcontext,
&cache_status_lookup);
if(cache_status_lookup == CACHE_INODE_NOT_FOUND)
{
/* Create the directory */
if((dir_pentry = cache_inode_create(parent_pentry,
&dir_name,
DIRECTORY,
pexport->cache_inode_policy,
mode,
NULL,
&attr,
ht,
pclient,
pcontext, &cache_status)) != NULL)
{
/*
* Get the FSAL handle for this entry
*/
pfsal_handle = cache_inode_get_fsal_handle(dir_pentry, &cache_status);
if(cache_status == CACHE_INODE_SUCCESS)
{
switch (preq->rq_vers)
{
case NFS_V2:
/* Build file handle */
if(!nfs2_FSALToFhandle
(&(pres->res_dirop2.DIROP2res_u.diropok.file), pfsal_handle,
pexport))
pres->res_dirop2.status = NFSERR_IO;
else
{
/*
* Build entry
* attributes
*/
if(nfs2_FSALattr_To_Fattr(pexport, &attr,
&(pres->res_dirop2.DIROP2res_u.
diropok.attributes)) == 0)
pres->res_dirop2.status = NFSERR_IO;
else
pres->res_dirop2.status = NFS_OK;
}
break;
case NFS_V3:
/* Build file handle */
if((pres->res_mkdir3.MKDIR3res_u.resok.obj.post_op_fh3_u.
handle.data.data_val = Mem_Alloc_Label(NFS3_FHSIZE,
"Filehandle V3 in nfs3_mkdir")) == NULL)
{
pres->res_mkdir3.status = NFS3ERR_IO;
return NFS_REQ_OK;
}
if(nfs3_FSALToFhandle
(&pres->res_mkdir3.MKDIR3res_u.resok.obj.post_op_fh3_u.
handle, pfsal_handle, pexport) == 0)
{
Mem_Free((char *)pres->res_mkdir3.MKDIR3res_u.resok.obj.
post_op_fh3_u.handle.data.data_val);
pres->res_mkdir3.status = NFS3ERR_INVAL;
return NFS_REQ_OK;
}
else
{
/* Set Post Op Fh3 structure */
pres->res_mkdir3.MKDIR3res_u.resok.obj.handle_follows =
TRUE;
pres->res_mkdir3.MKDIR3res_u.resok.obj.post_op_fh3_u.handle.
data.data_len = sizeof(file_handle_v3_t);
/*
* Build entry
* attributes
*/
nfs_SetPostOpAttr(pcontext, pexport,
dir_pentry,
&attr,
&(pres->res_mkdir3.MKDIR3res_u.resok.
obj_attributes));
/* Get the attributes of the parent after the operation */
cache_inode_get_attributes(parent_pentry,
&attr_parent_after);
/*
* Build Weak Cache
* Coherency data
*/
nfs_SetWccData(pcontext, pexport,
parent_pentry,
ppre_attr,
&attr_parent_after,
&(pres->res_mkdir3.MKDIR3res_u.resok.
dir_wcc));
pres->res_mkdir3.status = NFS3_OK;
}
break;
}
return NFS_REQ_OK;
}
}
} /* If( cache_status_lookup == CACHE_INODE_NOT_FOUND ) */
else
{
/* object already exists or failure during lookup */
if(cache_status_lookup == CACHE_INODE_SUCCESS)
{
/* Trying to create a file that already exists */
cache_status = CACHE_INODE_ENTRY_EXISTS;
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_EXIST;
break;
case NFS_V3:
pres->res_mkdir3.status = NFS3ERR_EXIST;
break;
}
}
else
{
/* Server fault */
cache_status = cache_status_lookup;
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_IO;
break;
case NFS_V3:
pres->res_mkdir3.status = NFS3ERR_INVAL;
break;
}
}
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_dirop2.status,
&pres->res_mkdir3.status,
NULL, NULL,
parent_pentry,
ppre_attr,
&(pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc),
NULL, NULL, NULL);
return NFS_REQ_OK;
}
}
}
/* If we are here, there was an error */
if(nfs_RetryableError(cache_status))
{
return NFS_REQ_DROP;
}
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_dirop2.status,
&pres->res_mkdir3.status,
NULL, NULL,
parent_pentry,
ppre_attr,
&(pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc), NULL, NULL, NULL);
return NFS_REQ_OK;
}
int nfs_Mkdir(nfs_arg_t *parg,
exportlist_t *pexport,
fsal_op_context_t *pcontext,
nfs_worker_data_t *pworker,
struct svc_req *preq,
nfs_res_t *pres)
{
char *str_dir_name = NULL;
fsal_accessmode_t mode = 0;
cache_entry_t *dir_pentry = NULL;
cache_entry_t *parent_pentry = NULL;
fsal_attrib_list_t parent_attr;
fsal_attrib_list_t attr;
fsal_attrib_list_t *ppre_attr;
fsal_attrib_list_t attr_parent_after;
cache_inode_file_type_t parent_filetype;
fsal_handle_t *pfsal_handle;
fsal_name_t dir_name;
cache_inode_status_t cache_status = CACHE_INODE_SUCCESS;
cache_inode_status_t cache_status_lookup;
cache_inode_create_arg_t create_arg;
int rc = NFS_REQ_OK;
#ifdef _USE_QUOTA
fsal_status_t fsal_status ;
#endif
memset(&create_arg, 0, sizeof(create_arg));
if(isDebug(COMPONENT_NFSPROTO))
{
char str[LEN_FH_STR];
switch (preq->rq_vers)
{
case NFS_V2:
str_dir_name = parg->arg_mkdir2.where.name;
break;
case NFS_V3:
str_dir_name = parg->arg_mkdir3.where.name;
break;
}
nfs_FhandleToStr(preq->rq_vers,
&(parg->arg_mkdir2.where.dir),
&(parg->arg_mkdir3.where.dir),
NULL,
str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs_Mkdir handle: %s name: %s",
str, str_dir_name);
}
if(preq->rq_vers == NFS_V3)
{
/* to avoid setting it on each error case */
pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc.before.attributes_follow = FALSE;
pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc.after.attributes_follow = FALSE;
ppre_attr = NULL;
}
if((parent_pentry = nfs_FhandleToCache(preq->rq_vers,
&(parg->arg_mkdir2.where.dir),
&(parg->arg_mkdir3.where.dir),
NULL,
&(pres->res_dirop2.status),
&(pres->res_mkdir3.status),
NULL,
&parent_attr,
pcontext, &rc)) == NULL)
{
/* Stale NFS FH ? */
goto out;
}
/* get directory attributes before action (for V3 reply) */
ppre_attr = &parent_attr;
/* Extract the filetype */
parent_filetype = cache_inode_fsal_type_convert(parent_attr.type);
/*
* Sanity checks:
*/
if(parent_filetype != DIRECTORY)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_NOTDIR;
break;
case NFS_V3:
pres->res_mkdir3.status = NFS3ERR_NOTDIR;
break;
}
rc = NFS_REQ_OK;
goto out;
}
#ifdef _USE_QUOTA
/* if quota support is active, then we should check is the FSAL allows inode creation or not */
fsal_status = FSAL_check_quota( pexport->fullpath,
FSAL_QUOTA_INODES,
FSAL_OP_CONTEXT_TO_UID( pcontext ) ) ;
if( FSAL_IS_ERROR( fsal_status ) )
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_dirop2.status = NFSERR_DQUOT;
break;
case NFS_V3:
pres->res_mkdir3.status = NFS3ERR_DQUOT;
break;
}
rc = NFS_REQ_OK ;
goto out;
}
#endif /* _USE_QUOTA */
switch (preq->rq_vers)
{
case NFS_V2:
str_dir_name = parg->arg_mkdir2.where.name;
if(parg->arg_mkdir2.attributes.mode != (unsigned int)-1)
{
mode = (fsal_accessmode_t) parg->arg_mkdir2.attributes.mode;
}
else
{
mode = (fsal_accessmode_t) 0;
}
break;
case NFS_V3:
str_dir_name = parg->arg_mkdir3.where.name;
if(parg->arg_mkdir3.attributes.mode.set_it == TRUE)
mode = (fsal_accessmode_t) parg->arg_mkdir3.attributes.mode.set_mode3_u.mode;
else
mode = (fsal_accessmode_t) 0;
break;
}
//if(str_dir_name == NULL || strlen(str_dir_name) == 0)
if(str_dir_name == NULL || *str_dir_name == '\0' )
{
if(preq->rq_vers == NFS_V2)
pres->res_dirop2.status = NFSERR_IO;
if(preq->rq_vers == NFS_V3)
pres->res_mkdir3.status = NFS3ERR_INVAL;
}
else
{
/* Make the directory */
if((cache_status = cache_inode_error_convert(FSAL_str2name(str_dir_name,
0,
&dir_name))) ==
CACHE_INODE_SUCCESS)
{
/*
* Lookup file to see if it exists. If so, use it. Otherwise
* create a new one.
*/
dir_pentry = cache_inode_lookup(parent_pentry,
&dir_name,
&attr,
pcontext,
&cache_status_lookup);
if(cache_status_lookup == CACHE_INODE_NOT_FOUND)
{
/* The create_arg structure contains the information "newly created directory"
* to be passed to cache_inode_new_entry from cache_inode_create */
create_arg.newly_created_dir = TRUE;
/* Create the directory */
if((dir_pentry = cache_inode_create(parent_pentry,
&dir_name,
DIRECTORY,
mode,
&create_arg,
&attr,
pcontext, &cache_status)) != NULL)
{
/*
* Get the FSAL handle for this entry
*/
pfsal_handle = &dir_pentry->handle;
if(preq->rq_vers == NFS_V2)
{
DIROP2resok *d2ok = &pres->res_dirop2.DIROP2res_u.diropok;
/* Build file handle */
if(!nfs2_FSALToFhandle(&d2ok->file, pfsal_handle, pexport))
pres->res_dirop2.status = NFSERR_IO;
else
{
/*
* Build entry
* attributes
*/
if(nfs2_FSALattr_To_Fattr(pexport, &attr,
&d2ok->attributes) == 0)
pres->res_dirop2.status = NFSERR_IO;
else
pres->res_dirop2.status = NFS_OK;
}
}
else
{
MKDIR3resok *d3ok = &pres->res_mkdir3.MKDIR3res_u.resok;
/* Build file handle */
pres->res_mkdir3.status =
nfs3_AllocateFH(&d3ok->obj.post_op_fh3_u.handle);
if(pres->res_mkdir3.status != NFS3_OK)
{
rc = NFS_REQ_OK;
goto out;
}
if(nfs3_FSALToFhandle(&d3ok->obj.post_op_fh3_u.handle,
pfsal_handle, pexport) == 0)
{
gsh_free(d3ok->obj.post_op_fh3_u.handle.data.data_val);
pres->res_mkdir3.status = NFS3ERR_INVAL;
rc = NFS_REQ_OK;
goto out;
}
/* Set Post Op Fh3 structure */
d3ok->obj.handle_follows = TRUE;
/*
* Build entry attributes
*/
nfs_SetPostOpAttr(pexport, &attr, &d3ok->obj_attributes);
/* Get the attributes of the parent after the operation */
if(cache_inode_getattr(parent_pentry,
&attr_parent_after,
pcontext, &cache_status) != CACHE_INODE_SUCCESS)
{
pres->res_mkdir3.status = nfs3_Errno(cache_status);
rc = NFS_REQ_OK;
goto out;
}
/*
* Build Weak Cache Coherency data
*/
nfs_SetWccData(pexport, ppre_attr, &attr_parent_after,
&d3ok->dir_wcc);
pres->res_mkdir3.status = NFS3_OK;
}
rc = NFS_REQ_OK;
goto out;
}
} /* If( cache_status_lookup == CACHE_INODE_NOT_FOUND ) */
else
{
switch (preq->rq_vers)
{
case NFS_V2:
if(cache_status_lookup == CACHE_INODE_SUCCESS)
pres->res_dirop2.status = NFSERR_EXIST;
else
pres->res_dirop2.status = NFSERR_IO;
break;
case NFS_V3:
if(cache_status_lookup == CACHE_INODE_SUCCESS)
pres->res_mkdir3.status = NFS3ERR_EXIST;
else
pres->res_mkdir3.status = NFS3ERR_INVAL;
nfs_SetWccData(pexport, ppre_attr, NULL,
&(pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc));
break;
}
rc = NFS_REQ_OK;
goto out;
}
}
}
/* If we are here, there was an error */
rc = nfs_SetFailedStatus(pexport, preq->rq_vers, cache_status,
&pres->res_dirop2.status, &pres->res_mkdir3.status,
NULL, ppre_attr,
&(pres->res_mkdir3.MKDIR3res_u.resfail.dir_wcc),
NULL, NULL);
out:
/* return references */
if (dir_pentry)
cache_inode_put(dir_pentry);
if (parent_pentry)
cache_inode_put(parent_pentry);
return (rc);
}
int nfs_Symlink(nfs_arg_t *parg,
exportlist_t *pexport,
fsal_op_context_t *pcontext,
nfs_worker_data_t *pworker,
struct svc_req *preq,
nfs_res_t *pres)
{
char *str_symlink_name = NULL;
fsal_name_t symlink_name;
char *str_target_path = NULL;
cache_inode_create_arg_t create_arg;
fsal_accessmode_t mode = 0777;
cache_entry_t *symlink_pentry = NULL;
cache_entry_t *parent_pentry;
cache_inode_file_type_t parent_filetype;
fsal_attrib_list_t parent_attr;
fsal_attrib_list_t attr_symlink;
fsal_attrib_list_t attributes_symlink;
fsal_attrib_list_t attr_parent_after;
fsal_attrib_list_t *ppre_attr;
cache_inode_status_t cache_status;
cache_inode_status_t cache_status_parent;
fsal_handle_t *pfsal_handle;
int rc = NFS_REQ_OK;
#ifdef _USE_QUOTA
fsal_status_t fsal_status ;
#endif
memset(&create_arg, 0, sizeof(create_arg));
if(isDebug(COMPONENT_NFSPROTO))
{
char str[LEN_FH_STR];
switch (preq->rq_vers)
{
case NFS_V2:
str_symlink_name = parg->arg_symlink2.from.name;
str_target_path = parg->arg_symlink2.to;
break;
case NFS_V3:
str_symlink_name = parg->arg_symlink3.where.name;
str_target_path = parg->arg_symlink3.symlink.symlink_data;
break;
}
nfs_FhandleToStr(preq->rq_vers,
&(parg->arg_symlink2.from.dir),
&(parg->arg_symlink3.where.dir),
NULL,
str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs_Symlink handle: %s name: %s target: %s",
str, str_symlink_name, str_target_path);
}
if(preq->rq_vers == NFS_V3)
{
/* to avoid setting it on each error case */
pres->res_symlink3.SYMLINK3res_u.resfail.dir_wcc.before.attributes_follow = FALSE;
pres->res_symlink3.SYMLINK3res_u.resfail.dir_wcc.after.attributes_follow = FALSE;
ppre_attr = NULL;
}
/* Convert directory file handle into a vnode */
if((parent_pentry = nfs_FhandleToCache(preq->rq_vers,
&(parg->arg_symlink2.from.dir),
&(parg->arg_symlink3.where.dir),
NULL,
&(pres->res_stat2),
&(pres->res_symlink3.status),
NULL,
&parent_attr,
pcontext, &rc)) == NULL)
{
/* Stale NFS FH ? */
goto out;;
}
/* get directory attributes before action (for V3 reply) */
ppre_attr = &parent_attr;
/* Extract the filetype */
parent_filetype = cache_inode_fsal_type_convert(parent_attr.type);
/*
* Sanity checks: new directory name must be non-null; parent must be
* a directory.
*/
if(parent_filetype != DIRECTORY)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_stat2 = NFSERR_NOTDIR;
break;
case NFS_V3:
pres->res_symlink3.status = NFS3ERR_NOTDIR;
break;
}
rc = NFS_REQ_OK;
goto out;
}
#ifdef _USE_QUOTA
/* if quota support is active, then we should check is the FSAL allows inode creation or not */
fsal_status = FSAL_check_quota( pexport->fullpath,
FSAL_QUOTA_INODES,
FSAL_OP_CONTEXT_TO_UID( pcontext ) ) ;
if( FSAL_IS_ERROR( fsal_status ) )
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_stat2 = NFSERR_DQUOT ;
break;
case NFS_V3:
pres->res_symlink3.status = NFS3ERR_DQUOT;
break;
}
rc = NFS_REQ_OK;
goto out;
}
#endif /* _USE_QUOTA */
switch (preq->rq_vers)
{
case NFS_V2:
str_symlink_name = parg->arg_symlink2.from.name;
str_target_path = parg->arg_symlink2.to;
break;
case NFS_V3:
str_symlink_name = parg->arg_symlink3.where.name;
str_target_path = parg->arg_symlink3.symlink.symlink_data;
break;
}
if(str_symlink_name == NULL ||
*str_symlink_name == '\0'||
str_target_path == NULL ||
*str_target_path == '\0' ||
FSAL_IS_ERROR(FSAL_str2name(str_symlink_name, 0, &symlink_name)) ||
FSAL_IS_ERROR(FSAL_str2path(str_target_path, 0, &create_arg.link_content)))
{
cache_status = CACHE_INODE_INVALID_ARGUMENT;
}
else
{
/* Make the symlink */
if((symlink_pentry = cache_inode_create(parent_pentry,
&symlink_name,
SYMBOLIC_LINK,
mode,
&create_arg,
&attr_symlink,
pcontext, &cache_status)) != NULL)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_stat2 = NFS_OK;
break;
case NFS_V3:
/* Build file handle */
pfsal_handle = &symlink_pentry->handle;
/* Some clients (like the Spec NFS benchmark) set attributes with the NFSPROC3_SYMLINK request */
if(nfs3_Sattr_To_FSALattr(&attributes_symlink,
&parg->arg_symlink3.symlink.symlink_attributes) == 0)
{
pres->res_create3.status = NFS3ERR_INVAL;
rc = NFS_REQ_OK;
goto out;
}
/* Mode is managed above (in cache_inode_create), there is no need
* to manage it */
if(attributes_symlink.asked_attributes & FSAL_ATTR_MODE)
attributes_symlink.asked_attributes &= ~FSAL_ATTR_MODE;
/* Some clients (like Solaris 10) try to set the size of the file to 0
* at creation time. The FSAL create empty file, so we ignore this */
if(attributes_symlink.asked_attributes & FSAL_ATTR_SIZE)
attributes_symlink.asked_attributes &= ~FSAL_ATTR_SIZE;
if(attributes_symlink.asked_attributes & FSAL_ATTR_SPACEUSED)
attributes_symlink.asked_attributes &= ~FSAL_ATTR_SPACEUSED;
/* If owner or owner_group are set, and the credential was
* squashed, then we must squash the set owner and owner_group.
*/
squash_setattr(&pworker->export_perms,
&pworker->user_credentials,
&attributes_symlink);
/* Are there attributes to be set (additional to the mode) ? */
if(attributes_symlink.asked_attributes != 0ULL &&
attributes_symlink.asked_attributes != FSAL_ATTR_MODE)
{
/* A call to cache_inode_setattr is required */
if(cache_inode_setattr(symlink_pentry,
&attributes_symlink,
pcontext,
FALSE,
&cache_status) != CACHE_INODE_SUCCESS)
{
goto out_error;
}
}
if ((pres->res_symlink3.status =
(nfs3_AllocateFH(&pres->res_symlink3.SYMLINK3res_u
.resok.obj.post_op_fh3_u.handle)))
!= NFS3_OK) {
pres->res_symlink3.status = NFS3ERR_IO;
rc = NFS_REQ_OK;
goto out;
}
if(nfs3_FSALToFhandle
(&pres->res_symlink3.SYMLINK3res_u.resok.obj.post_op_fh3_u.handle,
pfsal_handle, pexport) == 0)
{
gsh_free(pres->res_symlink3.SYMLINK3res_u.resok.obj.
post_op_fh3_u.handle.data.data_val);
pres->res_symlink3.status = NFS3ERR_BADHANDLE;
rc = NFS_REQ_OK;
goto out;
}
/* The the parent pentry attributes for building Wcc Data */
if(cache_inode_getattr(parent_pentry,
&attr_parent_after,
pcontext,
&cache_status_parent)
!= CACHE_INODE_SUCCESS)
{
gsh_free(pres->res_symlink3.SYMLINK3res_u.resok.obj.
post_op_fh3_u.handle.data.data_val);
pres->res_symlink3.status = NFS3ERR_BADHANDLE;
rc = NFS_REQ_OK;
goto out;
}
/* Set Post Op Fh3 structure */
pres->res_symlink3.SYMLINK3res_u.resok.obj.handle_follows = TRUE;
/* Build entry attributes */
nfs_SetPostOpAttr(pexport,
&attr_symlink,
&(pres->res_symlink3.SYMLINK3res_u
.resok.obj_attributes));
/* Build Weak Cache Coherency data */
nfs_SetWccData(pexport,
ppre_attr,
&attr_parent_after,
&(pres->res_symlink3.SYMLINK3res_u.resok.dir_wcc));
pres->res_symlink3.status = NFS3_OK;
break;
} /* switch */
rc = NFS_REQ_OK;
goto out;
}
}
out_error:
rc = nfs_SetFailedStatus(pexport, preq->rq_vers, cache_status,
&pres->res_stat2, &pres->res_symlink3.status,
NULL, ppre_attr,
&(pres->res_symlink3.SYMLINK3res_u.resfail.dir_wcc),
NULL, NULL);
out:
/* return references */
if (parent_pentry)
cache_inode_put(parent_pentry);
if (symlink_pentry)
cache_inode_put(symlink_pentry);
return (rc);
} /* nfs_Symlink */
int nfs_Fsstat(nfs_arg_t *parg,
exportlist_t *pexport,
fsal_op_context_t *pcontext,
nfs_worker_data_t *pworker,
struct svc_req *preq,
nfs_res_t * pres)
{
fsal_dynamicfsinfo_t dynamicinfo;
cache_inode_status_t cache_status;
cache_entry_t *pentry = NULL;
fsal_attrib_list_t attr;
int rc = NFS_REQ_OK;
if(isDebug(COMPONENT_NFSPROTO))
{
char str[LEN_FH_STR];
nfs_FhandleToStr(preq->rq_vers,
&(parg->arg_statfs2),
&(parg->arg_fsstat3.fsroot),
NULL,
str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs_Fsstat handle: %s", str);
}
if(preq->rq_vers == NFS_V3)
{
/* to avoid setting it on each error case */
pres->res_fsstat3.FSSTAT3res_u.resfail.obj_attributes.attributes_follow = FALSE;
}
/* convert file handle to vnode */
if((pentry = nfs_FhandleToCache(preq->rq_vers,
&(parg->arg_statfs2),
&(parg->arg_fsstat3.fsroot),
NULL,
&(pres->res_statfs2.status),
&(pres->res_fsstat3.status),
NULL, NULL, pcontext, &rc)) == NULL)
{
/* Stale NFS FH ? */
/* return NFS_REQ_DROP ; */
goto out;
}
/* Get statistics and convert from cache */
if((cache_status = cache_inode_statfs(pentry,
&dynamicinfo,
pcontext, &cache_status)) == CACHE_INODE_SUCCESS)
{
/* This call is costless, the pentry was cached during call to nfs_FhandleToCache */
if((cache_status = cache_inode_getattr(pentry,
&attr,
pcontext,
&cache_status)) == CACHE_INODE_SUCCESS)
{
LogFullDebug(COMPONENT_NFSPROTO,
"nfs_Fsstat --> dynamicinfo.total_bytes = %zu dynamicinfo.free_bytes = %zu dynamicinfo.avail_bytes = %zu",
dynamicinfo.total_bytes,
dynamicinfo.free_bytes,
dynamicinfo.avail_bytes);
LogFullDebug(COMPONENT_NFSPROTO,
"nfs_Fsstat --> dynamicinfo.total_files = %llu dynamicinfo.free_files = %llu dynamicinfo.avail_files = %llu",
dynamicinfo.total_files,
dynamicinfo.free_files,
dynamicinfo.avail_files);
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_statfs2.STATFS2res_u.info.tsize = NFS2_MAXDATA;
pres->res_statfs2.STATFS2res_u.info.bsize = DEV_BSIZE;
pres->res_statfs2.STATFS2res_u.info.blocks =
dynamicinfo.total_bytes / DEV_BSIZE;
pres->res_statfs2.STATFS2res_u.info.bfree =
dynamicinfo.free_bytes / DEV_BSIZE;
pres->res_statfs2.STATFS2res_u.info.bavail =
dynamicinfo.avail_bytes / DEV_BSIZE;
pres->res_statfs2.status = NFS_OK;
break;
case NFS_V3:
nfs_SetPostOpAttr(pexport,
&attr,
&(pres->res_fsstat3.FSSTAT3res_u
.resok.obj_attributes));
pres->res_fsstat3.FSSTAT3res_u.resok.tbytes = dynamicinfo.total_bytes;
pres->res_fsstat3.FSSTAT3res_u.resok.fbytes = dynamicinfo.free_bytes;
pres->res_fsstat3.FSSTAT3res_u.resok.abytes = dynamicinfo.avail_bytes;
pres->res_fsstat3.FSSTAT3res_u.resok.tfiles = dynamicinfo.total_files;
pres->res_fsstat3.FSSTAT3res_u.resok.ffiles = dynamicinfo.free_files;
pres->res_fsstat3.FSSTAT3res_u.resok.afiles = dynamicinfo.avail_files;
pres->res_fsstat3.FSSTAT3res_u.resok.invarsec = 0; /* volatile FS */
pres->res_fsstat3.status = NFS3_OK;
LogFullDebug(COMPONENT_NFSPROTO,
"nfs_Fsstat --> tbytes=%llu fbytes=%llu abytes=%llu",
pres->res_fsstat3.FSSTAT3res_u.resok.tbytes,
pres->res_fsstat3.FSSTAT3res_u.resok.fbytes,
pres->res_fsstat3.FSSTAT3res_u.resok.abytes);
LogFullDebug(COMPONENT_NFSPROTO,
"nfs_Fsstat --> tfiles=%llu fffiles=%llu afiles=%llu",
pres->res_fsstat3.FSSTAT3res_u.resok.tfiles,
pres->res_fsstat3.FSSTAT3res_u.resok.ffiles,
pres->res_fsstat3.FSSTAT3res_u.resok.afiles);
break;
}
rc = NFS_REQ_OK;
goto out;
}
}
/* At this point we met an error */
if(nfs_RetryableError(cache_status)) {
rc = NFS_REQ_DROP;
goto out;
}
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_statfs2.status,
&pres->res_fsstat3.status,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
rc = NFS_REQ_OK;
out:
/* return references */
if (pentry)
cache_inode_put(pentry);
return (rc);
} /* nfs_Fsstat */
int nfs3_fsstat(nfs_arg_t *arg, struct svc_req *req, nfs_res_t *res)
{
fsal_dynamicfsinfo_t dynamicinfo;
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];
nfs_FhandleToStr(req->rq_vers, &(arg->arg_fsstat3.fsroot), NULL,
str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs3_fsstat handle: %s",
str);
}
/* to avoid setting it on each error case */
res->res_fsstat3.FSSTAT3res_u.resfail.obj_attributes.attributes_follow =
FALSE;
entry = nfs3_FhandleToCache(&arg->arg_fsstat3.fsroot,
&res->res_fsstat3.status,
&rc);
if (entry == NULL) {
/* Status and rc have been set by nfs3_FhandleToCache */
goto out;
}
/* Get statistics and convert from cache */
cache_status = cache_inode_statfs(entry,
&dynamicinfo);
if (cache_status == CACHE_INODE_SUCCESS) {
LogFullDebug(COMPONENT_NFSPROTO,
"nfs_Fsstat --> dynamicinfo.total_bytes=%" PRIu64
" dynamicinfo.free_bytes=%" PRIu64
" dynamicinfo.avail_bytes=%" PRIu64,
dynamicinfo.total_bytes, dynamicinfo.free_bytes,
dynamicinfo.avail_bytes);
LogFullDebug(COMPONENT_NFSPROTO,
"nfs_Fsstat --> dynamicinfo.total_files=%" PRIu64
" dynamicinfo.free_files=%" PRIu64
" dynamicinfo.avail_files=%" PRIu64,
dynamicinfo.total_files, dynamicinfo.free_files,
dynamicinfo.avail_files);
nfs_SetPostOpAttr(entry,
&(res->res_fsstat3.FSSTAT3res_u.resok.
obj_attributes));
res->res_fsstat3.FSSTAT3res_u.resok.tbytes =
dynamicinfo.total_bytes;
res->res_fsstat3.FSSTAT3res_u.resok.fbytes =
dynamicinfo.free_bytes;
res->res_fsstat3.FSSTAT3res_u.resok.abytes =
dynamicinfo.avail_bytes;
res->res_fsstat3.FSSTAT3res_u.resok.tfiles =
dynamicinfo.total_files;
res->res_fsstat3.FSSTAT3res_u.resok.ffiles =
dynamicinfo.free_files;
res->res_fsstat3.FSSTAT3res_u.resok.afiles =
dynamicinfo.avail_files;
/* volatile FS */
res->res_fsstat3.FSSTAT3res_u.resok.invarsec = 0;
res->res_fsstat3.status = NFS3_OK;
LogFullDebug(COMPONENT_NFSPROTO,
"nfs_Fsstat --> tbytes=%llu fbytes=%llu abytes=%llu",
res->res_fsstat3.FSSTAT3res_u.resok.tbytes,
res->res_fsstat3.FSSTAT3res_u.resok.fbytes,
res->res_fsstat3.FSSTAT3res_u.resok.abytes);
LogFullDebug(COMPONENT_NFSPROTO,
"nfs_Fsstat --> tfiles=%llu fffiles=%llu afiles=%llu",
res->res_fsstat3.FSSTAT3res_u.resok.tfiles,
res->res_fsstat3.FSSTAT3res_u.resok.ffiles,
res->res_fsstat3.FSSTAT3res_u.resok.afiles);
rc = NFS_REQ_OK;
goto out;
}
/* At this point we met an error */
if (nfs_RetryableError(cache_status)) {
rc = NFS_REQ_DROP;
goto out;
}
res->res_fsstat3.status = nfs3_Errno(cache_status);
rc = NFS_REQ_OK;
out:
/* return references */
if (entry)
cache_inode_put(entry);
return rc;
} /* nfs3_fsstat */
int nfs_Read(nfs_arg_t *parg,
exportlist_t *pexport,
fsal_op_context_t *pcontext,
nfs_worker_data_t *pworker,
struct svc_req *preq,
nfs_res_t *pres)
{
cache_entry_t *pentry;
fsal_attrib_list_t attr;
fsal_attrib_list_t pre_attr;
cache_inode_status_t cache_status = CACHE_INODE_SUCCESS;
size_t size = 0;
size_t read_size = 0;
fsal_off_t offset = 0;
void *data = NULL;
cache_inode_file_type_t filetype;
fsal_boolean_t eof_met=FALSE;
int rc = NFS_REQ_OK;
if(isDebug(COMPONENT_NFSPROTO))
{
char str[LEN_FH_STR];
switch (preq->rq_vers)
{
case NFS_V2:
offset = parg->arg_read2.offset;
size = parg->arg_read2.count;
break;
case NFS_V3:
offset = parg->arg_read3.offset;
size = parg->arg_read3.count;
}
nfs_FhandleToStr(preq->rq_vers,
&(parg->arg_read2.file),
&(parg->arg_read3.file),
NULL,
str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs_Read handle: %s start: %llx len: %llx",
str, (unsigned long long) offset, (unsigned long long) size);
}
if(preq->rq_vers == NFS_V3)
{
/* to avoid setting it on each error case */
pres->res_read3.READ3res_u.resfail.file_attributes.attributes_follow = FALSE;
/* initialize for read of size 0 */
pres->res_read3.READ3res_u.resok.eof = FALSE;
pres->res_read3.READ3res_u.resok.count = 0;
pres->res_read3.READ3res_u.resok.data.data_val = NULL;
pres->res_read3.READ3res_u.resok.data.data_len = 0;
pres->res_read3.status = NFS3_OK;
}
else if(preq->rq_vers == NFS_V2)
{
/* initialize for read of size 0 */
pres->res_read2.READ2res_u.readok.data.nfsdata2_val = NULL;
pres->res_read2.READ2res_u.readok.data.nfsdata2_len = 0;
pres->res_attr2.status = NFS_OK;
}
/* Convert file handle into a cache entry */
if((pentry = nfs_FhandleToCache(preq->rq_vers,
&(parg->arg_read2.file),
&(parg->arg_read3.file),
NULL,
&(pres->res_read2.status),
&(pres->res_read3.status),
NULL, &pre_attr, pcontext, &rc)) == NULL)
{
/* Stale NFS FH ? */
goto out;
}
if((preq->rq_vers == NFS_V3) && (nfs3_Is_Fh_Xattr(&(parg->arg_read3.file))))
{
rc = nfs3_Read_Xattr(parg, pexport, pcontext, preq, pres);
goto out;
}
if(cache_inode_access(pentry,
FSAL_READ_ACCESS,
pcontext,
&cache_status) != CACHE_INODE_SUCCESS)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_attr2.status = nfs2_Errno(cache_status);
break;
case NFS_V3:
pres->res_read3.status = nfs3_Errno(cache_status);
break;
}
rc = NFS_REQ_OK;
goto out;
}
/* Extract the filetype */
filetype = cache_inode_fsal_type_convert(pre_attr.type);
/* Sanity check: read only from a regular file */
if(filetype != REGULAR_FILE)
{
switch (preq->rq_vers)
{
case NFS_V2:
/*
* In the RFC tell it not good but it does
* not tell what to do ...
*/
pres->res_attr2.status = NFSERR_ISDIR;
break;
case NFS_V3:
if(filetype == DIRECTORY)
pres->res_read3.status = NFS3ERR_ISDIR;
else
pres->res_read3.status = NFS3ERR_INVAL;
break;
}
rc = NFS_REQ_OK;
goto out;
}
/* For MDONLY export, reject write operation */
/* Request of type MDONLY_RO were rejected at the nfs_rpc_dispatcher level */
/* This is done by replying EDQUOT (this error is known for not disturbing the client's requests cache */
if(pexport->access_type == ACCESSTYPE_MDONLY
|| pexport->access_type == ACCESSTYPE_MDONLY_RO)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_attr2.status = NFSERR_DQUOT;
break;
case NFS_V3:
pres->res_read3.status = NFS3ERR_DQUOT;
break;
}
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_read2.status,
&pres->res_read3.status,
pentry,
&(pres->res_read3.READ3res_u.resfail.file_attributes),
NULL, NULL, NULL, NULL, NULL, NULL);
rc = NFS_REQ_OK;
goto out;
}
/* Extract the argument from the request */
switch (preq->rq_vers)
{
case NFS_V2:
offset = parg->arg_read2.offset; /* beginoffset is obsolete */
size = parg->arg_read2.count; /* totalcount is obsolete */
break;
case NFS_V3:
offset = parg->arg_read3.offset;
size = parg->arg_read3.count;
break;
}
/*
* do not exceed maxium READ offset if set
*/
if((pexport->options & EXPORT_OPTION_MAXOFFSETREAD) == EXPORT_OPTION_MAXOFFSETREAD)
{
LogFullDebug(COMPONENT_NFSPROTO,
"-----> Read offset=%llu count=%llu MaxOffSet=%llu",
(unsigned long long) offset,
(unsigned long long) size,
(unsigned long long) pexport->MaxOffsetRead);
if((fsal_off_t) (offset + size) > pexport->MaxOffsetRead)
{
LogEvent(COMPONENT_NFSPROTO,
"NFS READ: A client tryed to violate max file size %llu for exportid #%hu",
(unsigned long long) pexport->MaxOffsetRead, pexport->id);
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_attr2.status = NFSERR_DQUOT;
break;
case NFS_V3:
pres->res_read3.status = NFS3ERR_INVAL;
break;
}
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_read2.status,
&pres->res_read3.status,
pentry,
&(pres->res_read3.READ3res_u.resfail.file_attributes),
NULL, NULL, NULL, NULL, NULL, NULL);
rc = NFS_REQ_OK;
goto out;
}
}
/*
* We should not exceed the FSINFO rtmax field for
* the size
*/
if(((pexport->options & EXPORT_OPTION_MAXREAD) == EXPORT_OPTION_MAXREAD) &&
size > pexport->MaxRead)
{
/*
* The client asked for too much, normally
* this should not happen because the client
* is calling nfs_Fsinfo at mount time and so
* is aware of the server maximum write size
*/
size = pexport->MaxRead;
}
if(size == 0)
{
nfs_read_ok(pexport, preq, pres, NULL, 0, &pre_attr, 0);
rc = NFS_REQ_OK;
goto out;
}
else
{
data = gsh_malloc(size);
if(data == NULL)
{
rc = NFS_REQ_DROP;
goto out;
}
if((cache_inode_rdwr(pentry,
CACHE_INODE_READ,
offset,
size,
&read_size,
data,
&eof_met,
pcontext,
CACHE_INODE_SAFE_WRITE_TO_FS,
&cache_status) == CACHE_INODE_SUCCESS) &&
(cache_inode_getattr(pentry, &attr, pcontext,
&cache_status)) == CACHE_INODE_SUCCESS)
{
nfs_read_ok(pexport, preq, pres, data, read_size, &attr,
((offset + read_size) >= attr.filesize));
rc = NFS_REQ_OK;
goto out;
}
gsh_free(data);
}
/* If we are here, there was an error */
if(nfs_RetryableError(cache_status))
{
rc = NFS_REQ_DROP;
goto out;
}
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_read2.status,
&pres->res_read3.status,
pentry,
&(pres->res_read3.READ3res_u.resfail.file_attributes),
NULL, NULL, NULL, NULL, NULL, NULL);
rc = NFS_REQ_OK;
out:
/* return references */
if (pentry)
cache_inode_put(pentry);
return (rc);
} /* nfs_Read */
int nfs3_readlink(nfs_arg_t *arg, struct svc_req *req, nfs_res_t *res)
{
cache_entry_t *entry = NULL;
cache_inode_status_t cache_status;
struct gsh_buffdesc link_buffer = {
.addr = NULL,
.len = 0
};
int rc = NFS_REQ_OK;
if (isDebug(COMPONENT_NFSPROTO)) {
char str[LEN_FH_STR];
nfs_FhandleToStr(req->rq_vers,
&(arg->arg_readlink3.symlink),
NULL, str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs_Readlink handle: %s",
str);
}
/* to avoid setting it on each error case */
res->res_readlink3.READLINK3res_u.resfail.symlink_attributes.
attributes_follow = false;
entry = nfs3_FhandleToCache(&arg->arg_readlink3.symlink,
&res->res_readlink3.status,
&rc);
if (entry == NULL) {
/* Status and rc have been set by nfs3_FhandleToCache */
goto out;
}
/* Sanity Check: the entry must be a link */
if (entry->type != SYMBOLIC_LINK) {
res->res_readlink3.status = NFS3ERR_INVAL;
rc = NFS_REQ_OK;
goto out;
}
cache_status = cache_inode_readlink(entry, &link_buffer);
if (cache_status != CACHE_INODE_SUCCESS) {
res->res_readlink3.status = nfs3_Errno(cache_status);
nfs_SetPostOpAttr(entry,
&res->res_readlink3.READLINK3res_u.resfail.
symlink_attributes);
if (nfs_RetryableError(cache_status))
rc = NFS_REQ_DROP;
goto out;
}
/* Reply to the client */
res->res_readlink3.READLINK3res_u.resok.data = link_buffer.addr;
nfs_SetPostOpAttr(entry,
&res->res_readlink3.READLINK3res_u.
resok.symlink_attributes);
res->res_readlink3.status = NFS3_OK;
rc = NFS_REQ_OK;
out:
/* return references */
if (entry)
cache_inode_put(entry);
return rc;
} /* nfs3_readlink */
/**
* @brief Free the result structure allocated for nfs3_readlink.
*
* This function frees the result structure allocated for
* nfs3_readlink.
*
* @param[in,out] res Result structure
*
*/
void nfs3_readlink_free(nfs_res_t *res)
{
if (res->res_readlink3.status == NFS3_OK)
gsh_free(res->res_readlink3.READLINK3res_u.resok.data);
}
int nfs3_rename(nfs_arg_t *arg, struct svc_req *req, nfs_res_t *res)
{
const char *entry_name = arg->arg_rename3.from.name;
const char *new_entry_name = arg->arg_rename3.to.name;
cache_entry_t *parent_entry = NULL;
cache_entry_t *new_parent_entry = NULL;
cache_inode_status_t cache_status;
short to_exportid = 0;
short from_exportid = 0;
int rc = NFS_REQ_OK;
pre_op_attr pre_parent = {
.attributes_follow = false
};
pre_op_attr pre_new_parent = {
.attributes_follow = false
};
if (isDebug(COMPONENT_NFSPROTO)) {
char strto[LEN_FH_STR], strfrom[LEN_FH_STR];
nfs_FhandleToStr(req->rq_vers,
&arg->arg_rename3.from.dir,
NULL,
strfrom);
nfs_FhandleToStr(req->rq_vers,
&arg->arg_rename3.to.dir,
NULL,
strto);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs_Rename from handle: %s name %s to handle: %s name: %s",
strfrom, entry_name, strto, new_entry_name);
}
/* to avoid setting it on each error case */
res->res_rename3.RENAME3res_u.resfail.fromdir_wcc.before.
attributes_follow = FALSE;
res->res_rename3.RENAME3res_u.resfail.fromdir_wcc.after.
attributes_follow = FALSE;
res->res_rename3.RENAME3res_u.resfail.todir_wcc.before.
attributes_follow = FALSE;
res->res_rename3.RENAME3res_u.resfail.todir_wcc.after.
attributes_follow = FALSE;
/* Get the exportids for the two handles. */
to_exportid = nfs3_FhandleToExportId(&(arg->arg_rename3.to.dir));
from_exportid = nfs3_FhandleToExportId(&(arg->arg_rename3.from.dir));
/* Validate the to_exportid */
if (to_exportid < 0 || from_exportid < 0) {
LogInfo(COMPONENT_DISPATCH,
"NFS%d RENAME Request from client %s has badly formed handle for to dir",
req->rq_vers,
op_ctx->client
? op_ctx->client->hostaddr_str
: "unknown client");
/* Bad handle, report to client */
res->res_rename3.status = NFS3ERR_BADHANDLE;
goto out;
}
/* Both objects have to be in the same filesystem */
if (to_exportid != from_exportid) {
res->res_rename3.status = NFS3ERR_XDEV;
goto out;
}
/* Convert fromdir file handle into a cache_entry */
parent_entry = nfs3_FhandleToCache(&arg->arg_rename3.from.dir,
&res->res_create3.status,
&rc);
if (parent_entry == NULL) {
/* Status and rc have been set by nfs3_FhandleToCache */
goto out;
}
nfs_SetPreOpAttr(parent_entry, &pre_parent);
/* Convert todir file handle into a cache_entry */
new_parent_entry = nfs3_FhandleToCache(&arg->arg_rename3.to.dir,
&res->res_create3.status,
&rc);
if (new_parent_entry == NULL) {
/* Status and rc have been set by nfs3_FhandleToCache */
goto out;
}
nfs_SetPreOpAttr(new_parent_entry, &pre_new_parent);
if (entry_name == NULL || *entry_name == '\0' || new_entry_name == NULL
|| *new_entry_name == '\0') {
cache_status = CACHE_INODE_INVALID_ARGUMENT;
goto out_fail;
}
cache_status = cache_inode_rename(parent_entry,
entry_name,
new_parent_entry,
new_entry_name);
if (cache_status != CACHE_INODE_SUCCESS)
goto out_fail;
res->res_rename3.status = NFS3_OK;
nfs_SetWccData(&pre_parent, parent_entry,
&res->res_rename3.RENAME3res_u.resok.fromdir_wcc);
nfs_SetWccData(&pre_new_parent, new_parent_entry,
&res->res_rename3.RENAME3res_u.resok.todir_wcc);
rc = NFS_REQ_OK;
goto out;
out_fail:
res->res_rename3.status = nfs3_Errno(cache_status);
nfs_SetWccData(&pre_parent, parent_entry,
&res->res_rename3.RENAME3res_u.resfail.fromdir_wcc);
nfs_SetWccData(&pre_new_parent, new_parent_entry,
&res->res_rename3.RENAME3res_u.resfail.todir_wcc);
/* If we are here, there was an error */
if (nfs_RetryableError(cache_status))
rc = NFS_REQ_DROP;
out:
if (parent_entry)
cache_inode_put(parent_entry);
if (new_parent_entry)
cache_inode_put(new_parent_entry);
return rc;
}
/**
* @brief Free the result structure allocated for nfs3_rename.
*
* This function frees the result structure allocated for nfs3_rename.
*
* @param[in,out] res Result structure
*
*/
void nfs3_rename_free(nfs_res_t *res)
{
/* Nothing to do here */
}
int nfs3_fsstat(nfs_arg_t *arg, struct svc_req *req, nfs_res_t *res)
{
fsal_dynamicfsinfo_t dynamicinfo;
fsal_status_t fsal_status;
struct fsal_obj_handle *obj = NULL;
int rc = NFS_REQ_OK;
if (isDebug(COMPONENT_NFSPROTO)) {
char str[LEN_FH_STR];
nfs_FhandleToStr(req->rq_msg.cb_vers,
&(arg->arg_fsstat3.fsroot),
NULL, str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs3_fsstat handle: %s",
str);
}
/* to avoid setting it on each error case */
res->res_fsstat3.FSSTAT3res_u.resfail.obj_attributes.attributes_follow =
FALSE;
obj = nfs3_FhandleToCache(&arg->arg_fsstat3.fsroot,
&res->res_fsstat3.status,
&rc);
if (obj == NULL) {
/* Status and rc have been set by nfs3_FhandleToCache */
return rc;
}
/* Get statistics and convert from FSAL */
fsal_status = fsal_statfs(obj, &dynamicinfo);
if (FSAL_IS_ERROR(fsal_status)) {
/* At this point we met an error */
LogFullDebug(COMPONENT_NFSPROTO,
"failed statfs: fsal_status=%s",
fsal_err_txt(fsal_status));
if (nfs_RetryableError(fsal_status.major)) {
/* Drop retryable errors. */
rc = NFS_REQ_DROP;
} else {
res->res_fsstat3.status =
nfs3_Errno_status(fsal_status);
rc = NFS_REQ_OK;
}
goto out;
}
LogFullDebug(COMPONENT_NFSPROTO,
"nfs_Fsstat --> dynamicinfo.total_bytes=%" PRIu64
" dynamicinfo.free_bytes=%" PRIu64
" dynamicinfo.avail_bytes=%" PRIu64,
dynamicinfo.total_bytes, dynamicinfo.free_bytes,
dynamicinfo.avail_bytes);
LogFullDebug(COMPONENT_NFSPROTO,
"nfs_Fsstat --> dynamicinfo.total_files=%" PRIu64
" dynamicinfo.free_files=%" PRIu64
" dynamicinfo.avail_files=%" PRIu64,
dynamicinfo.total_files, dynamicinfo.free_files,
dynamicinfo.avail_files);
nfs_SetPostOpAttr(obj,
&res->res_fsstat3.FSSTAT3res_u.resok.obj_attributes,
NULL);
res->res_fsstat3.FSSTAT3res_u.resok.tbytes = dynamicinfo.total_bytes;
res->res_fsstat3.FSSTAT3res_u.resok.fbytes = dynamicinfo.free_bytes;
res->res_fsstat3.FSSTAT3res_u.resok.abytes = dynamicinfo.avail_bytes;
res->res_fsstat3.FSSTAT3res_u.resok.tfiles = dynamicinfo.total_files;
res->res_fsstat3.FSSTAT3res_u.resok.ffiles = dynamicinfo.free_files;
res->res_fsstat3.FSSTAT3res_u.resok.afiles = dynamicinfo.avail_files;
/* volatile FS */
res->res_fsstat3.FSSTAT3res_u.resok.invarsec = 0;
res->res_fsstat3.status = NFS3_OK;
LogFullDebug(COMPONENT_NFSPROTO,
"nfs_Fsstat --> tbytes=%llu fbytes=%llu abytes=%llu",
res->res_fsstat3.FSSTAT3res_u.resok.tbytes,
res->res_fsstat3.FSSTAT3res_u.resok.fbytes,
res->res_fsstat3.FSSTAT3res_u.resok.abytes);
LogFullDebug(COMPONENT_NFSPROTO,
"nfs_Fsstat --> tfiles=%llu fffiles=%llu afiles=%llu",
res->res_fsstat3.FSSTAT3res_u.resok.tfiles,
res->res_fsstat3.FSSTAT3res_u.resok.ffiles,
res->res_fsstat3.FSSTAT3res_u.resok.afiles);
rc = NFS_REQ_OK;
out:
/* return references */
obj->obj_ops.put_ref(obj);
return rc;
} /* nfs3_fsstat */
int nfs_Remove(nfs_arg_t *parg,
exportlist_t *pexport,
fsal_op_context_t *pcontext,
nfs_worker_data_t *pworker,
struct svc_req *preq,
nfs_res_t *pres)
{
cache_entry_t *parent_pentry = NULL;
cache_entry_t *pentry_child = NULL;
fsal_attrib_list_t pre_parent_attr;
fsal_attrib_list_t pentry_child_attr;
fsal_attrib_list_t parent_attr;
fsal_attrib_list_t *pparent_attr = NULL;
cache_inode_file_type_t filetype;
cache_inode_file_type_t childtype;
cache_inode_status_t cache_status;
char *file_name = NULL;
fsal_name_t name;
int rc = NFS_REQ_OK;
if(isDebug(COMPONENT_NFSPROTO))
{
char str[LEN_FH_STR];
switch (preq->rq_vers)
{
case NFS_V2:
file_name = parg->arg_remove2.name;
break;
case NFS_V3:
file_name = parg->arg_remove3.object.name;
break;
}
nfs_FhandleToStr(preq->rq_vers,
&(parg->arg_create2.where.dir),
&(parg->arg_create3.where.dir),
NULL,
str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs_Remove handle: %s name: %s",
str, file_name);
}
if(preq->rq_vers == NFS_V3)
{
/* to avoid setting it on each error case */
pres->res_remove3.REMOVE3res_u.resfail.dir_wcc.before.attributes_follow = FALSE;
pres->res_remove3.REMOVE3res_u.resfail.dir_wcc.after.attributes_follow = FALSE;
pparent_attr = NULL;
}
/* Convert file handle into a pentry */
if((parent_pentry = nfs_FhandleToCache(preq->rq_vers,
&(parg->arg_remove2.dir),
&(parg->arg_remove3.object.dir),
NULL,
&(pres->res_dirop2.status),
&(pres->res_remove3.status),
NULL,
&pre_parent_attr,
pcontext, &rc)) == NULL)
{
/* Stale NFS FH ? */
goto out;
}
if((preq->rq_vers == NFS_V3) && (nfs3_Is_Fh_Xattr(&(parg->arg_remove3.object.dir)))) {
rc = nfs3_Remove_Xattr(parg, pexport, pcontext, preq, pres);
goto out;
}
/* get directory attributes before action (for V3 reply) */
pparent_attr = &pre_parent_attr;
/* Extract the filetype */
filetype = cache_inode_fsal_type_convert(pre_parent_attr.type);
/*
* Sanity checks: new directory name must be non-null; parent must be
* a directory.
*/
if(filetype != DIRECTORY)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_stat2 = NFSERR_NOTDIR;
break;
case NFS_V3:
pres->res_remove3.status = NFS3ERR_NOTDIR;
break;
}
rc = NFS_REQ_OK;
goto out;
}
switch (preq->rq_vers)
{
case NFS_V2:
file_name = parg->arg_remove2.name;
break;
case NFS_V3:
file_name = parg->arg_remove3.object.name;
break;
}
//if(file_name == NULL || strlen(file_name) == 0)
if(file_name == NULL || *file_name == '\0' )
{
cache_status = CACHE_INODE_INVALID_ARGUMENT; /* for lack of better... */
}
else
{
if((cache_status = cache_inode_error_convert(FSAL_str2name(file_name,
0,
&name))) ==
CACHE_INODE_SUCCESS)
{
/*
* Lookup to the child entry to check if it is a directory
*
*/
if((pentry_child = cache_inode_lookup(parent_pentry,
&name,
&pentry_child_attr,
pcontext,
&cache_status)) != NULL)
{
/* Extract the filetype */
childtype = cache_inode_fsal_type_convert(pentry_child_attr.type);
/*
* Sanity check: make sure we are about to remove a directory
*/
if(childtype == DIRECTORY)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_stat2 = NFSERR_ISDIR;
break;
case NFS_V3:
pres->res_remove3.status = NFS3ERR_ISDIR;
break;
}
rc = NFS_REQ_OK;
goto out;
}
LogFullDebug(COMPONENT_NFSPROTO,
"==== NFS REMOVE ====> Trying to remove file %s",
name.name);
/*
* Remove the entry.
*/
if(cache_inode_remove(parent_pentry,
&name,
&parent_attr,
pcontext, &cache_status) == CACHE_INODE_SUCCESS)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_stat2 = NFS_OK;
break;
case NFS_V3:
/* Build Weak Cache Coherency data */
nfs_SetWccData(pexport,
pparent_attr,
&parent_attr,
&(pres->res_remove3.REMOVE3res_u.resok.dir_wcc));
pres->res_remove3.status = NFS3_OK;
break;
}
rc = NFS_REQ_OK;
goto out;
}
}
}
}
/* If we are here, there was an error */
rc = nfs_SetFailedStatus(pexport, preq->rq_vers, cache_status,
&pres->res_stat2,
&pres->res_remove3.status,
NULL,
pparent_attr,
&(pres->res_remove3.REMOVE3res_u.resfail.dir_wcc),
NULL, NULL);
out:
/* return references */
if (pentry_child)
cache_inode_put(pentry_child);
if (parent_pentry)
cache_inode_put(parent_pentry);
return (rc);
} /* nfs_Remove */
int nfs3_lookup(nfs_arg_t *arg, struct svc_req *req, nfs_res_t *res)
{
struct fsal_obj_handle *obj_dir = NULL;
struct fsal_obj_handle *obj_file = NULL;
fsal_status_t fsal_status;
char *name = NULL;
int rc = NFS_REQ_OK;
struct attrlist attrs;
/* We have the option of not sending attributes, so set ATTR_RDATTR_ERR.
*/
fsal_prepare_attrs(&attrs, ATTRS_NFS3 | ATTR_RDATTR_ERR);
if (isDebug(COMPONENT_NFSPROTO)) {
char str[LEN_FH_STR];
name = arg->arg_lookup3.what.name;
nfs_FhandleToStr(req->rq_msg.cb_vers,
&(arg->arg_lookup3.what.dir),
NULL, str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs_Lookup handle: %s name: %s",
str, name);
}
/* to avoid setting it on each error case */
res->res_lookup3.LOOKUP3res_u.resfail.dir_attributes.attributes_follow =
FALSE;
obj_dir = nfs3_FhandleToCache(&arg->arg_lookup3.what.dir,
&res->res_lookup3.status,
&rc);
if (obj_dir == NULL) {
/* Status and rc have been set by nfs3_FhandleToCache */
goto out;
}
name = arg->arg_lookup3.what.name;
fsal_status = fsal_lookup(obj_dir, name, &obj_file, &attrs);
if (FSAL_IS_ERROR(fsal_status)) {
/* If we are here, there was an error */
if (nfs_RetryableError(fsal_status.major)) {
rc = NFS_REQ_DROP;
goto out;
}
res->res_lookup3.status = nfs3_Errno_status(fsal_status);
nfs_SetPostOpAttr(obj_dir,
&res->res_lookup3.LOOKUP3res_u.resfail.
dir_attributes,
NULL);
} else {
/* Build FH */
if (nfs3_FSALToFhandle(
true,
&res->res_lookup3.LOOKUP3res_u.resok.object,
obj_file,
op_ctx->ctx_export)) {
/* Build entry attributes */
nfs_SetPostOpAttr(obj_file,
&res->res_lookup3.LOOKUP3res_u.
resok.obj_attributes,
&attrs);
/* Build directory attributes */
nfs_SetPostOpAttr(obj_dir,
&res->res_lookup3.
LOOKUP3res_u.resok.dir_attributes,
NULL);
res->res_lookup3.status = NFS3_OK;
} else {
res->res_lookup3.status = NFS3ERR_BADHANDLE;
}
}
rc = NFS_REQ_OK;
out:
/* Release the attributes. */
fsal_release_attrs(&attrs);
/* return references */
if (obj_dir)
obj_dir->obj_ops.put_ref(obj_dir);
if (obj_file)
obj_file->obj_ops.put_ref(obj_file);
return rc;
} /* nfs3_lookup */
/**
*
* @brief The NFSPROC3_LINK
*
* The NFSPROC3_LINK.
*
* @param[in] arg NFS argument union
* @param[in] req SVC request related to this call
* @param[out] res Structure to contain the result of the call
*
* @retval NFS_REQ_OK if successful
* @retval NFS_REQ_DROP if failed but retryable
* @retval NFS_REQ_FAILED if failed and not retryable
*
*/
int nfs3_link(nfs_arg_t *arg, struct svc_req *req, nfs_res_t *res)
{
struct LINK3args *l3_arg = &arg->arg_link3;
struct LINK3res *l3_res = &res->res_link3;
const char *link_name = l3_arg->link.name;
struct fsal_obj_handle *target_obj = NULL;
struct fsal_obj_handle *parent_obj = NULL;
pre_op_attr pre_parent = {0};
fsal_status_t fsal_status = {0, 0};
int rc = NFS_REQ_OK;
if (isDebug(COMPONENT_NFSPROTO)) {
char strto[LEN_FH_STR], strfrom[LEN_FH_STR];
nfs_FhandleToStr(req->rq_msg.cb_vers, &l3_arg->file,
NULL, strfrom);
nfs_FhandleToStr(req->rq_msg.cb_vers, &l3_arg->link.dir,
NULL, strto);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs3_link handle: %s to handle: %s name: %s",
strfrom, strto, link_name);
}
/* to avoid setting it on each error case */
l3_res->LINK3res_u.resfail.file_attributes.attributes_follow = FALSE;
l3_res->LINK3res_u.resfail.linkdir_wcc.before.attributes_follow = FALSE;
l3_res->LINK3res_u.resfail.linkdir_wcc.after.attributes_follow = FALSE;
l3_res->status = nfs3_verify_exportid(l3_arg, req);
if (l3_res->status != NFS3_OK)
return rc;
parent_obj = nfs3_FhandleToCache(&l3_arg->link.dir, &l3_res->status,
&rc);
if (parent_obj == NULL)
return rc; /* Status and rc are set by nfs3_FhandleToCache */
nfs_SetPreOpAttr(parent_obj, &pre_parent);
target_obj = nfs3_FhandleToCache(&l3_arg->file, &l3_res->status, &rc);
if (target_obj == NULL) {
parent_obj->obj_ops.put_ref(parent_obj);
return rc; /* Status and rc are set by nfs3_FhandleToCache */
}
if (parent_obj->type != DIRECTORY) {
l3_res->status = NFS3ERR_NOTDIR;
goto out;
}
if (link_name == NULL || *link_name == '\0') {
l3_res->status = NFS3ERR_INVAL;
goto out;
}
fsal_status = fsal_link(target_obj, parent_obj, link_name);
if (FSAL_IS_ERROR(fsal_status)) {
/* If we are here, there was an error */
LogFullDebug(COMPONENT_NFSPROTO,
"failed link: fsal_status=%s",
fsal_err_txt(fsal_status));
if (nfs_RetryableError(fsal_status.major)) {
rc = NFS_REQ_DROP;
goto out;
}
l3_res->status = nfs3_Errno_status(fsal_status);
nfs_SetPostOpAttr(target_obj,
&l3_res->LINK3res_u.resfail.file_attributes,
NULL);
nfs_SetWccData(&pre_parent, parent_obj,
&l3_res->LINK3res_u.resfail.linkdir_wcc);
} else {
nfs_SetPostOpAttr(target_obj,
&l3_res->LINK3res_u.resok.file_attributes,
NULL);
nfs_SetWccData(&pre_parent, parent_obj,
&l3_res->LINK3res_u.resok.linkdir_wcc);
l3_res->status = NFS3_OK;
}
out:
/* return references */
target_obj->obj_ops.put_ref(target_obj);
parent_obj->obj_ops.put_ref(parent_obj);
return rc;
} /* nfs3_link */
int nfs3_rmdir(nfs_arg_t *arg,
nfs_worker_data_t *worker,
struct svc_req *req, nfs_res_t *res)
{
cache_entry_t *parent_entry = NULL;
cache_entry_t *child_entry = NULL;
pre_op_attr pre_parent = {
.attributes_follow = false
};
cache_inode_status_t cache_status;
const char *name = arg->arg_rmdir3.object.name;
int rc = NFS_REQ_OK;
if (isDebug(COMPONENT_NFSPROTO)) {
char str[LEN_FH_STR];
nfs_FhandleToStr(req->rq_vers,
&arg->arg_rmdir3.object.dir,
NULL,
str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs3_rmdir handle: %s "
"name: %s", str, name);
}
/* Convert file handle into a pentry */
/* to avoid setting it on each error case */
res->res_rmdir3.RMDIR3res_u.resfail.dir_wcc.before.attributes_follow =
FALSE;
res->res_rmdir3.RMDIR3res_u.resfail.dir_wcc.after.attributes_follow =
FALSE;
parent_entry = nfs3_FhandleToCache(&arg->arg_rmdir3.object.dir,
&res->res_rmdir3.status,
&rc);
if (parent_entry == NULL) {
/* Status and rc have been set by nfs3_FhandleToCache */
goto out;
}
nfs_SetPreOpAttr(parent_entry, &pre_parent);
/* Sanity checks: directory name must be non-null; parent
* must be a directory.
*/
if (parent_entry->type != DIRECTORY) {
res->res_rmdir3.status = NFS3ERR_NOTDIR;
rc = NFS_REQ_OK;
goto out;
}
if ((name == NULL) || (*name == '\0')) {
cache_status = CACHE_INODE_INVALID_ARGUMENT;
goto out_fail;
}
/* Lookup to the entry to be removed to check that it is a
* directory
*/
cache_status = cache_inode_lookup(parent_entry,
name,
&child_entry);
if (child_entry != NULL) {
/* Sanity check: make sure we are about to remove a
* directory
*/
if (child_entry->type != DIRECTORY) {
res->res_rmdir3.status = NFS3ERR_NOTDIR;
rc = NFS_REQ_OK;
goto out;
}
}
cache_status = cache_inode_remove(parent_entry, name);
if (cache_status != CACHE_INODE_SUCCESS)
goto out_fail;
nfs_SetWccData(&pre_parent, parent_entry,
&res->res_rmdir3.RMDIR3res_u.resok.dir_wcc);
res->res_rmdir3.status = NFS3_OK;
rc = NFS_REQ_OK;
goto out;
out_fail:
res->res_rmdir3.status = nfs3_Errno(cache_status);
nfs_SetWccData(&pre_parent, parent_entry,
&res->res_rmdir3.RMDIR3res_u.resfail.dir_wcc);
/* If we are here, there was an error */
if (nfs_RetryableError(cache_status))
rc = NFS_REQ_DROP;
out:
/* return references */
if (child_entry)
cache_inode_put(child_entry);
if (parent_entry)
cache_inode_put(parent_entry);
return rc;
} /* nfs3_rmdir */
/**
* @brief Free the result structure allocated for nfs3_rmdir
*
* This function frees the result structure allocated for nfs3_rmdir.
*
* @param[in,out] res Result structure
*
*/
void nfs3_rmdir_free(nfs_res_t *res)
{
return;
}
int nfs3_remove(nfs_arg_t *arg, struct svc_req *req, nfs_res_t *res)
{
struct fsal_obj_handle *parent_obj = NULL;
struct fsal_obj_handle *child_obj = NULL;
pre_op_attr pre_parent = {
.attributes_follow = false
};
fsal_status_t fsal_status;
const char *name = arg->arg_remove3.object.name;
int rc = NFS_REQ_OK;
if (isDebug(COMPONENT_NFSPROTO)) {
char str[LEN_FH_STR];
nfs_FhandleToStr(req->rq_msg.cb_vers,
&arg->arg_create3.where.dir,
NULL,
str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs_Remove handle: %s name: %s",
str, name);
}
/* Convert file handle into a pentry */
/* to avoid setting it on each error case */
res->res_remove3.REMOVE3res_u.resfail.dir_wcc.before.attributes_follow =
FALSE;
res->res_remove3.REMOVE3res_u.resfail.dir_wcc.after.attributes_follow =
FALSE;
parent_obj = nfs3_FhandleToCache(&arg->arg_remove3.object.dir,
&res->res_remove3.status,
&rc);
if (parent_obj == NULL) {
/* Status and rc have been set by nfs3_FhandleToCache */
goto out;
}
nfs_SetPreOpAttr(parent_obj, &pre_parent);
/* Sanity checks: file name must be non-null; parent must be a
* directory.
*/
if (parent_obj->type != DIRECTORY) {
res->res_remove3.status = NFS3ERR_NOTDIR;
rc = NFS_REQ_OK;
goto out;
}
if (name == NULL || *name == '\0') {
fsal_status = fsalstat(ERR_FSAL_INVAL, 0);
goto out_fail;
}
/* Lookup the child entry to verify that it is not a directory */
fsal_status = fsal_lookup(parent_obj, name, &child_obj, NULL);
if (!FSAL_IS_ERROR(fsal_status)) {
/* Sanity check: make sure we are not removing a
* directory
*/
if (child_obj->type == DIRECTORY) {
res->res_remove3.status = NFS3ERR_ISDIR;
rc = NFS_REQ_OK;
goto out;
}
}
LogFullDebug(COMPONENT_NFSPROTO, "Trying to remove file %s", name);
/* Remove the entry. */
fsal_status = fsal_remove(parent_obj, name);
if (FSAL_IS_ERROR(fsal_status))
goto out_fail;
/* Build Weak Cache Coherency data */
nfs_SetWccData(&pre_parent, parent_obj,
&res->res_remove3.REMOVE3res_u.resok.dir_wcc);
res->res_remove3.status = NFS3_OK;
rc = NFS_REQ_OK;
goto out;
out_fail:
res->res_remove3.status = nfs3_Errno_status(fsal_status);
nfs_SetWccData(&pre_parent, parent_obj,
&res->res_remove3.REMOVE3res_u.resfail.dir_wcc);
if (nfs_RetryableError(fsal_status.major))
rc = NFS_REQ_DROP;
out:
/* return references */
if (child_obj)
child_obj->obj_ops.put_ref(child_obj);
if (parent_obj)
parent_obj->obj_ops.put_ref(parent_obj);
return rc;
} /* nfs3_remove */
/**
* @brief Free the result structure allocated for nfs3_remove.
*
* This function frees the result structure allocated for nfs3_remove.
*
* @param[in,out] res Result structure
*
*/
void nfs3_remove_free(nfs_res_t *res)
{
/* Nothing to do here */
}
int nfs_Write(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[] = "nfs_Write";
cache_entry_t *pentry;
fsal_attrib_list_t attr;
fsal_attrib_list_t pre_attr;
fsal_attrib_list_t *ppre_attr;
int rc;
cache_inode_status_t cache_status = CACHE_INODE_SUCCESS;
cache_content_status_t content_status;
fsal_seek_t seek_descriptor;
fsal_size_t size = 0;
fsal_size_t written_size;
fsal_off_t offset = 0;
caddr_t data = NULL;
enum stable_how stable; /* NFS V3 storage stability, see RFC1813 page 50 */
cache_inode_file_type_t filetype;
fsal_boolean_t eof_met;
uint64_t stable_flag = FSAL_SAFE_WRITE_TO_FS;
if(isDebug(COMPONENT_NFSPROTO))
{
char str[LEN_FH_STR], *stables = "";
switch (preq->rq_vers)
{
case NFS_V2:
offset = parg->arg_write2.offset;
size = parg->arg_write2.data.nfsdata2_len;
stables = "FILE_SYNC";
break;
case NFS_V3:
offset = parg->arg_write3.offset;
size = parg->arg_write3.count;
switch (parg->arg_write3.stable)
{
case UNSTABLE: stables = "UNSTABLE"; break;
case DATA_SYNC: stables = "DATA_SYNC"; break;
case FILE_SYNC: stables = "FILE_SYNC"; break;
}
}
nfs_FhandleToStr(preq->rq_vers,
&(parg->arg_write2.file),
&(parg->arg_write3.file),
NULL,
str);
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs_Write handle: %s start: %llx len: %llx %s",
str,
(unsigned long long) offset,
(unsigned long long) size,
stables);
}
cache_content_policy_data_t datapol;
datapol.UseMaxCacheSize = FALSE;
if(preq->rq_vers == NFS_V3)
{
/* to avoid setting it on each error case */
pres->res_write3.WRITE3res_u.resfail.file_wcc.before.attributes_follow = FALSE;
pres->res_write3.WRITE3res_u.resfail.file_wcc.after.attributes_follow = FALSE;
ppre_attr = NULL;
}
/* Convert file handle into a cache entry */
if((pentry = nfs_FhandleToCache(preq->rq_vers,
&(parg->arg_write2.file),
&(parg->arg_write3.file),
NULL,
&(pres->res_attr2.status),
&(pres->res_write3.status),
NULL, &pre_attr, pcontext, pclient, ht, &rc)) == NULL)
{
/* Stale NFS FH ? */
return rc;
}
if((preq->rq_vers == NFS_V3) && (nfs3_Is_Fh_Xattr(&(parg->arg_write3.file))))
return nfs3_Write_Xattr(parg, pexport, pcontext, pclient, ht, preq, pres);
/* get directory attributes before action (for V3 reply) */
ppre_attr = &pre_attr;
/* Extract the filetype */
filetype = cache_inode_fsal_type_convert(pre_attr.type);
/* Sanity check: write only a regular file */
if(filetype != REGULAR_FILE)
{
switch (preq->rq_vers)
{
case NFS_V2:
/*
* In the RFC tell it not good but it does
* not tell what to do ...
* We use NFSERR_ISDIR for lack of better
*/
pres->res_attr2.status = NFSERR_ISDIR;
break;
case NFS_V3:
if(filetype == DIR_BEGINNING || filetype == DIR_CONTINUE)
pres->res_write3.status = NFS3ERR_ISDIR;
else
pres->res_write3.status = NFS3ERR_INVAL;
break;
}
return NFS_REQ_OK;
}
/* For MDONLY export, reject write operation */
/* Request of type MDONLY_RO were rejected at the nfs_rpc_dispatcher level */
/* This is done by replying EDQUOT (this error is known for not disturbing the client's requests cache */
if(pexport->access_type == ACCESSTYPE_MDONLY)
{
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_attr2.status = NFSERR_DQUOT;
break;
case NFS_V3:
pres->res_write3.status = NFS3ERR_DQUOT;
break;
}
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_attr2.status,
&pres->res_write3.status,
NULL, NULL,
pentry,
ppre_attr,
&(pres->res_write3.WRITE3res_u.resfail.file_wcc),
NULL, NULL, NULL);
return NFS_REQ_OK;
}
/* Extract the argument from the request */
switch (preq->rq_vers)
{
case NFS_V2:
if(ppre_attr && ppre_attr->filesize > NFS2_MAX_FILESIZE)
{
/*
* V2 clients don't understand filesizes >
* 2GB, so we don't allow them to alter
* them in any way. BJP 6/26/2001
*/
pres->res_attr2.status = NFSERR_FBIG;
return NFS_REQ_OK;
}
offset = parg->arg_write2.offset; /* beginoffset is obsolete */
size = parg->arg_write2.data.nfsdata2_len; /* totalcount is obsolete */
data = parg->arg_write2.data.nfsdata2_val;
stable = FILE_SYNC;
if (pexport->use_commit == TRUE)
stable_flag = FSAL_SAFE_WRITE_TO_FS;
break;
case NFS_V3:
offset = parg->arg_write3.offset;
size = parg->arg_write3.count;
if(size > parg->arg_write3.data.data_len)
{
/* should never happen */
pres->res_write3.status = NFS3ERR_INVAL;
return NFS_REQ_OK;
}
if((pexport->use_commit == TRUE) &&
(pexport->use_ganesha_write_buffer == FALSE) &&
(parg->arg_write3.stable == UNSTABLE))
{
stable_flag = FSAL_UNSAFE_WRITE_TO_FS_BUFFER;
}
else if((pexport->use_commit == TRUE) &&
(pexport->use_ganesha_write_buffer == TRUE) &&
(parg->arg_write3.stable == UNSTABLE))
{
stable_flag = FSAL_UNSAFE_WRITE_TO_GANESHA_BUFFER;
}
else
{
stable_flag = FSAL_SAFE_WRITE_TO_FS;
}
data = parg->arg_write3.data.data_val;
stable = parg->arg_write3.stable;
break;
}
/*
* do not exceed maxium WRITE offset if set
*/
if((pexport->options & EXPORT_OPTION_MAXOFFSETWRITE) == EXPORT_OPTION_MAXOFFSETWRITE)
{
LogFullDebug(COMPONENT_NFSPROTO,
"-----> Write offset=%llu count=%llu MaxOffSet=%llu",
(unsigned long long) offset,
(unsigned long long) size,
(unsigned long long) pexport->MaxOffsetWrite);
if((fsal_off_t) (offset + size) > pexport->MaxOffsetWrite)
{
LogEvent(COMPONENT_NFSPROTO,
"NFS WRITE: A client tryed to violate max file size %llu for exportid #%hu",
(unsigned long long) pexport->MaxOffsetWrite, pexport->id);
switch (preq->rq_vers)
{
case NFS_V2:
pres->res_attr2.status = NFSERR_DQUOT;
break;
case NFS_V3:
pres->res_write3.status = NFS3ERR_INVAL;
break;
}
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_attr2.status,
&pres->res_write3.status,
NULL, NULL,
pentry,
ppre_attr,
&(pres->res_write3.WRITE3res_u.resfail.file_wcc),
NULL, NULL, NULL);
return NFS_REQ_OK;
}
}
/*
* We should take care not to exceed FSINFO wtmax
* field for the size
*/
if(((pexport->options & EXPORT_OPTION_MAXWRITE) == EXPORT_OPTION_MAXWRITE) &&
size > pexport->MaxWrite)
{
/*
* The client asked for too much data, we
* must restrict him
*/
size = pexport->MaxWrite;
}
if(size == 0)
{
cache_status = CACHE_INODE_SUCCESS;
written_size = 0;
}
else
{
/* An actual write is to be made, prepare it */
/* If entry is not cached, cache it now */
datapol.UseMaxCacheSize = pexport->options & EXPORT_OPTION_MAXCACHESIZE;
datapol.MaxCacheSize = pexport->MaxCacheSize;
if((pexport->options & EXPORT_OPTION_USE_DATACACHE) &&
(cache_content_cache_behaviour(pentry,
&datapol,
(cache_content_client_t *)
pclient->pcontent_client,
&content_status) == CACHE_CONTENT_FULLY_CACHED)
&& (pentry->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 */
/* Status is set in last argument */
cache_inode_add_data_cache(pentry, ht, pclient, pcontext, &cache_status);
if((cache_status != CACHE_INODE_SUCCESS) &&
(cache_status != CACHE_INODE_CACHE_CONTENT_EXISTS))
{
/* If we are here, there was an error */
if(nfs_RetryableError(cache_status))
{
return NFS_REQ_DROP;
}
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_attr2.status,
&pres->res_write3.status,
NULL, NULL,
pentry,
ppre_attr,
&(pres->res_write3.WRITE3res_u.resfail.file_wcc),
NULL, NULL, NULL);
return NFS_REQ_OK;
}
}
/* only FILE_SYNC mode is supported */
/* Set up uio to define the transfer */
seek_descriptor.whence = FSAL_SEEK_SET;
seek_descriptor.offset = offset;
if(cache_inode_rdwr(pentry,
CACHE_INODE_WRITE,
&seek_descriptor,
size,
&written_size,
&attr,
data,
&eof_met,
ht,
pclient,
pcontext, stable_flag, &cache_status) == CACHE_INODE_SUCCESS)
{
switch (preq->rq_vers)
{
case NFS_V2:
nfs2_FSALattr_To_Fattr(pexport,
&attr, &(pres->res_attr2.ATTR2res_u.attributes));
pres->res_attr2.status = NFS_OK;
break;
case NFS_V3:
/* Build Weak Cache Coherency data */
nfs_SetWccData(pcontext,
pexport,
pentry,
ppre_attr,
&attr, &(pres->res_write3.WRITE3res_u.resok.file_wcc));
/* Set the written size */
pres->res_write3.WRITE3res_u.resok.count = written_size;
/* How do we commit data ? */
if(stable_flag == FSAL_SAFE_WRITE_TO_FS)
{
pres->res_write3.WRITE3res_u.resok.committed = FILE_SYNC;
}
else
{
pres->res_write3.WRITE3res_u.resok.committed = UNSTABLE;
}
/* Set the write verifier */
memcpy(pres->res_write3.WRITE3res_u.resok.verf,
NFS3_write_verifier, sizeof(writeverf3));
pres->res_write3.status = NFS3_OK;
break;
}
return NFS_REQ_OK;
}
}
LogFullDebug(COMPONENT_NFSPROTO,
"---> failed write: cache_status=%d", cache_status);
/* If we are here, there was an error */
if(nfs_RetryableError(cache_status))
{
return NFS_REQ_DROP;
}
nfs_SetFailedStatus(pcontext, pexport,
preq->rq_vers,
cache_status,
&pres->res_attr2.status,
&pres->res_write3.status,
NULL, NULL,
pentry,
ppre_attr,
&(pres->res_write3.WRITE3res_u.resfail.file_wcc), NULL, NULL, NULL);
return NFS_REQ_OK;
} /* nfs_Write.c */
