int nlm4_Test(nfs_arg_t * parg /* IN */ ,
exportlist_t * pexport /* IN */ ,
fsal_op_context_t * pcontext /* IN */ ,
cache_inode_client_t * pclient /* INOUT */ ,
hash_table_t * ht /* INOUT */ ,
struct svc_req *preq /* IN */ ,
nfs_res_t * pres /* OUT */ )
{
nlm4_testargs *arg;
cache_entry_t *pentry;
fsal_attrib_list_t attr;
nlm_lock_entry_t *nlm_entry;
cache_inode_status_t cache_status;
cache_inode_fsal_data_t fsal_data;
LogFullDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nlm_Test");
if(in_nlm_grace_period())
{
pres->res_nlm4test.test_stat.stat = NLM4_DENIED_GRACE_PERIOD;
return NFS_REQ_OK;
}
/* Convert file handle into a cache entry */
arg = &parg->arg_nlm4_test;
if(!nfs3_FhandleToFSAL((nfs_fh3 *) & (arg->alock.fh), &fsal_data.handle, pcontext))
{
/* handle is not valid */
pres->res_nlm4test.test_stat.stat = NLM4_STALE_FH;
/*
* Should we do a REQ_OK so that the client get
* a response ? FIXME!!
*/
return NFS_REQ_DROP;
}
/* Now get the cached inode attributes */
fsal_data.cookie = DIR_START;
if((pentry = cache_inode_get(&fsal_data, &attr, ht,
pclient, pcontext, &cache_status)) == NULL)
{
/* handle is not valid */
pres->res_nlm4test.test_stat.stat = NLM4_STALE_FH;
return NFS_REQ_OK;
}
nlm_entry = nlm_overlapping_entry(&(arg->alock), arg->exclusive);
if(!nlm_entry)
{
pres->res_nlm4test.test_stat.stat = NLM4_GRANTED;
}
else
{
pres->res_nlm4test.test_stat.stat = NLM4_DENIED;
nlm_lock_entry_to_nlm_holder(nlm_entry,
&pres->res_nlm4test.test_stat.nlm4_testrply_u.holder);
nlm_lock_entry_dec_ref(nlm_entry);
}
return NFS_REQ_OK;
}
int nfs3_Pathconf(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_Pathconf";
cache_inode_status_t cache_status;
cache_entry_t *pentry = NULL;
cache_inode_fsal_data_t fsal_data;
fsal_attrib_list_t attr;
fsal_staticfsinfo_t * pstaticinfo = pcontext->export_context->fe_static_fs_info;
if(isDebug(COMPONENT_NFSPROTO))
{
char str[LEN_FH_STR];
sprint_fhandle3(str, &(parg->arg_pathconf3.object));
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs3_Pathconf handle: %s", str);
}
/* to avoid setting it on each error case */
pres->res_pathconf3.PATHCONF3res_u.resfail.obj_attributes.attributes_follow = FALSE;
/* Convert file handle into a fsal_handle */
if(nfs3_FhandleToFSAL(&(parg->arg_pathconf3.object), &fsal_data.handle, pcontext) == 0)
return NFS_REQ_DROP;
/* Set cookie to zero */
fsal_data.cookie = DIR_START;
/* Get the entry in the cache_inode */
if((pentry = cache_inode_get( &fsal_data,
pexport->cache_inode_policy,
&attr,
ht,
pclient,
pcontext,
&cache_status)) == NULL)
{
/* Stale NFS FH ? */
pres->res_pathconf3.status = NFS3ERR_STALE;
return NFS_REQ_OK;
}
/* Build post op file attributes */
nfs_SetPostOpAttr(pcontext, pexport,
pentry,
&attr, &(pres->res_pathconf3.PATHCONF3res_u.resok.obj_attributes));
pres->res_pathconf3.PATHCONF3res_u.resok.linkmax = pstaticinfo->maxlink;
pres->res_pathconf3.PATHCONF3res_u.resok.name_max = pstaticinfo->maxnamelen;
pres->res_pathconf3.PATHCONF3res_u.resok.no_trunc = pstaticinfo->no_trunc;
pres->res_pathconf3.PATHCONF3res_u.resok.chown_restricted = pstaticinfo->chown_restricted;
pres->res_pathconf3.PATHCONF3res_u.resok.case_insensitive = pstaticinfo->case_insensitive;
pres->res_pathconf3.PATHCONF3res_u.resok.case_preserving = pstaticinfo->case_preserving;
return NFS_REQ_OK;
} /* nfs3_Pathconf */
int nfs3_Pathconf(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_Pathconf";
cache_inode_status_t cache_status;
cache_entry_t *pentry = NULL;
cache_inode_fsal_data_t fsal_data;
fsal_attrib_list_t attr;
fsal_staticfsinfo_t staticinfo;
fsal_dynamicfsinfo_t dynamicinfo;
/* to avoid setting it on each error case */
pres->res_pathconf3.PATHCONF3res_u.resfail.obj_attributes.attributes_follow = FALSE;
/* Convert file handle into a fsal_handle */
if(nfs3_FhandleToFSAL(&(parg->arg_access3.object), &fsal_data.handle, pcontext) == 0)
return NFS_REQ_DROP;
/* Set cookie to zero */
fsal_data.cookie = DIR_START;
/* Get the entry in the cache_inode */
if((pentry = cache_inode_get(&fsal_data,
&attr, ht, pclient, pcontext, &cache_status)) == NULL)
{
/* Stale NFS FH ? */
pres->res_pathconf3.status = NFS3ERR_STALE;
return NFS_REQ_OK;
}
/* Get the filesystem information */
if(cache_inode_statfs(pentry, &staticinfo, &dynamicinfo, pcontext, &cache_status) !=
CACHE_INODE_SUCCESS)
{
pres->res_pathconf3.status = nfs3_Errno(cache_status);
return NFS_REQ_OK;
}
/* Build post op file attributes */
nfs_SetPostOpAttr(pcontext, pexport,
pentry,
&attr, &(pres->res_pathconf3.PATHCONF3res_u.resok.obj_attributes));
pres->res_pathconf3.PATHCONF3res_u.resok.linkmax = staticinfo.maxlink;
pres->res_pathconf3.PATHCONF3res_u.resok.name_max = staticinfo.maxnamelen;
pres->res_pathconf3.PATHCONF3res_u.resok.no_trunc = staticinfo.no_trunc;
pres->res_pathconf3.PATHCONF3res_u.resok.chown_restricted = staticinfo.chown_restricted;
pres->res_pathconf3.PATHCONF3res_u.resok.case_insensitive = staticinfo.case_insensitive;
pres->res_pathconf3.PATHCONF3res_u.resok.case_preserving = staticinfo.case_preserving;
return NFS_REQ_OK;
} /* nfs3_Pathconf */
int nlm_process_share_parms(struct svc_req * preq,
nlm4_share * share,
cache_entry_t ** ppentry,
fsal_op_context_t * pcontext,
care_t care,
state_nsm_client_t ** ppnsm_client,
state_nlm_client_t ** ppnlm_client,
state_owner_t ** ppowner)
{
cache_inode_fsal_data_t fsal_data;
fsal_attrib_list_t attr;
cache_inode_status_t cache_status;
SVCXPRT *ptr_svc = preq->rq_xprt;
int rc;
*ppnsm_client = NULL;
*ppnlm_client = NULL;
*ppowner = NULL;
/* Convert file handle into a cache entry */
if(share->fh.n_len > MAX_NETOBJ_SZ ||
!nfs3_FhandleToFSAL((nfs_fh3 *) &share->fh, &fsal_data.fh_desc, pcontext))
{
/* handle is not valid */
return NLM4_STALE_FH;
}
/* Now get the cached inode attributes */
*ppentry = cache_inode_get(&fsal_data,
&attr,
pcontext,
NULL,
&cache_status);
if(*ppentry == NULL)
{
/* handle is not valid */
return NLM4_STALE_FH;
}
*ppnsm_client = get_nsm_client(care, ptr_svc, share->caller_name);
if(*ppnsm_client == NULL)
{
/* If NSM Client is not found, and we don't care (for unshare),
* just return GRANTED (the unshare must succeed, there can't be
* any shares).
*/
if(care != CARE_NOT)
rc = NLM4_DENIED_NOLOCKS;
else
rc = NLM4_GRANTED;
goto out_put;
}
*ppnlm_client = get_nlm_client(care, ptr_svc, *ppnsm_client, share->caller_name);
if(*ppnlm_client == NULL)
{
/* If NLM Client is not found, and we don't care (such as unlock),
* just return GRANTED (the unlock must succeed, there can't be
* any locks).
*/
dec_nsm_client_ref(*ppnsm_client);
if(care != CARE_NOT)
rc = NLM4_DENIED_NOLOCKS;
else
rc = NLM4_GRANTED;
goto out_put;
}
*ppowner = get_nlm_owner(care, *ppnlm_client, &share->oh, 0);
if(*ppowner == NULL)
{
LogDebug(COMPONENT_NLM,
"Could not get NLM Owner");
dec_nsm_client_ref(*ppnsm_client);
dec_nlm_client_ref(*ppnlm_client);
*ppnlm_client = NULL;
/* If owner is not found, and we don't care (such as unlock),
* just return GRANTED (the unlock must succeed, there can't be
* any locks).
*/
if(care != CARE_NOT)
rc = NLM4_DENIED_NOLOCKS;
else
rc = NLM4_GRANTED;
goto out_put;
}
LogFullDebug(COMPONENT_NLM,
"Parameters Processed");
return -1;
out_put:
cache_inode_put(*ppentry);
*ppentry = NULL;
return rc;
}
int nlm_process_parameters(struct svc_req * preq,
bool_t exclusive,
nlm4_lock * alock,
fsal_lock_param_t * plock,
cache_entry_t ** ppentry,
fsal_op_context_t * pcontext,
care_t care,
state_nsm_client_t ** ppnsm_client,
state_nlm_client_t ** ppnlm_client,
state_owner_t ** ppowner,
state_block_data_t ** ppblock_data)
{
cache_inode_fsal_data_t fsal_data;
fsal_attrib_list_t attr;
cache_inode_status_t cache_status;
SVCXPRT *ptr_svc = preq->rq_xprt;
int rc;
*ppnsm_client = NULL;
*ppnlm_client = NULL;
*ppowner = NULL;
/* Convert file handle into a cache entry */
if(alock->fh.n_len > MAX_NETOBJ_SZ ||
!nfs3_FhandleToFSAL((nfs_fh3 *) &alock->fh, &fsal_data.fh_desc, pcontext))
{
/* handle is not valid */
return NLM4_STALE_FH;
}
/* Now get the cached inode attributes */
*ppentry = cache_inode_get(&fsal_data,
&attr,
pcontext,
NULL,
&cache_status);
if(*ppentry == NULL)
{
/* handle is not valid */
return NLM4_STALE_FH;
}
*ppnsm_client = get_nsm_client(care, ptr_svc, alock->caller_name);
if(*ppnsm_client == NULL)
{
/* If NSM Client is not found, and we don't care (such as unlock),
* just return GRANTED (the unlock must succeed, there can't be
* any locks).
*/
if(care != CARE_NOT)
rc = NLM4_DENIED_NOLOCKS;
else
rc = NLM4_GRANTED;
goto out_put;
}
*ppnlm_client = get_nlm_client(care, ptr_svc, *ppnsm_client, alock->caller_name);
if(*ppnlm_client == NULL)
{
/* If NLM Client is not found, and we don't care (such as unlock),
* just return GRANTED (the unlock must succeed, there can't be
* any locks).
*/
dec_nsm_client_ref(*ppnsm_client);
if(care != CARE_NOT)
rc = NLM4_DENIED_NOLOCKS;
else
rc = NLM4_GRANTED;
goto out_put;
}
*ppowner = get_nlm_owner(care, *ppnlm_client, &alock->oh, alock->svid);
if(*ppowner == NULL)
{
LogDebug(COMPONENT_NLM,
"Could not get NLM Owner");
dec_nsm_client_ref(*ppnsm_client);
dec_nlm_client_ref(*ppnlm_client);
*ppnlm_client = NULL;
/* If owner is not found, and we don't care (such as unlock),
* just return GRANTED (the unlock must succeed, there can't be
* any locks).
*/
if(care != CARE_NOT)
rc = NLM4_DENIED_NOLOCKS;
else
rc = NLM4_GRANTED;
goto out_put;
}
if(ppblock_data != NULL)
{
*ppblock_data = gsh_calloc(1, sizeof(**ppblock_data));
/* Fill in the block data, if we don't get one, we will just proceed
* without (which will mean the lock doesn't block.
*/
if(*ppblock_data != NULL)
{
if(copy_xprt_addr(&(*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_nlm_hostaddr, ptr_svc) == 0)
{
LogFullDebug(COMPONENT_NLM,
"copy_xprt_addr failed for Program %d, Version %d, Function %d",
(int)preq->rq_prog, (int)preq->rq_vers, (int)preq->rq_proc);
gsh_free(*ppblock_data);
*ppblock_data = NULL;
rc = NLM4_FAILED;
goto out_put;
}
(*ppblock_data)->sbd_granted_callback = nlm_granted_callback;
(*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_nlm_fh.n_bytes =
(*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_nlm_fh_buf;
(*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_nlm_fh.n_len = alock->fh.n_len;
memcpy((*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_nlm_fh_buf,
alock->fh.n_bytes,
alock->fh.n_len);
/* FSF TODO: Ultimately I think the following will go away, we won't need the context, just the export */
/* Copy credentials from pcontext */
#ifdef _USE_HPSS
/** @todo : PhD: Think about removing hpsscred_t from FSAL */
(*ppblock_data)->sbd_credential.user = pcontext->credential.hpss_usercred.Uid ;
(*ppblock_data)->sbd_credential.group = pcontext->credential.hpss_usercred.Gid ;
#else
(*ppblock_data)->sbd_credential = pcontext->credential;
/* Copy the alt groups list */
if(pcontext->credential.nbgroups != 0)
{
(*ppblock_data)->sbd_credential.alt_groups =
gsh_malloc(sizeof(gid_t) * pcontext->credential.nbgroups);
if((*ppblock_data)->sbd_credential.alt_groups == NULL)
{
gsh_free(*ppblock_data);
*ppblock_data = NULL;
rc = NLM4_FAILED;
goto out_put;
}
memcpy((*ppblock_data)->sbd_credential.alt_groups,
pcontext->credential.alt_groups,
pcontext->credential.nbgroups);
}
#endif
}
}
/* Fill in plock */
plock->lock_type = exclusive ? FSAL_LOCK_W : FSAL_LOCK_R;
plock->lock_start = alock->l_offset;
plock->lock_length = alock->l_len;
LogFullDebug(COMPONENT_NLM,
"Parameters Processed");
return -1;
out_put:
cache_inode_put(*ppentry);
*ppentry = NULL;
return rc;
}
int main(int argc, char *argv[])
{
int c;
int exportid = 0;
char buffer[CMD_BUFFER_SIZE];
char str[2 * CMD_BUFFER_SIZE];
fhandle2 filehandle_v2;
struct nfs_fh3 filehandle_v3;
nfs_fh4 filehandle_v4;
int flag_i = FALSE;
char exec_name[MAXPATHLEN];
char *tempo_exec_name = NULL;
cache_inode_fsal_data_t fsal_data;
fsal_op_context_t fsal_op_context;
fsal_export_context_t fsal_export_context;
exportlist_t *pexportlist = NULL;
exportlist_t *pexport = NULL;
nfs_start_info_t nfs_start_info;
fsal_status_t fsal_status;
unsigned int nfs_version = 3;
path_str_t fsal_path_lib[NB_AVAILABLE_FSAL];
#ifdef _USE_SHARED_FSAL
int lentab = NB_AVAILABLE_FSAL ;
#endif
short cache_content_hash;
char entry_path[MAXPATHLEN];
int i, nb_char;
fsal_path_t export_path = FSAL_PATH_INITIALIZER;
unsigned int cookie;
fsal_xattrent_t xattr_array[256];
unsigned int nb_returned;
int eol;
char attr_buffer[4096];
size_t sz_returned;
fsal_u64_t objid;
char options[] = "h@f:v:i:";
char usage[] = "%s [-h][-f <cfg_path>] {-v 2|3|4 <NFS_FileHandle> | -i <inum>}\n"
" -h : prints this help\n"
" -f <config_file> : sets the ganesha configuration file to be used\n"
" -v <nfs_version> : sets the NFS version the file handle passed as argument\n"
" -i <inum> : get datacache path for the given inode number (decimal)\n";
ServerBootTime = time(NULL);
SetDefaultLogging("STDERR");
/* What is the executable file's name */
if((tempo_exec_name = strrchr(argv[0], '/')) != NULL)
strcpy((char *)exec_name, tempo_exec_name + 1);
strncpy(config_path, DEFAULT_CONFIG_FILE, MAXPATHLEN);
/* now parsing options with getopt */
while((c = getopt(argc, argv, options)) != EOF)
{
switch (c)
{
case '@':
printf("%s compiled on %s at %s\n", exec_name, __DATE__, __TIME__);
exit(0);
break;
case 'h':
printf(usage, exec_name);
exit(0);
break;
case 'f':
strncpy(config_path, optarg, MAXPATHLEN);
break;
case 'i':
if(sscanf(optarg, "%llu", &objid) != 1)
{
fprintf(stderr, "Invalid object_id %s (base-10 integer expected)\n",
optarg);
exit(1);
}
flag_i = TRUE;
break;
case 'v':
nfs_version = atoi(optarg);
if((nfs_version < 2) || (nfs_version > 4))
{
fprintf(stderr, "Invalid nfs version %u\n", nfs_version);
exit(1);
}
break;
case '?':
printf("Unknown option: %c\n", optopt);
printf(usage, exec_name);
exit(1);
}
}
if(!flag_i && (optind != argc - 1))
{
printf("Missing argument: <NFS_FileHandle>\n");
printf(usage, exec_name);
exit(1);
}
/* initialize memory and logging */
nfs_prereq_init("convert_fh", "localhost", NIV_MAJ, "/dev/tty");
#ifdef _USE_SHARED_FSAL
if(nfs_get_fsalpathlib_conf(config_path, fsal_path_lib, &lentab))
{
fprintf(stderr, "NFS MAIN: Error parsing configuration file.");
exit(1);
}
#endif /* _USE_SHARED_FSAL */
/* Load the FSAL library (if needed) */
if(!FSAL_LoadLibrary((char *)fsal_path_lib)) /** @todo: this part of the code and this utility has to be checked */
{
fprintf(stderr, "NFS MAIN: Could not load FSAL dynamic library %s", (char *)fsal_path_lib[0]);
exit(1);
}
/* Get the FSAL functions */
FSAL_LoadFunctions();
/* Get the FSAL consts */
FSAL_LoadConsts();
/* initialize default parameters */
nfs_set_param_default();
/* parse configuration file */
if(nfs_set_param_from_conf(&nfs_start_info))
{
fprintf(stderr, "Error parsing configuration file '%s'", config_path);
exit(1);
}
/* check parameters consitency */
if(nfs_check_param_consistency())
{
fprintf(stderr, "Inconsistent parameters found");
exit(1);
}
if(!nfs_param.pexportlist)
{
fprintf(stderr, "No export entries found in configuration file !!!\n");
return -1;
}
pexportlist = nfs_param.pexportlist;
/* not initialization is needed for converting fileid to path in datacache */
if(!flag_i)
{
#ifdef _USE_SHARED_FSAL
fsal_status = FSAL_Init(&nfs_param.fsal_param[0]);
#else
fsal_status = FSAL_Init(&nfs_param.fsal_param);
#endif
if(FSAL_IS_ERROR(fsal_status))
{
/* Failed init */
fprintf(stderr, "FSAL library could not be initialized, major=%d minor=%d\n",
fsal_status.major, fsal_status.minor);
exit(1);
}
strncpy(str, argv[optind], 2 * CMD_BUFFER_SIZE);
switch (nfs_version)
{
case 2:
if(sscanmem(filehandle_v2, sizeof(file_handle_v2_t), (char *)str) == -1)
{
fprintf(stderr, "Bad FH as input (expected size: %lu bytes)\n",
(unsigned long)sizeof(file_handle_v2_t));
exit(1);
}
exportid = nfs2_FhandleToExportId(&filehandle_v2);
break;
case 3:
if(sscanmem(buffer, sizeof(file_handle_v3_t), (char *)str) == -1)
{
fprintf(stderr, "Bad FH as input (expected size: %lu bytes)\n",
(unsigned long)sizeof(file_handle_v3_t));
exit(1);
}
filehandle_v3.data.data_val = (char *)buffer;
filehandle_v3.data.data_len = sizeof(file_handle_v3_t);
exportid = nfs3_FhandleToExportId(&filehandle_v3);
break;
case 4:
if(sscanmem(buffer, sizeof(file_handle_v4_t), (char *)str) == -1)
{
fprintf(stderr, "Bad FH as input (expected size: %lu bytes)\n",
(unsigned long)sizeof(file_handle_v4_t));
exit(1);
}
filehandle_v4.nfs_fh4_val = (char *)buffer;
filehandle_v4.nfs_fh4_len = sizeof(file_handle_v4_t);
exportid = nfs4_FhandleToExportId(&filehandle_v4);
break;
}
if((pexport = nfs_Get_export_by_id(pexportlist, exportid)) == NULL)
{
fprintf(stderr, "NFS FH has exportid %u which is invalid....\n", exportid);
exit(1);
}
/* INITIALIZING A CLIENT CONTEXT FOR FSAL */
FSAL_str2path(pexport->fullpath, MAXPATHLEN, &export_path);
if(FSAL_IS_ERROR
(fsal_status =
FSAL_BuildExportContext(&fsal_export_context, &export_path,
pexport->FS_specific)))
{
fprintf(stderr, "Error in FSAL_BuildExportContext, major=%u, minor=%u\n",
fsal_status.major, fsal_status.minor);
exit(1);
}
fsal_status = FSAL_InitClientContext(&fsal_op_context);
if(FSAL_IS_ERROR(fsal_status))
{
/* Failed init */
fprintf(stderr, "Could not init client context... major=%d minor=%d\n",
fsal_status.major, fsal_status.minor);
exit(1);
}
fsal_status = FSAL_GetClientContext(&fsal_op_context,
&fsal_export_context, 0, 0, NULL, 0);
if(FSAL_IS_ERROR(fsal_status))
{
/* Failed init */
fprintf(stderr, "Could not get cred for uid=%d gid=%d, major=%d minor=%d\n",
getuid(), getgid(), fsal_status.major, fsal_status.minor);
exit(1);
}
/* now, can use the fsal_op_context */
switch (nfs_version)
{
case 2:
if(!nfs2_FhandleToFSAL(&filehandle_v2, &fsal_data.handle, &fsal_op_context))
{
fprintf(stderr, "Cannot convert Fhandle to FSAL\n");
exit(1);
}
break;
case 3:
if(!nfs3_FhandleToFSAL(&filehandle_v3, &fsal_data.handle, &fsal_op_context))
{
fprintf(stderr, "Cannot convert Fhandle to FSAL\n");
exit(1);
}
break;
case 4:
if(!nfs4_FhandleToFSAL(&filehandle_v4, &fsal_data.handle, &fsal_op_context))
{
fprintf(stderr, "Cannot convert Fhandle to FSAL\n");
exit(1);
}
break;
}
printf("\n");
snprintmem((caddr_t) str, 2 * CMD_BUFFER_SIZE, (caddr_t) & fsal_data.handle,
sizeof(fsal_data.handle));
printf("%-18s = %s\n", "FSAL Handle", str);
/* Now, list FSAL extended attributes */
cookie = XATTRS_READLIST_FROM_BEGINNING;
eol = FALSE;
while(!eol)
{
unsigned int index;
fsal_status = FSAL_ListXAttrs(&fsal_data.handle, cookie, &fsal_op_context,
xattr_array, 256, &nb_returned, &eol);
if(FSAL_IS_ERROR(fsal_status))
{
fprintf(stderr, "Error executing FSAL_ListXAttrs\n");
exit(1);
}
/* list attributes and get their value */
for(index = 0; index < nb_returned; index++)
{
cookie = xattr_array[index].xattr_cookie;
printf("%-18s = ", xattr_array[index].xattr_name.name);
fsal_status =
FSAL_GetXAttrValueByName(&fsal_data.handle,
&xattr_array[index].xattr_name,
&fsal_op_context, attr_buffer, 4096,
&sz_returned);
if(FSAL_IS_ERROR(fsal_status))
{
fprintf(stderr, "Error executing FSAL_GetXAttrValueByName\n");
}
/* Display it */
print_buffer(attr_buffer, sz_returned);
}
}
/* get object ID */
fsal_status =
FSAL_DigestHandle(&fsal_export_context, FSAL_DIGEST_FILEID4, &fsal_data.handle,
(caddr_t) & objid);
if(FSAL_IS_ERROR(fsal_status))
{
fprintf(stderr, "Error retrieving fileid from handle\n");
}
else
{
printf("%-18s = %llu\n", "FileId", objid);
}
}
/* end of retrieval of objid */
/* build the path in the datacache */
cache_content_hash = HashFileID4(objid);
/* for limiting the number of entries into each datacache directory
* we create 256 subdirectories on 2 levels, depending on the entry's fileid.
*/
nb_char = snprintf(entry_path, MAXPATHLEN, "export_id=%d", 0);
for(i = 0; i <= 8; i += 8)
{
/* concatenation of hashval */
nb_char += snprintf((char *)(entry_path + nb_char), MAXPATHLEN - nb_char,
"/%02hhX", (char)((cache_content_hash >> i) & 0xFF));
}
/* displays the node name */
printf("%-18s = %s/%s/node=%llx*\n", "DataCache path",
nfs_param.cache_layers_param.cache_content_client_param.cache_dir, entry_path,
objid);
exit(0);
}
int nlm_process_parameters(struct svc_req * preq,
bool_t exclusive,
nlm4_lock * alock,
state_lock_desc_t * plock,
hash_table_t * ht,
cache_entry_t ** ppentry,
fsal_op_context_t * pcontext,
cache_inode_client_t * pclient,
care_t care,
state_nsm_client_t ** ppnsm_client,
state_nlm_client_t ** ppnlm_client,
state_owner_t ** ppowner,
state_block_data_t ** ppblock_data)
{
cache_inode_fsal_data_t fsal_data;
fsal_attrib_list_t attr;
cache_inode_status_t cache_status;
SVCXPRT *ptr_svc = preq->rq_xprt;
*ppnsm_client = NULL;
*ppnlm_client = NULL;
*ppowner = NULL;
/* Convert file handle into a cache entry */
if(alock->fh.n_len > MAX_NETOBJ_SZ ||
!nfs3_FhandleToFSAL((nfs_fh3 *) &alock->fh, &fsal_data.handle, pcontext))
{
/* handle is not valid */
return NLM4_STALE_FH;
}
/* Now get the cached inode attributes */
fsal_data.cookie = DIR_START;
*ppentry = cache_inode_get(&fsal_data,
CACHE_INODE_JOKER_POLICY,
&attr,
ht,
pclient,
pcontext,
&cache_status);
if(*ppentry == NULL)
{
/* handle is not valid */
return NLM4_STALE_FH;
}
*ppnsm_client = get_nsm_client(care, ptr_svc, alock->caller_name);
if(*ppnsm_client == NULL)
{
/* If NSM Client is not found, and we don't care (such as unlock),
* just return GRANTED (the unlock must succeed, there can't be
* any locks).
*/
if(care != CARE_NOT)
return NLM4_DENIED_NOLOCKS;
else
return NLM4_GRANTED;
}
*ppnlm_client = get_nlm_client(care, ptr_svc, *ppnsm_client, alock->caller_name);
if(*ppnlm_client == NULL)
{
/* If NLM Client is not found, and we don't care (such as unlock),
* just return GRANTED (the unlock must succeed, there can't be
* any locks).
*/
dec_nsm_client_ref(*ppnsm_client);
if(care != CARE_NOT)
return NLM4_DENIED_NOLOCKS;
else
return NLM4_GRANTED;
}
*ppowner = get_nlm_owner(care, *ppnlm_client, &alock->oh, alock->svid);
if(*ppowner == NULL)
{
LogDebug(COMPONENT_NLM,
"Could not get NLM Owner");
dec_nsm_client_ref(*ppnsm_client);
dec_nlm_client_ref(*ppnlm_client);
*ppnlm_client = NULL;
/* If owner is not found, and we don't care (such as unlock),
* just return GRANTED (the unlock must succeed, there can't be
* any locks).
*/
if(care)
return NLM4_DENIED_NOLOCKS;
else
return NLM4_GRANTED;
}
if(ppblock_data != NULL)
{
*ppblock_data = (state_block_data_t *) Mem_Alloc_Label(sizeof(**ppblock_data),
"NLM_Block_Data");
/* Fill in the block data, if we don't get one, we will just proceed
* without (which will mean the lock doesn't block.
*/
if(*ppblock_data != NULL)
{
memset(*ppblock_data, 0, sizeof(**ppblock_data));
if(copy_xprt_addr(&(*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_nlm_hostaddr, ptr_svc) == 0)
{
LogFullDebug(COMPONENT_NLM,
"copy_xprt_addr failed for Program %d, Version %d, Function %d",
(int)preq->rq_prog, (int)preq->rq_vers, (int)preq->rq_proc);
Mem_Free(*ppblock_data);
*ppblock_data = NULL;
return NLM4_FAILED;
}
(*ppblock_data)->sbd_granted_callback = nlm_granted_callback;
(*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_nlm_fh.n_bytes =
(*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_nlm_fh_buf;
(*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_nlm_fh.n_len = alock->fh.n_len;
memcpy((*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_nlm_fh_buf,
alock->fh.n_bytes,
alock->fh.n_len);
/* FSF TODO: Ultimately I think the following will go away, we won't need the context, just the export */
/* Copy credentials from pcontext */
(*ppblock_data)->sbd_block_data.sbd_nlm_block_data.sbd_credential = pcontext->credential;
}
}
/* Fill in plock */
plock->sld_type = exclusive ? STATE_LOCK_W : STATE_LOCK_R;
plock->sld_offset = alock->l_offset;
plock->sld_length = alock->l_len;
LogFullDebug(COMPONENT_NLM,
"Parameters Processed");
return -1;
}
int nfs3_Fsinfo(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_Fsinfo";
cache_inode_status_t cache_status;
cache_entry_t *pentry = NULL;
cache_inode_fsal_data_t fsal_data;
fsal_attrib_list_t attr;
if(isDebug(COMPONENT_NFSPROTO))
{
char str[LEN_FH_STR];
sprint_fhandle3(str, &(parg->arg_fsinfo3.fsroot));
LogDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nfs3_Fsinfo handle: %s", str);
}
/* to avoid setting it on each error case */
pres->res_fsinfo3.FSINFO3res_u.resfail.obj_attributes.attributes_follow = FALSE;
/* Convert file handle into a fsal_handle */
if(nfs3_FhandleToFSAL(&(parg->arg_fsinfo3.fsroot), &fsal_data.handle, pcontext) == 0)
return NFS_REQ_DROP;
/* Set the cookie */
fsal_data.cookie = DIR_START;
/* Get the entry in the cache_inode */
if((pentry = cache_inode_get( &fsal_data,
pexport->cache_inode_policy,
&attr,
ht,
pclient,
pcontext,
&cache_status)) == NULL)
{
/* Stale NFS FH ? */
pres->res_fsinfo3.status = NFS3ERR_STALE;
return NFS_REQ_OK;
}
/*
* New fields were added to nfs_config_t to handle this value. We use
* them
*/
#define FSINFO_FIELD pres->res_fsinfo3.FSINFO3res_u.resok
FSINFO_FIELD.rtmax = pexport->MaxRead;
FSINFO_FIELD.rtpref = pexport->PrefRead;
/* This field is generally unused, it will be removed in V4 */
FSINFO_FIELD.rtmult = DEV_BSIZE;
FSINFO_FIELD.wtmax = pexport->MaxWrite;
FSINFO_FIELD.wtpref = pexport->PrefWrite;
/* This field is generally unused, it will be removed in V4 */
FSINFO_FIELD.wtmult = DEV_BSIZE;
FSINFO_FIELD.dtpref = pexport->PrefReaddir;
FSINFO_FIELD.maxfilesize = FSINFO_MAX_FILESIZE;
FSINFO_FIELD.time_delta.seconds = 1;
FSINFO_FIELD.time_delta.nseconds = 0;
LogFullDebug(COMPONENT_NFSPROTO,
"rtmax = %d | rtpref = %d | trmult = %d",
FSINFO_FIELD.rtmax,
FSINFO_FIELD.rtpref,
FSINFO_FIELD.rtmult);
LogFullDebug(COMPONENT_NFSPROTO,
"wtmax = %d | wtpref = %d | wrmult = %d",
FSINFO_FIELD.wtmax,
FSINFO_FIELD.wtpref,
FSINFO_FIELD.wtmult);
LogFullDebug(COMPONENT_NFSPROTO,
"dtpref = %d | maxfilesize = %llu ",
FSINFO_FIELD.dtpref,
FSINFO_FIELD.maxfilesize);
/*
* Allow all kinds of operations to be performed on the server
* through NFS v3
*/
FSINFO_FIELD.properties = FSF3_LINK | FSF3_SYMLINK | FSF3_HOMOGENEOUS | FSF3_CANSETTIME;
nfs_SetPostOpAttr(pcontext, pexport,
pentry,
&attr, &(pres->res_fsinfo3.FSINFO3res_u.resok.obj_attributes));
pres->res_fsinfo3.status = NFS3_OK;
return NFS_REQ_OK;
} /* nfs3_Fsinfo */
int nlm4_Unlock(nfs_arg_t * parg /* IN */ ,
exportlist_t * pexport /* IN */ ,
fsal_op_context_t * pcontext /* IN */ ,
cache_inode_client_t * pclient /* INOUT */ ,
hash_table_t * ht /* INOUT */ ,
struct svc_req *preq /* IN */ ,
nfs_res_t * pres /* OUT */ )
{
int lck_cnt, lck_state;
nlm4_unlockargs *arg;
cache_entry_t *pentry;
fsal_attrib_list_t attr;
nlm_lock_entry_t *nlm_entry;
cache_inode_status_t cache_status;
cache_inode_fsal_data_t fsal_data;
LogFullDebug(COMPONENT_NFSPROTO,
"REQUEST PROCESSING: Calling nlm4_Lock");
if(in_nlm_grace_period())
{
pres->res_nlm4test.test_stat.stat = NLM4_DENIED_GRACE_PERIOD;
return NFS_REQ_OK;
}
/* Convert file handle into a cache entry */
arg = &parg->arg_nlm4_unlock;
if(!nfs3_FhandleToFSAL((nfs_fh3 *) & (arg->alock.fh), &fsal_data.handle, pcontext))
{
/* handle is not valid */
pres->res_nlm4.stat.stat = NLM4_STALE_FH;
/*
* Should we do a REQ_OK so that the client get
* a response ? FIXME!!
*/
return NFS_REQ_DROP;
}
/* Now get the cached inode attributes */
fsal_data.cookie = DIR_START;
if((pentry = cache_inode_get(&fsal_data, &attr, ht,
pclient, pcontext, &cache_status)) == NULL)
{
/* handle is not valid */
pres->res_nlm4.stat.stat = NLM4_STALE_FH;
return NFS_REQ_OK;
}
/*
* nlm_find_lock_entry with state NLM4_GRANTED will search for lock
* in both blocked and granted state. We can get an unlock request
* even for a lock in blocked state because grant rpc response could
* get dropped and the client can think that lock is granted but the
* server still consider it locked.
*/
nlm_entry = nlm_find_lock_entry(&(arg->alock), 0, NLM4_GRANTED);
if(!nlm_entry)
{
pres->res_nlm4.stat.stat = NLM4_DENIED_NOLOCKS;
return NFS_REQ_OK;
}
lck_state = nlm_lock_entry_get_state(nlm_entry);
pres->res_nlm4.stat.stat = NLM4_GRANTED;
lck_cnt = nlm_delete_lock_entry(&(arg->alock));
nlm_unmonitor_host(arg->alock.caller_name);
/*
* Now check whether we have blocked locks.
* if found grant them the lock
*/
if(lck_state == NLM4_GRANTED)
nlm_grant_blocked_locks(&(arg->alock.fh));
nlm_lock_entry_dec_ref(nlm_entry);
return NFS_REQ_OK;
}
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 */
