/**
* @brief Initialize NFSd prerequisites
*
* @param[in] program_name Name of the program
* @param[in] host_name Server host name
* @param[in] debug_level Debug level
* @param[in] log_path Log path
*/
void nfs_prereq_init(char *program_name, char *host_name, int debug_level,
char *log_path)
{
/* Initialize logging */
SetNamePgm(program_name);
SetNameFunction("main");
SetNameHost(host_name);
InitLogging();
if (log_path)
SetDefaultLogging(log_path);
if (debug_level >= 0)
SetLevelDebug(debug_level);
ReadLogEnvironment();
/* Register error families */
AddFamilyError(ERR_POSIX, "POSIX Errors", tab_systeme_status);
AddFamilyError(ERR_HASHTABLE, "HashTable related Errors",
tab_errctx_hash);
AddFamilyError(ERR_FSAL, "FSAL related Errors", tab_errstatus_FSAL);
AddFamilyError(ERR_CACHE_INODE, "Cache Inode related Errors",
tab_errstatus_cache_inode);
}
int main(int argc, char **argv)
{
SetDefaultLogging("TEST");
SetNamePgm("verif_syntax");
char *errtxt;
char *fichier;
config_file_t config;
if ((argc > 1) && (argv[1])) {
fichier = argv[1];
} else {
LogTest("Usage %s <config_file>", argv[0]);
exit(EINVAL);
}
/* test de la syntaxe du fichier */
config = config_ParseFile(fichier);
if (config == NULL) {
LogTest("Error parsing %s", argv[1]);
exit(EINVAL);
} else {
LogTest("The syntax of the file %s is correct!", argv[1]);
exit(0);
}
config_Free(config);
return 0;
}
void* posix_init(const char* config_file, const char* log_file) {
SetNamePgm("TC-POSIX");
SetNameFunction("posix");
SetNameHost("localhost");
init_logging(log_file, NIV_EVENT);
return (void*) log_file;
}
/**
* @brief Initialize NFSd prerequisites
*
* @param[in] program_name Name of the program
* @param[in] host_name Server host name
* @param[in] debug_level Debug level
* @param[in] log_path Log path
*/
void nfs_prereq_init(char *program_name, char *host_name, int debug_level,
char *log_path)
{
/* Initialize logging */
SetNamePgm(program_name);
SetNameFunction("main");
SetNameHost(host_name);
init_logging(log_path, debug_level);
}
main(int argc, char *argv[])
{
SetDefaultLogging("TEST");
SetNamePgm("test_buddy");
char name[30];
uint32_t valeur;
int i;
if(argc == 1)
exit(0);
for(i = 1; i < argc; i++)
{
strncpy(name, argv[i], 30);
idmap_computer_hash_value(name, &valeur);
LogTest("%s %x\n", name, valeur);
}
}
int main(int argc, char *argv[])
{
if (argc >= 2) {
/* TEST 1 Standard */
if (!strcmp(argv[1], "STD")) {
char *str = "No extra string provided";
char *file = NULL;
if (argc >= 3)
str = argv[2];
if (argc >= 4)
file = argv[3];
SetNamePgm("test_liblog");
SetNameHost("localhost");
SetDefaultLogging("TEST");
InitLogging();
AddFamilyError(ERR_POSIX, "POSIX Errors",
tab_systeme_status);
LogTest("AddFamilyError = %d",
AddFamilyError(ERR_DUMMY, "Family Dummy",
tab_test_err));
LogTest("The family which was added is %s",
ReturnNameFamilyError(ERR_DUMMY));
run_Tests(true, "monothread", str, file);
}
/* TEST 1 multithread */
else if (!strcmp(argv[1], "MT")) {
/* multithread test */
pthread_attr_t th_attr[NB_THREADS];
pthread_t threads[NB_THREADS];
int th_index, i;
void *result;
SetNamePgm("test_liblog");
SetNameHost("localhost");
SetDefaultLogging("STDOUT");
InitLogging();
AddFamilyError(ERR_POSIX, "POSIX Errors",
tab_systeme_status);
LogTest("AddFamilyError = %d",
AddFamilyError(ERR_DUMMY, "Family Dummy",
tab_test_err));
LogTest("The family which was added is %s",
ReturnNameFamilyError(ERR_DUMMY));
/* creation of attributes */
for (th_index = 0; th_index < NB_THREADS; th_index++) {
pthread_attr_init(&th_attr[th_index]);
pthread_attr_setdetachstate(
&th_attr[th_index],
PTHREAD_CREATE_JOINABLE);
}
/* creation of threads with their names */
for (i = 0; i < NB_THREADS; i++) {
int rc;
char *thread_name = gsh_malloc(256);
snprintf(thread_name, 256, "thread %3d", i);
rc = pthread_create(&(threads[i]), &th_attr[i],
run_MT_Tests,
(void *)thread_name);
}
/* waiting for threads termination */
for (i = 0; i < NB_THREADS; i++) {
pthread_join(threads[i], &result);
if (result)
return 1;
}
return 0;
}
/* unknown test */
else {
fprintf(stderr, "%s", usage);
exit(1);
}
} else {
fprintf(stderr, "%s", usage);
exit(1);
}
return 0;
}
int main(int argc, char **argv)
{
char localmachine[256];
char *test;
fsal_parameter_t init_param;
fsal_status_t st;
uid_t uid;
fsal_export_context_t export_ctx;
fsal_op_context_t op_ctx;
fsal_handle_t root_handle, handle;
fsal_name_t name;
fsal_path_t path;
fsal_attrib_list_t attribs;
fsal_attrib_mask_t mask;
char tracebuff[256];
if(argc < 2)
{
usage();
exit(-1);
}
test = argv[1];
/* retrieving params */
#ifndef _NO_BUDDY_SYSTEM
BuddyInit(NULL);
#endif
/* init debug */
SetNamePgm("test_fsal");
SetDefaultLogging("TEST");
SetNameFunction("main");
InitLogging();
/* Obtention du nom de la machine */
if(gethostname(localmachine, sizeof(localmachine)) != 0)
{
LogError(COMPONENT_STDOUT,ERR_SYS, ERR_GETHOSTNAME, errno);
exit(1);
}
else
SetNameHost(localmachine);
AddFamilyError(ERR_FSAL, "FSAL related Errors", tab_errstatus_FSAL);
/* prepare fsal_init */
/* 1 - fs specific info */
#ifdef _USE_HPSS_51
init_param.fs_specific_info.behaviors.PrincipalName = FSAL_INIT_FORCE_VALUE;
strcpy(init_param.fs_specific_info.hpss_config.PrincipalName, "hpss_nfs");
init_param.fs_specific_info.behaviors.KeytabPath = FSAL_INIT_FORCE_VALUE;
strcpy(init_param.fs_specific_info.hpss_config.KeytabPath, "/krb5/hpssserver.keytab");
#elif defined _USE_HPSS_62
init_param.fs_specific_info.behaviors.AuthnMech = FSAL_INIT_FORCE_VALUE;
init_param.fs_specific_info.hpss_config.AuthnMech = hpss_authn_mech_krb5;
init_param.fs_specific_info.behaviors.Principal = FSAL_INIT_FORCE_VALUE;
strcpy(init_param.fs_specific_info.Principal, "hpssfs");
init_param.fs_specific_info.behaviors.KeytabPath = FSAL_INIT_FORCE_VALUE;
strcpy(init_param.fs_specific_info.KeytabPath, "/var/hpss/etc/hpss.keytab");
#endif
/* 2-common info (default) */
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxfilesize);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxlink);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxnamelen);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxpathlen);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, no_trunc);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, chown_restricted);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, case_insensitive);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, case_preserving);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, fh_expire_type);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, link_support);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, symlink_support);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, named_attr);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, unique_handles);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, lease_time);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, acl_support);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, cansettime);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, homogenous);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, supported_attrs);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxread);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxwrite);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, umask);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, auth_exportpath_xdev);
/* 3- fsal info */
init_param.fsal_info.max_fs_calls = 0;
/* Init */
if(FSAL_IS_ERROR(st = FSAL_Init(&init_param)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
/* getting creds */
uid = getuid();
LogTest("uid = %d", uid);
st = FSAL_BuildExportContext(&export_ctx, NULL, NULL);
if(FSAL_IS_ERROR(st))
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
st = FSAL_InitClientContext(&op_ctx);
if(FSAL_IS_ERROR(st))
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
st = FSAL_GetClientContext(&op_ctx, &export_ctx, uid, -1, NULL, 0);
if(FSAL_IS_ERROR(st))
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
/* getting root handle */
if(FSAL_IS_ERROR(st = FSAL_lookup(NULL, NULL, &op_ctx, &root_handle, NULL)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &root_handle);
LogTest("Root handle = %s", tracebuff);
/* getting what are the supported attributes */
attribs.asked_attributes = 0;
FSAL_SET_MASK(attribs.asked_attributes, FSAL_ATTR_SUPPATTR);
LogTest("asked attributes :");
printmask(attribs.asked_attributes);
if(FSAL_IS_ERROR(st = ZFSFSAL_getattrs(&root_handle, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
LogTest("supported attributes :");
printmask(attribs.supported_attributes);
mask = attribs.supported_attributes;
/* TEST 1 */
if(test[0] == '1')
{
attribs.asked_attributes = 0;
FSAL_SET_MASK(attribs.asked_attributes, FSAL_ATTR_SUPPATTR);
LogTest("asked attributes :");
printmask(attribs.asked_attributes);
if(FSAL_IS_ERROR(st = ZFSFSAL_getattrs(&root_handle, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
LogTest("supported attributes :");
/* getting all spported attributes of root */
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = ZFSFSAL_getattrs(&root_handle, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
printattributes(attribs);
}
else
/* TEST 2 */
if(test[0] == '2')
{
/* getting handle and attributes for subdirectory "OSF1_V5" */
if(FSAL_IS_ERROR(st = FSAL_str2name("cea", 4, &name)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookup(&root_handle, &name, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea handle = %s", tracebuff);
/* displaying attributes */
printattributes(attribs);
/* getting handle and attributes for subdirectory "bin" */
if(FSAL_IS_ERROR(st = FSAL_str2name("prot", 5, &name)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
root_handle = handle;
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookup(&root_handle, &name, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea/prot handle = %s", tracebuff);
/* displaying attributes */
printattributes(attribs);
/* getting handle and attributes for symlink "AglaePwrSW" */
if(FSAL_IS_ERROR(st = FSAL_str2name("lama", 5, &name)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
root_handle = handle;
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookup(&root_handle, &name, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea/prot/lama handle = %s", tracebuff);
/* displaying attributes */
printattributes(attribs);
}
else
/* TEST 3 */
if(test[0] == '3')
{
/* lookup root */
if(FSAL_IS_ERROR(st = FSAL_str2path("/", 30, &path)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookupPath(&path, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/ handle = %s", tracebuff);
/* displaying attributes */
printattributes(attribs);
/* lookup path */
if(FSAL_IS_ERROR(st = FSAL_str2path("/cea/prot/lama", 15, &path)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookupPath(&path, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea/prot/lama handle = %s", tracebuff);
/* displaying attributes */
printattributes(attribs);
}
else
/* TEST 4 */
if(test[0] == '4')
{
/* readdir on root */
fsal_dir_t dir;
fsal_cookie_t from, to;
fsal_dirent_t entries[READDIR_SIZE];
fsal_count_t number;
fsal_boolean_t eod = FALSE;
int error = FALSE;
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_opendir(&root_handle, &op_ctx, &dir, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
LogTest("'/' attributes :");
/* displaying attributes */
printattributes(attribs);
from = FSAL_READDIR_FROM_BEGINNING;
while(!error && !eod)
{
unsigned int i;
char cookiebuff[256];
snprintCookie(cookiebuff, 256, &from);
LogTest("\nReaddir cookie = %s", cookiebuff);
if(FSAL_IS_ERROR(st = FSAL_readdir(&dir, from,
mask, READDIR_SIZE * sizeof(fsal_dirent_t),
entries, &to, &number, &eod)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
error = TRUE;
}
for(i = 0; (!error) && (i < number); i++)
{
snprintHandle(tracebuff, 256, &entries[i].handle);
snprintCookie(cookiebuff, 256, &entries[i].cookie);
LogTest("\t%s : %s (cookie %s)", tracebuff,
entries[i].name.name, cookiebuff);
}
/* preparing next call */
from = to;
}
LogTest("Fin de boucle : error=%d ; eod=%d", error, eod);
}
else
/* TEST 5 */
if(test[0] == '5')
{
/* readdir on root */
fsal_dir_t dir;
fsal_cookie_t from, to;
fsal_dirent_t entries[READDIR_SIZE];
fsal_count_t number;
fsal_boolean_t eod = FALSE;
int error = FALSE;
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_opendir(&root_handle, &op_ctx, &dir, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
LogTest("'/' attributes :");
/* displaying attributes */
printattributes(attribs);
from = FSAL_READDIR_FROM_BEGINNING;
while(!error && !eod)
{
fsal_dirent_t *curr;
char cookiebuff[256];
snprintCookie(cookiebuff, 256, &from);
LogTest("\nReaddir cookie = %s", cookiebuff);
if(FSAL_IS_ERROR(st = FSAL_readdir(&dir, from,
mask, READDIR_SIZE * sizeof(fsal_dirent_t),
entries, &to, &number, &eod)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
error = TRUE;
}
if(number > 0)
{
curr = entries;
do
{
snprintHandle(tracebuff, 256, &curr->handle);
snprintCookie(cookiebuff, 256, &curr->cookie);
LogTest("\t%s : %s (cookie %s)", tracebuff,
curr->name.name, cookiebuff);
}
while(curr = curr->nextentry);
}
/* preparing next call */
from = to;
}
LogTest("Fin de boucle : error=%d ; eod=%d", error, eod);
}
else
/* TEST 6 */
if(test[0] == '6')
{
/* readdir on root */
fsal_dir_t dir;
fsal_cookie_t from, to;
fsal_dirent_t entries[READDIR_SIZE];
fsal_count_t number;
fsal_boolean_t eod = FALSE;
int error = FALSE;
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_opendir(&root_handle, &op_ctx, &dir, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
LogTest("'/' attributes :");
/* displaying attributes */
printattributes(attribs);
from = FSAL_READDIR_FROM_BEGINNING;
while(!error && !eod)
{
unsigned int i;
snprintCookie(tracebuff, 256, &from);
LogTest("\nReaddir cookie = %s", tracebuff);
st = FSAL_readdir(&dir, from, mask,
READDIR_SIZE * sizeof(fsal_dirent_t),
entries, &to, &number, &eod);
if(FSAL_IS_ERROR(st))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
error = TRUE;
}
/* for each entry, we compare the result of FSAL_access
* to FSAL_test_access. */
for(i = 0; (!error) && (i < number); i++)
{
fsal_status_t st1, st2;
char cookiebuff[256];
snprintHandle(tracebuff, 256, &entries[i].handle);
snprintCookie(cookiebuff, 256, &entries[i].cookie);
LogTest("\t%s : %s (cookie %s)", tracebuff,
entries[i].name.name, cookiebuff);
if(FSAL_IS_ERROR(st = ZFSFSAL_getattrs(&entries[i].handle, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
/* 1 - test R access */
st1 = FSAL_access(&entries[i].handle, &op_ctx, FSAL_R_OK, NULL);
st2 = FSAL_test_access(&op_ctx, FSAL_R_OK, &attribs);
LogError(COMPONENT_STDOUT, ERR_FSAL, st1.major, st1.minor);
LogError(COMPONENT_STDOUT, ERR_FSAL, st2.major, st2.minor);
if(st1.major != st2.major)
{
LogTest
("Error : different access permissions given by FSAL_access and FSAL_test_access : %d <>%d",
st1.major, st2.major);
}
/* 2 - test W access */
st1 = FSAL_access(&entries[i].handle, &op_ctx, FSAL_W_OK, NULL);
st2 = FSAL_test_access(&op_ctx, FSAL_W_OK, &attribs);
LogError(COMPONENT_STDOUT, ERR_FSAL, st1.major, st1.minor);
LogError(COMPONENT_STDOUT, ERR_FSAL, st2.major, st2.minor);
if(st1.major != st2.major)
{
LogTest
("Error : different access permissions given by FSAL_access and FSAL_test_access : %d <>%d",
st1.major, st2.major);
}
/* 3 - test X access */
st1 = FSAL_access(&entries[i].handle, &op_ctx, FSAL_X_OK, NULL);
st2 = FSAL_test_access(&op_ctx, FSAL_X_OK, &attribs);
LogError(COMPONENT_STDOUT, ERR_FSAL, st1.major, st1.minor);
LogError(COMPONENT_STDOUT, ERR_FSAL, st2.major, st2.minor);
if(st1.major != st2.major)
{
LogTest
("Error : different access permissions given by FSAL_access and FSAL_test_access : %d <>%d",
st1.major, st2.major);
}
}
/* preparing next call */
from = to;
}
LogTest("Fin de boucle : error=%d ; eod=%d", error, eod);
}
else
/* TEST 7 */
if(test[0] == '7')
{
/* test snprintmem and sscanmem */
char test_string[] =
"Ceci est une chaine d'essai.\nLes chiffres : 0123456789\nLes lettres : ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char buffer[256];
char string[200]; /* 200 suffit car test_string fait <100 */
int size1, size2, size3, i;
/* we put bad values in string, to see if it is correctly set. */
for(i = 0; i < 200; i++)
string[i] = (char)i;
LogTest("Initial data (%d Bytes) = <<%s>>", strlen(test_string), test_string);
/* Write test_string to a buffer. */
/* We don't give the final '\0'. */
snprintmem(buffer, 256, test_string, strlen(test_string));
LogTest("Dest_Buffer (%d Bytes) = <<%s>>", strlen(buffer), buffer);
/* read the value from the buffer */
sscanmem(string, strlen(test_string), buffer);
/* sets the final 0 to print the content of the buffer */
LogTest("Retrieved string : following byte = %d",
(int)string[strlen(test_string)]);
string[strlen(test_string)] = '\0';
LogTest("Retrieved string (%d Bytes) = <<%s>>", strlen(string), string);
/* Automatic tests : */
size1 = strlen(test_string);
size2 = strlen(buffer);
size3 = strlen(string);
LogTest("-------------------------------------");
if(size1 <= 0)
LogTest("***** ERROR: source size=0 !!!");
if(size1 != size3)
LogTest("***** ERROR: source size <> target size");
else
LogTest("OK: source size = target size");
if((size1 * 2) != size2)
LogTest("***** ERROR: hexa size <> 2 * source size");
else
LogTest("OK: hexa size = 2 * source size");
if(strcmp(test_string, string))
LogTest("***** ERROR: source string <> target string");
else
LogTest("OK: source string = target string");
}
else
/* TEST 8 */
if(test[0] == '8')
{
fsal_handle_t dir_hdl, subdir_hdl;
fsal_name_t subdir_name;
/* lookup on /cea/prot/S/lama/s8/leibovic */
if(FSAL_IS_ERROR(st = FSAL_str2path("/cea/prot/S/lama/s8/leibovic", 40, &path)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookupPath(&path, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea/prot/S/lama/s8/leibovic: handle = %s", tracebuff);
sleep(1);
/* creates a directory */
LogTest("------- Create a directory -------");
if(FSAL_IS_ERROR(st = FSAL_str2name("tests_GANESHA", 30, &name)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_mkdir(&handle, &name, &op_ctx,
FSAL_MODE_RUSR | FSAL_MODE_WUSR
| FSAL_MODE_XUSR | FSAL_MODE_RGRP
| FSAL_MODE_WGRP, &dir_hdl, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
snprintHandle(tracebuff, 256, &dir_hdl);
LogTest("newly created dir handle = %s", tracebuff);
printattributes(attribs);
}
sleep(1);
/* Try to create it again */
LogTest("------- Try to create it again -------");
if(FSAL_IS_ERROR(st = FSAL_mkdir(&handle, &name, &op_ctx,
FSAL_MODE_RUSR | FSAL_MODE_WUSR
| FSAL_MODE_XUSR | FSAL_MODE_RGRP
| FSAL_MODE_WGRP, &dir_hdl, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
LogTest("**** Error: FSAL should have returned ERR_FSAL_EXIST");
}
sleep(1);
/* creates a subdirectory */
LogTest("------- Create a subdirectory -------");
if(FSAL_IS_ERROR(st = FSAL_str2name("subdir_GANESHA", 30, &subdir_name)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
if(FSAL_IS_ERROR(st = FSAL_mkdir(&dir_hdl, &subdir_name, &op_ctx,
FSAL_MODE_RUSR | FSAL_MODE_WUSR
| FSAL_MODE_XUSR | FSAL_MODE_RGRP
| FSAL_MODE_WGRP, &subdir_hdl, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
snprintHandle(tracebuff, 256, &subdir_hdl);
LogTest("newly created subdir handle = %s", tracebuff);
printattributes(attribs);
}
/* try to removes the parent directory */
LogTest("------- Try to removes the parent directory -------");
if(FSAL_IS_ERROR(st = FSAL_unlink(&handle, &name, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
LogTest("FSAL should not have unlinked %s because it is not empty", name.name);
}
sleep(1);
/* removes the subdirectory */
LogTest("------- Removes the subdirectory -------");
if(FSAL_IS_ERROR(st = FSAL_unlink(&dir_hdl, &subdir_name, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
LogTest("New attributes for parent directory:");
printattributes(attribs);
}
/* removes the parent directory */
LogTest("------- Removes the parent directory -------");
if(FSAL_IS_ERROR(st = FSAL_unlink(&handle, &name, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
LogTest("Unlink %s OK", name.name);
}
}
/* TEST 9 */
else if(test[0] == '9')
{
fsal_handle_t dir_hdl, subdir_hdl;
fsal_name_t subdir_name;
fsal_attrib_list_t attr_set;
fsal_fsid_t set_fsid = { 1LL, 2LL };
#ifdef _LINUX
struct tm jour_heure = { 56, 34, 12, 31, 12, 110, 0, 0, 0, 0, 0 };
#else
struct tm jour_heure = { 56, 34, 12, 31, 12, 110, 0, 0, 0 };
#endif
/* lookup on /cea/prot/S/lama/s8/leibovic */
if(FSAL_IS_ERROR(st = FSAL_str2path("/cea/prot/S/lama/s8/leibovic", 40, &path)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookupPath(&path, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea/prot/S/lama/s8/leibovic: handle = %s", tracebuff);
sleep(1);
/* creates a file */
LogTest("------- Create a file -------");
if(FSAL_IS_ERROR(st = FSAL_str2name("tests_GANESHA_setattrs", 30, &name)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_create(&handle, &name, &op_ctx,
FSAL_MODE_RUSR | FSAL_MODE_WUSR
| FSAL_MODE_XUSR | FSAL_MODE_RGRP
| FSAL_MODE_WGRP, &dir_hdl, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
snprintHandle(tracebuff, 256, &dir_hdl);
LogTest("newly created file handle = %s", tracebuff);
printattributes(attribs);
}
sleep(1);
LogTest("------- Try to change its attributes -------");
/* Macro that try to change the value for an attribute */
#define CHANGE_ATTRS( str_nom, nom, flag, new_val ) do {\
memset(&attr_set, 0, sizeof(fsal_attrib_list_t) ); \
LogTest("\nTry to change '%s' :",str_nom); \
FSAL_SET_MASK( attr_set.asked_attributes , flag ); \
attr_set.nom = new_val; \
attribs.asked_attributes = attr_set.asked_attributes; \
/* attribs.asked_attributes = mask; */\
st = FSAL_setattrs( &dir_hdl, &op_ctx, &attr_set, &attribs );\
if ( FSAL_IS_ERROR(st) ) \
LogError(COMPONENT_STDOUT,ERR_FSAL,st.major,st.minor);\
else \
printattributes( attribs ); \
} while(0)
CHANGE_ATTRS("supported_attributes", supported_attributes,
FSAL_ATTR_SUPPATTR, FSAL_ATTRS_MANDATORY);
CHANGE_ATTRS("type", type, FSAL_ATTR_TYPE, FSAL_TYPE_LNK);
sleep(1); /* to see mtime modification by truncate */
CHANGE_ATTRS("filesize", filesize, FSAL_ATTR_SIZE, (fsal_size_t) 12);
sleep(1); /* to see mtime modification by truncate */
CHANGE_ATTRS("fsid", fsid, FSAL_ATTR_FSID, set_fsid);
/* @todo : ACLs */
CHANGE_ATTRS("fileid", fileid, FSAL_ATTR_FILEID, (fsal_u64_t) 1234);
CHANGE_ATTRS("mode", mode, FSAL_ATTR_MODE,
(FSAL_MODE_RUSR | FSAL_MODE_WUSR | FSAL_MODE_RGRP));
CHANGE_ATTRS("numlinks", numlinks, FSAL_ATTR_NUMLINKS, 7);
/* FSAL_ATTR_RAWDEV */
CHANGE_ATTRS("atime", atime.seconds, FSAL_ATTR_ATIME, mktime(&jour_heure));
jour_heure.tm_min++;
CHANGE_ATTRS("creation", creation.seconds, FSAL_ATTR_CREATION, mktime(&jour_heure));
jour_heure.tm_min++;
CHANGE_ATTRS("mtime", mtime.seconds, FSAL_ATTR_MTIME, mktime(&jour_heure));
jour_heure.tm_min++;
CHANGE_ATTRS("ctime", ctime.seconds, FSAL_ATTR_CTIME, mktime(&jour_heure));
CHANGE_ATTRS("spaceused", spaceused, FSAL_ATTR_SPACEUSED, (fsal_size_t) 12345);
CHANGE_ATTRS("mounted_on_fileid", mounted_on_fileid,
FSAL_ATTR_MOUNTFILEID, (fsal_u64_t) 3210);
CHANGE_ATTRS("owner", owner, FSAL_ATTR_OWNER, 3051); /* deniel */
CHANGE_ATTRS("group", group, FSAL_ATTR_GROUP, 5953); /* sr */
sleep(1);
/* removes the parent directory */
LogTest("------- Removes the directory -------");
if(FSAL_IS_ERROR(st = FSAL_unlink(&handle, &name, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
LogTest("Unlink %s OK", name.name);
}
}
else if(test[0] == 'A')
{
char digest_buff[FSAL_DIGEST_SIZE_HDLV3];
/* lookup on /cea/prot/S/lama/s8/leibovic */
if(FSAL_IS_ERROR(st = FSAL_str2path("/cea/prot/S/lama/s8/leibovic", 40, &path)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookupPath(&path, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea/prot/S/lama/s8/leibovic: handle = %s", tracebuff);
/* building digest */
st = FSAL_DigestHandle(&export_ctx, FSAL_DIGEST_NFSV3, &handle, digest_buff);
if(FSAL_IS_ERROR(st))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
/* print digest */
snprintmem(tracebuff, 256, digest_buff, FSAL_DIGEST_SIZE_HDLV3);
LogTest("/cea/prot/S/lama/s8/leibovic: handle_digest = %s", tracebuff);
}
memset(&handle, 0, sizeof(fsal_handle_t));
/* expend digest */
st = FSAL_ExpandHandle(&export_ctx, FSAL_DIGEST_NFSV3, digest_buff, &handle);
if(FSAL_IS_ERROR(st))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
/* print expended handle */
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea/prot/S/lama/s8/leibovic: handle expended = %s", tracebuff);
}
}
else if(test[0] == 'B')
{
fsal_dynamicfsinfo_t dyninfo;
if(FSAL_IS_ERROR(st = FSAL_dynamic_fsinfo(&root_handle, &op_ctx, &dyninfo)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
exit(st.major);
}
LogTest("total_bytes = %llu", dyninfo.total_bytes);
LogTest("free_bytes = %llu", dyninfo.free_bytes);
LogTest("avail_bytes = %llu", dyninfo.avail_bytes);
LogTest("total_files = %llu", dyninfo.total_files);
LogTest("free_files = %llu", dyninfo.free_files);
LogTest("avail_files = %llu", dyninfo.avail_files);
LogTest("time_delta = %u.%u", dyninfo.time_delta.seconds,
dyninfo.time_delta.nseconds);
}
else
LogTest("%s : test inconnu", test);
return 0;
}
main(int argc, char *argv[])
{
char localmachine[256];
cache_inode_client_t client;
LRU_parameter_t lru_param;
LRU_status_t lru_status;
cache_inode_fsal_data_t fsdata;
fsal_status_t status;
fsal_parameter_t init_param;
fsal_name_t name;
fsal_path_t path;
fsal_attrib_mask_t mask;
fsal_path_t pathroot;
fsal_attrib_list_t attribs;
fsal_handle_t root_handle;
cache_inode_endofdir_t eod_met;
cache_inode_dir_entry_t dirent_array[100];
cache_inode_dir_entry_t dirent_array_loop[5];
unsigned int nbfound;
unsigned int begin_cookie = 0;
hash_buffer_t key, value;
uid_t uid;
fsal_cred_t cred;
cache_inode_status_t cache_status;
cache_inode_parameter_t cache_param;
cache_inode_client_parameter_t cache_client_param;
hash_table_t *ht = NULL;
fsal_attrib_list_t attrlookup;
cache_entry_t *cache_entry_root = NULL;
cache_entry_t *cache_entry_lookup = NULL;
cache_entry_t *cache_entry_lookup2 = NULL;
cache_entry_t *cache_entry_lookup3 = NULL;
cache_entry_t *cache_entry_lookup4 = NULL;
cache_entry_t *cache_entry_lookup5 = NULL;
cache_entry_t *cache_entry_lookup6 = NULL;
cache_entry_t *cache_entry_dircont = NULL;
cache_inode_gc_policy_t gcpol;
char *configfile = argv[1];
int i = 0;
int rc = 0;
/* Init the Buddy System allocation */
if((rc = BuddyInit(NULL)) != BUDDY_SUCCESS)
{
LogTest("Error while initializing Buddy system allocator");
exit(1);
}
/* init debug */
SetNamePgm("test_cache_inode");
SetDefaultLogging("TEST");
SetNameFunction("main");
InitLogging();
#if defined( _USE_GHOSTFS )
if(argc != 2)
{
LogTest("Please set the configuration file as parameter");
exit(1);
}
#endif
/* Obtention du nom de la machine */
if(gethostname(localmachine, sizeof(localmachine)) != 0)
{
LogError(COMPONENT_STDOUT, ERR_SYS, ERR_GETHOSTNAME, errno);
exit(1);
}
else
SetNameHost(localmachine);
AddFamilyError(ERR_FSAL, "FSAL related Errors", tab_errstatus_FSAL);
AddFamilyError(ERR_CACHE_INODE, "FSAL related Errors", tab_errstatus_cache_inode);
LogTest( "Starting the test");
LogTest( "-----------------");
#if defined( _USE_GHOSTFS )
if(FSAL_IS_ERROR(status = FSAL_str2path(configfile,
strlen(configfile) + 1,
&(init_param.fs_specific_info.
definition_file))))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor);
}
#elif defined( _USE_HPSS )
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, Flags);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DebugValue);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, TransferType);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, NumRetries);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, BusyDelay);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, BusyRetries);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, TotalDelay);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, GKTotalDelay);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, LimitedRetries);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, MaxConnections);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, ReuseDataConnections);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, UsePortRange);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, RetryStageInp);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DMAPWriteUpdates);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, ServerName);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DescName);
init_param.fs_specific_info.behaviors.PrincipalName = FSAL_INIT_FORCE_VALUE;
strncpy(init_param.fs_specific_info.hpss_config.PrincipalName,
HPSS_SSM, HPSS_MAX_PRINCIPAL_NAME);
init_param.fs_specific_info.behaviors.KeytabPath = FSAL_INIT_FORCE_VALUE;
strncpy(init_param.fs_specific_info.hpss_config.KeytabPath,
HPSS_KEYTAB, HPSS_MAX_PATH_NAME);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DebugPath);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, HostName);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, RegistrySiteName);
#endif
/* 2-common info (default) */
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxfilesize);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxlink);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxnamelen);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxpathlen);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, no_trunc);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, chown_restricted);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, case_insensitive);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, case_preserving);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, fh_expire_type);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, link_support);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, symlink_support);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, named_attr);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, unique_handles);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, lease_time);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, acl_support);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, cansettime);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, homogenous);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxread);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxwrite);
/* Init */
if(FSAL_IS_ERROR(status = FSAL_Init(&init_param)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor);
}
/* getting creds */
uid = getuid();
if(FSAL_IS_ERROR(status = FSAL_GetUserCred(uid, NULL, &cred)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor);
}
/* Init of the cache inode module */
cache_param.hparam.index_size = 31;
cache_param.hparam.alphabet_length = 10; /* Buffer seen as a decimal polynom */
cache_param.hparam.nb_node_prealloc = 100;
cache_param.hparam.hash_func_key = cache_inode_fsal_hash_func;
cache_param.hparam.hash_func_rbt = cache_inode_fsal_rbt_func;
cache_param.hparam.hash_func_both = NULL ; /* BUGAZOMEU */
cache_param.hparam.compare_key = cache_inode_compare_key_fsal;
cache_param.hparam.key_to_str = display_key;
cache_param.hparam.val_to_str = display_value;
if((ht = cache_inode_init(cache_param, &cache_status)) == NULL)
{
LogTest( "Error %d while init hash ", cache_status);
}
else
LogTest( "Hash Table address = %p", ht);
/* We need a cache_client to acces the cache */
cache_client_param.attrmask =
FSAL_ATTRS_MANDATORY | FSAL_ATTR_MTIME | FSAL_ATTR_CTIME | FSAL_ATTR_ATIME;
cache_client_param.nb_prealloc_entry = 1000;
cache_client_param.nb_pre_dir_data = 200;
cache_client_param.nb_pre_parent = 1200;
cache_client_param.nb_pre_state_v4 = 100;
cache_client_param.lru_param.nb_entry_prealloc = 1000;
cache_client_param.lru_param.entry_to_str = lru_entry_to_str;
cache_client_param.lru_param.clean_entry = lru_clean_entry;
cache_client_param.grace_period_attr = 0;
cache_client_param.grace_period_link = 0;
cache_client_param.grace_period_dirent = 0;
cache_client_param.expire_type_attr = CACHE_INODE_EXPIRE_NEVER;
cache_client_param.expire_type_link = CACHE_INODE_EXPIRE_NEVER;
cache_client_param.expire_type_dirent = CACHE_INODE_EXPIRE_NEVER;
/* Init the cache_inode client */
if(cache_inode_client_init(&client, cache_client_param, 0) != 0)
exit(1);
/* Getting the root of the FS */
if((FSAL_IS_ERROR(status = FSAL_str2path("/", 2, &pathroot))))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor);
exit(1);
}
attribs.asked_attributes = cache_client_param.attrmask;
if((FSAL_IS_ERROR(status = FSAL_lookupPath(pathroot, &cred, &root_handle, &attribs))))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor);
exit(1);
}
fsdata.cookie = 0;
fsdata.handle = root_handle;
/* Cache the root of the FS */
if((cache_entry_root =
cache_inode_make_root(&fsdata, 1, ht, &client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't init fs's root");
exit(1);
}
/* A lookup in the root fsal */
if((FSAL_IS_ERROR(status = FSAL_str2name("cea", 10, &name))))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor);
exit(1);
}
if((cache_entry_lookup = cache_inode_lookup(cache_entry_root,
name,
&attrlookup,
ht, &client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
/* Lookup a second time (entry should now be cached) */
if((cache_entry_lookup2 = cache_inode_lookup(cache_entry_root,
name,
&attrlookup,
ht,
&client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
if(cache_entry_lookup2 != cache_entry_lookup)
{
LogTest("Error: lookup results should be the same");
exit(1);
}
/* A lookup in the root fsal */
if((FSAL_IS_ERROR(status = FSAL_str2name("log", 10, &name))))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor);
exit(1);
}
if((cache_entry_lookup3 = cache_inode_lookup(cache_entry_root,
name,
&attrlookup,
ht,
&client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
if((cache_entry_lookup4 = cache_inode_lookup(cache_entry_root,
name,
&attrlookup,
ht,
&client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
if(cache_entry_lookup3 != cache_entry_lookup4)
{
LogTest("Error: lookup results should be the same");
exit(1);
}
/* A lookup in the root fsal */
if((FSAL_IS_ERROR(status = FSAL_str2name("cea", 10, &name))))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor);
exit(1);
}
if((cache_entry_lookup = cache_inode_lookup(cache_entry_root,
name,
&attrlookup,
ht, &client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
/* A lookup in the root fsal */
if((FSAL_IS_ERROR(status = FSAL_str2name("log", 10, &name))))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor);
exit(1);
}
if((cache_entry_lookup = cache_inode_lookup(cache_entry_root,
name,
&attrlookup,
ht, &client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
LogTest( "---------------------------------");
/* The end of all the tests */
LogTest( "All tests exited successfully");
exit(0);
} /* main */
int main(int argc, char **argv)
{
unsigned int i;
struct timeval tv1, tv2, tv3, tvdiff;
int count, rc;
char *dir;
handle_map_param_t param;
time_t now;
/* Init logging */
SetNamePgm("test_handle_mapping");
SetDefaultLogging("TEST");
SetNameFunction("main");
SetNameHost("localhost");
InitLogging();
if(argc != 3 || (count = atoi(argv[2])) == 0)
{
LogTest("usage: test_handle_mapping <db_dir> <db_count>");
exit(1);
}
#ifndef _NO_BUDDY_SYSTEM
if((rc = BuddyInit(NULL)) != BUDDY_SUCCESS)
{
/* Failed init */
LogCrit(COMPONENT_FSAL, "ERROR: Could not initialize memory manager");
exit(rc);
}
#endif
dir = argv[1];
strcpy(param.databases_directory, dir);
strcpy(param.temp_directory, "/tmp");
param.database_count = count;
param.hashtable_size = 27;
param.nb_handles_prealloc = 1024;
param.nb_db_op_prealloc = 1024;
param.synchronous_insert = FALSE;
rc = HandleMap_Init(¶m);
LogTest("HandleMap_Init() = %d", rc);
if(rc)
exit(rc);
gettimeofday(&tv1, NULL);
/* Now insert a set of handles */
now = time(NULL);
for(i = 0; i < 10000; i++)
{
nfs23_map_handle_t nfs23_digest;
fsal_handle_t handle;
memset(&handle, i, sizeof(fsal_handle_t));
nfs23_digest.object_id = 12345 + i;
nfs23_digest.handle_hash = (1999 * i + now) % 479001599;
rc = HandleMap_SetFH(&nfs23_digest, &handle);
if(rc && (rc != HANDLEMAP_EXISTS))
exit(rc);
}
gettimeofday(&tv2, NULL);
timersub(&tv2, &tv1, &tvdiff);
LogTest("%u threads inserted 10000 handles in %d.%06ds",
count, (int)tvdiff.tv_sec, (int)tvdiff.tv_usec);
/* Now get them ! */
for(i = 0; i < 10000; i++)
{
nfs23_map_handle_t nfs23_digest;
fsal_handle_t handle;
nfs23_digest.object_id = 12345 + i;
nfs23_digest.handle_hash = (1999 * i + now) % 479001599;
rc = HandleMap_GetFH(&nfs23_digest, &handle);
if(rc)
{
LogTest("Error %d retrieving handle !", rc);
exit(rc);
}
rc = HandleMap_DelFH(&nfs23_digest);
if(rc)
{
LogTest("Error %d deleting handle !", rc);
exit(rc);
}
}
gettimeofday(&tv3, NULL);
timersub(&tv3, &tv2, &tvdiff);
LogTest("Retrieved and deleted 10000 handles in %d.%06ds", (int)tvdiff.tv_sec,
(int)tvdiff.tv_usec);
rc = HandleMap_Flush();
gettimeofday(&tv3, NULL);
timersub(&tv3, &tv1, &tvdiff);
LogTest("Total time with %u threads (including flush): %d.%06ds", count,
(int)tvdiff.tv_sec, (int)tvdiff.tv_usec);
exit(0);
}
int main(int argc, char **argv)
{
int rc, i;
ns_testset_t *p_test;
char path[FSAL_MAX_PATH_LEN];
unsigned int gen = 0;
unsigned int dev = DEV;
/* Init logging */
SetNamePgm("test_ns");
SetDefaultLogging("TEST");
SetNameFunction("main");
InitLogging();
/* namespace init */
rc = NamespaceInit(ROOT_INODE, DEV, &gen);
if(rc)
{
LogTest("NamespaceInit rc=%d\n", rc);
exit(1);
}
for(i = 0; i < 2; i++)
{
/* creation des entrees */
for(p_test = testset; p_test->name != NULL; p_test++)
{
rc = NamespaceAdd(p_test->parent_inode, DEV, gen, p_test->name,
p_test->entry_inode, DEV, &gen);
LogTest("NamespaceAdd(%lu,%s->%lu) = %d\n", p_test->parent_inode, p_test->name,
p_test->entry_inode, rc);
if(rc)
exit(1); /* This is an error */
}
/* tentative de recreation */
for(p_test = testset; p_test->name != NULL; p_test++)
{
rc = NamespaceAdd(p_test->parent_inode, DEV, gen, p_test->name,
p_test->entry_inode, DEV, &gen);
LogTest("Redundant NamespaceAdd(%lu,%s->%lu) = %d\n", p_test->parent_inode,
p_test->name, p_test->entry_inode, rc);
if(rc)
exit(1); /* This is an error */
}
/* recolte du chemin complet de root */
rc = NamespacePath(ROOT_INODE, DEV, gen, path);
if(rc)
{
LogTest("NamespacePath(%lu) rc=%d\n", ROOT_INODE, rc);
exit(1);
}
else
LogTest("NamespacePath(%lu) => \"%s\"\n", ROOT_INODE, path);
/* recolte du chemin complet des entrees */
for(p_test = testset; p_test->name != NULL; p_test++)
{
rc = NamespacePath(p_test->entry_inode, DEV, gen, path);
if(rc)
{
LogTest("NamespacePath(%lu) rc=%d\n", p_test->entry_inode, rc);
exit(1);
}
else
LogTest("NamespacePath(%lu) => \"%s\"\n", p_test->entry_inode, path);
}
/* on efface les entrees en ordre inverse */
for(p_test--; p_test >= testset; p_test--)
{
rc = NamespaceRemove(p_test->parent_inode, DEV, gen, p_test->name);
LogTest("NamespaceRemove(%lu,%s) = %d\n", p_test->parent_inode,
p_test->name, rc);
}
/* on essaye d'obtenir leur nom */
for(p_test = testset; p_test->name != NULL; p_test++)
{
rc = NamespacePath(p_test->entry_inode, DEV, gen, path);
if(rc == 0)
{
LogTest("NamespacePath(%lu) => \"%s\"\n", p_test->entry_inode, path);
exit(1);
}
else if(rc != ENOENT)
{
LogTest("NamespacePath(%lu) rc=%d\n", p_test->entry_inode, rc);
exit(1);
}
else
LogTest("NamespacePath(%lu) rc=%d (ENOENT)\n", p_test->entry_inode, rc);
}
}
/* now create/remove a hardlink to a file N times */
rc = NamespaceAdd(ROOT_INODE, DEV, gen, "dir", ROOT_INODE + 1, DEV, &gen);
if(rc)
{
LogTest("NamespaceAdd error %d line %d\n", rc, __LINE__ - 1);
exit(1);
}
rc = NamespaceAdd(ROOT_INODE + 1, DEV, gen, "subdir", ROOT_INODE + 2, DEV, &gen);
if(rc)
{
LogTest("NamespaceAdd error %d line %d\n", rc, __LINE__ - 1);
exit(1);
}
rc = NamespaceAdd(ROOT_INODE + 2, DEV, gen, "entry", ROOT_INODE + 3, DEV, &gen);
if(rc)
{
LogTest("NamespaceAdd error %d line %d\n", rc, __LINE__ - 1);
exit(1);
}
/* create hardlinks and lookup */
for(i = 0; i < 3; i++)
{
char name[FSAL_MAX_NAME_LEN];
sprintf(name, "entry.hl%d", i);
rc = NamespaceAdd(ROOT_INODE + 2, DEV, gen, name, ROOT_INODE + 3, DEV, &gen);
LogTest("NamespaceAdd(%lu,%s->%lu) = %d\n", ROOT_INODE + 2, name, ROOT_INODE + 3,
rc);
if(rc)
exit(1);
rc = NamespacePath(ROOT_INODE + 3, DEV, gen, path);
if(rc)
{
LogTest("NamespacePath(%lu) rc=%d\n", ROOT_INODE + 3, rc);
exit(1);
}
else
LogTest("NamespacePath(%lu) => \"%s\"\n", ROOT_INODE + 3, path);
}
/* delete hardlinks and lookup */
for(i = 0; i < 3; i++)
{
char name[FSAL_MAX_NAME_LEN];
sprintf(name, "entry.hl%d", i);
rc = NamespaceRemove(ROOT_INODE + 2, DEV, gen, name);
LogTest("NamespaceRemove(%lu,%s) = %d\n", ROOT_INODE + 2, name, rc);
if(rc)
exit(1);
rc = NamespacePath(ROOT_INODE + 3, DEV, gen, path);
if(rc)
{
LogTest("NamespacePath(%lu) rc=%d\n", ROOT_INODE + 3, rc);
exit(1);
}
else
LogTest("NamespacePath(%lu) => \"%s\"\n", ROOT_INODE + 3, path);
}
return 0;
}
int main(int argc, char *argv[])
{
SetDefaultLogging("TEST");
SetNamePgm("test_configurable_lru");
char buf[LENBUF];
int ok = 1;
int hrc = 0;
int rc = 0;
int expected_rc;
char c;
char *p;
int key;
LRU_status_t status = 0;
LRU_list_t *plru;
LRU_parameter_t param;
param.nb_entry_prealloc = PREALLOC;
param.entry_to_str = print_entry;
param.clean_entry = clean_entry;
param.name = "Test";
BuddyInit(NULL);
if((plru = LRU_Init(param, &status)) == NULL)
{
LogTest("Test ECHOUE : Mauvaise init");
exit(1);
}
/*
*
* La syntaxe d'un test est
* 'i key rc' : invalide l'entree avec la clef key
* 'n key rc' : cree une nouvelle entree avec la clef key
* 'g key rc' : passage du garbage collector (key ne sert a rien)
* 'p key rc' : imprime le LRU (key et rc ne servent a rien).
*
* Une ligne qui debute par '#' est un commentaire
* Une ligne qui debute par un espace ou un tab est une ligne vide [meme si il y a des trucs derriere.. :-( ]
* Une ligne vide (juste un CR) est une ligne vide (cette citation a recu le Premier Prix lors du Festival International
* de la Tautologie de Langue Francaise (FITLF), a Poully le Marais, en Aout 2004)
*
*/
LogTest("============ Debut de l'interactif =================");
while(ok)
{
/* Code interactif, pompe sur le test rbt de Jacques */
fputs("> ", stdout);
if((p = fgets(buf, LENBUF, stdin)) == NULL)
{
LogTest("fin des commandes");
ok = 0;
continue;
}
if((p = strchr(buf, '\n')) != NULL)
*p = '\0';
rc = sscanf(buf, "%c %d %d", &c, &key, &expected_rc);
if(c == '#')
{
/* # indique un commentaire */
continue;
}
else if(c == ' ' || c == '\t' || rc == -1)
{
/* Cas d'une ligne vide */
if(rc > 1)
LogTest("Erreur de syntaxe : mettre un diese au debut d'un commentaire");
continue;
}
else
{
if(rc != 3)
{
LogTest("Erreur de syntaxe : sscanf retourne %d au lieu de 3", rc);
continue;
}
LogTest("---> %c %d %d", c, key, expected_rc);
}
switch (c)
{
case 'i':
/* set overwrite */
LogTest("invalidate %d --> %d ?", key, expected_rc);
hrc = do_invalidate(plru, key);
if(hrc != expected_rc)
LogTest(">>>> ERREUR: invalidate %d : %d != %d (expected)",
key, hrc, expected_rc);
else
LogTest(">>>> OK invalidate %d", key);
break;
case 'n':
/* test */
LogTest("new %d --> %d ?", key, expected_rc);
hrc = do_new(plru, key);
if(hrc != expected_rc)
LogTest(">>>> ERREUR: new %d : %d != %d (expected)", key, hrc, expected_rc);
else
LogTest(">>>> OK new %d", key);
break;
case 'g':
/* set no overwrite */
LogTest("gc %d --> %d ?", key, expected_rc);
hrc = do_gc(plru);
if(hrc != expected_rc)
LogTest(">>>> ERREUR: gc %d: %d != %d (expected)", key, hrc, expected_rc);
else
LogTest(">>>> OK new %d", key);
break;
case 'p':
/* Print */
LRU_Print(plru);
break;
default:
/* syntaxe error */
LogTest("ordre '%c' non-reconnu", c);
break;
}
}
LogTest("====================================================");
LogTest("Test reussi : tous les tests sont passes avec succes");
exit(0);
return;
} /* main */
int main(int argc, char *argv[])
{
SetDefaultLogging("TEST");
SetNamePgm("test_cmchash");
hash_table_t *ht = NULL;
hash_parameter_t hparam;
hash_buffer_t buffval;
hash_buffer_t buffkey;
hash_buffer_t buffval2;
hash_buffer_t buffkey2;
hash_stat_t statistiques;
int i;
int val;
int rc;
int res;
struct Temps debut, fin;
char tmpstr[10];
char tmpstr2[10];
char tmpstr3[10];
char strtab[MAXTEST][10];
int critere_recherche = 0;
int random_val = 0;
hparam.index_size = PRIME;
hparam.alphabet_length = 10;
hparam.nb_node_prealloc = NB_PREALLOC;
hparam.hash_func_key = simple_hash_func;
hparam.hash_func_rbt = rbt_hash_func;
hparam.compare_key = compare_string_buffer;
hparam.key_to_str = display_buff;
hparam.val_to_str = display_buff;
BuddyInit(NULL);
/* Init de la table */
if((ht = HashTable_Init(hparam)) == NULL)
{
LogTest("Test FAILED: Bad init");
exit(1);
}
MesureTemps(&debut, NULL);
LogTest("Created the table");
for(i = 0; i < MAXTEST; i++)
{
sprintf(strtab[i], "%d", i);
buffkey.len = strlen(strtab[i]);
buffkey.pdata = strtab[i];
buffval.len = strlen(strtab[i]);
buffval.pdata = strtab[i];
rc = HashTable_Set(ht, &buffkey, &buffval);
LogFullDebug(COMPONENT_HASHTABLE,"Added %s , %d , return = %d", strtab[i], i, rc);
}
MesureTemps(&fin, &debut);
LogTest("Time to insert %d entries: %s", MAXTEST,
ConvertiTempsChaine(fin, NULL));
LogFullDebug(COMPONENT_HASHTABLE, "-----------------------------------------");
HashTable_Log(COMPONENT_HASHTABLE,ht);
LogTest("=========================================");
/* Premier test simple: verif de la coherence des valeurs lues */
critere_recherche = CRITERE;
sprintf(tmpstr, "%d", critere_recherche);
buffkey.len = strlen(tmpstr);
buffkey.pdata = tmpstr;
MesureTemps(&debut, NULL);
rc = HashTable_Get(ht, &buffkey, &buffval);
MesureTemps(&fin, &debut);
LogTest("Recovery of %d th key ->%d", critere_recherche, rc);
LogTest("Time to recover = %s", ConvertiTempsChaine(fin, NULL));
if(rc != HASHTABLE_SUCCESS)
{
LogTest("Test FAILED: The key is not found");
exit(1);
}
sprintf(tmpstr, "%d", critere_recherche);
buffkey.len = strlen(tmpstr);
buffkey.pdata = tmpstr;
MesureTemps(&debut, NULL);
rc = HashTable_Get(ht, &buffkey, &buffval);
MesureTemps(&fin, &debut);
LogTest("Recovery of %d th key (test 2) -> %s", critere_recherche, rc);
LogTest("Time to recover = %s", ConvertiTempsChaine(fin, NULL));
if(rc != HASHTABLE_SUCCESS)
{
LogTest("Test FAILED: The key is not found (test 2)");
exit(1);
}
LogTest("----> retrieved value = len %d ; val = %s", buffval.len, buffval.pdata);
val = atoi(buffval.pdata);
if(val != critere_recherche)
{
LogTest("Test FAILED: the reading is incorrect");
exit(1);
}
LogTest("Now, I try to retrieve %d entries (taken at random, almost)",
MAXGET);
MesureTemps(&debut, NULL);
for(i = 0; i < MAXGET; i++)
{
random_val = random() % MAXTEST;
sprintf(tmpstr, "%d", random_val);
buffkey2.len = strlen(tmpstr);
buffkey2.pdata = tmpstr;
rc = HashTable_Get(ht, &buffkey2, &buffval2);
LogFullDebug(COMPONENT_HASHTABLE,"\tPlaying key = %s --> %s", buffkey2.pdata, buffval2.pdata);
if(rc != HASHTABLE_SUCCESS)
{
LogTest("Error reading %d = %d", i, rc);
LogTest("Test FAILED: the reading is incorrect");
exit(1);
}
}
MesureTemps(&fin, &debut);
LogTest("Time to read %d elements = %s", MAXGET,
ConvertiTempsChaine(fin, NULL));
LogTest("-----------------------------------------");
sprintf(tmpstr, "%d", critere_recherche);
buffkey.len = strlen(tmpstr);
buffkey.pdata = tmpstr;
rc = HashTable_Del(ht, &buffkey, NULL, NULL);
LogTest("Deleting the key %d --> %d", critere_recherche, rc);
if(rc != HASHTABLE_SUCCESS)
{
LogTest("Test FAILED: delete incorrect");
exit(1);
}
LogTest("=========================================");
sprintf(tmpstr, "%d", critere_recherche);
buffkey.len = strlen(tmpstr);
buffkey.pdata = tmpstr;
rc = HashTable_Del(ht, &buffkey, NULL, NULL);
LogTest("Deleting the key %d (2nd try) --> %d", critere_recherche, rc);
if(rc != HASHTABLE_ERROR_NO_SUCH_KEY)
{
printf("Test FAILED: delete incorrect");
exit(1);
}
LogTest("=========================================");
sprintf(tmpstr, "%d", critere_recherche);
buffkey.len = strlen(tmpstr);
buffkey.pdata = tmpstr;
rc = HashTable_Get(ht, &buffkey, &buffval);
LogTest
("Recovery of the %d key (erased) (must return HASH_ERROR_NO_SUCH_KEY) = %d --> %d",
critere_recherche, HASHTABLE_ERROR_NO_SUCH_KEY, rc);
if(rc != HASHTABLE_ERROR_NO_SUCH_KEY)
{
LogTest("Test FAILED: the reading is incorrect");
exit(1);
}
LogTest("-----------------------------------------");
LogTest
("Destruction of %d items, taken at random (well if you want ... I use srandom)",
MAXDESTROY);
srandom(getpid());
random_val = random() % MAXTEST;
MesureTemps(&debut, NULL);
for(i = 0; i < MAXDESTROY; i++)
{
/*
it used to be that the random values were chosen with
repeated calls to random(), but if the same key comes up twice,
that causes a fail. This way we start with a random value and
just linearly delete from it
*/
random_val = (random_val + 1) % MAXTEST;
sprintf(tmpstr, "%d", random_val);
LogTest("\t Delete %d", random_val);
buffkey.len = strlen(tmpstr);
buffkey.pdata = tmpstr;
rc = HashTable_Del(ht, &buffkey, NULL, NULL);
if(rc != HASHTABLE_SUCCESS)
{
LogTest("Error on delete %d = %d", i, rc);
LogTest("Test FAILED: delete incorrect");
exit(1);
}
}
MesureTemps(&fin, &debut);
LogTest("Time to delete %d elements = %s", MAXDESTROY,
ConvertiTempsChaine(fin, NULL));
LogTest("-----------------------------------------");
LogTest("Now, I try to retrieve %d entries (if necessary destroyed)",
MAXGET);
MesureTemps(&debut, NULL);
for(i = 0; i < MAXGET; i++)
{
random_val = random() % MAXTEST;
sprintf(tmpstr, "%d", random_val);
buffkey.len = strlen(tmpstr);
buffkey.pdata = tmpstr;
rc = HashTable_Get(ht, &buffkey, &buffval);
}
MesureTemps(&fin, &debut);
LogTest("Tie to read %d elements = %s", MAXGET,
ConvertiTempsChaine(fin, NULL));
LogTest("-----------------------------------------");
LogTest("Writing a duplicate key ");
sprintf(tmpstr, "%d", CRITERE_2);
buffkey.len = strlen(tmpstr);
buffkey.pdata = tmpstr;
rc = HashTable_Test_And_Set(ht, &buffkey, &buffval, HASHTABLE_SET_HOW_SET_NO_OVERWRITE);
LogTest("The value should be HASHTABLE_ERROR_KEY_ALREADY_EXISTS = %d --> %d",
HASHTABLE_ERROR_KEY_ALREADY_EXISTS, rc);
if(rc != HASHTABLE_ERROR_KEY_ALREADY_EXISTS)
{
LogTest("Test FAILED: duplicate key");
exit(1);
}
LogTest("-----------------------------------------");
HashTable_Log(COMPONENT_HASHTABLE,ht);
LogFullDebug(COMPONENT_HASHTABLE,"-----------------------------------------");
LogTest("Displaying table statistics ");
HashTable_GetStats(ht, &statistiques);
LogTest(" Number of entries = %d", statistiques.dynamic.nb_entries);
LogTest(" Successful operations : Set = %d, Get = %d, Del = %d, Test = %d",
statistiques.dynamic.ok.nb_set, statistiques.dynamic.ok.nb_get,
statistiques.dynamic.ok.nb_del, statistiques.dynamic.ok.nb_test);
LogTest(" Failed operations : Set = %d, Get = %d, Del = %d, Test = %d",
statistiques.dynamic.err.nb_set, statistiques.dynamic.err.nb_get,
statistiques.dynamic.err.nb_del, statistiques.dynamic.err.nb_test);
LogTest(" Operations 'NotFound': Set = %d, Get = %d, Del = %d, Test = %d",
statistiques.dynamic.notfound.nb_set, statistiques.dynamic.notfound.nb_get,
statistiques.dynamic.notfound.nb_del, statistiques.dynamic.notfound.nb_test);
LogTest
(" Calculated statistics: min_rbt_node = %d, max_rbt_node = %d, average_rbt_node = %d",
statistiques.computed.min_rbt_num_node, statistiques.computed.max_rbt_num_node,
statistiques.computed.average_rbt_num_node);
/* Test sur la pertinence des valeurs de statistiques */
if(statistiques.dynamic.ok.nb_set != MAXTEST)
{
LogTest("Test FAILED: Incorrect statistics: ok.nb_set ");
exit(1);
}
if(statistiques.dynamic.ok.nb_get + statistiques.dynamic.notfound.nb_get !=
2 * MAXGET + 3)
{
LogTest("Test FAILED: Incorrect statistics: *.nb_get ");
exit(1);
}
if(statistiques.dynamic.ok.nb_del != MAXDESTROY + 1
|| statistiques.dynamic.notfound.nb_del != 1)
{
LogTest("Test ECHOUE : statistiques incorrectes: *.nb_del ");
exit(1);
}
if(statistiques.dynamic.err.nb_test != 1)
{
LogTest("Test ECHOUE : statistiques incorrectes: err.nb_test ");
exit(1);
}
/* Tous les tests sont ok */
BuddyDumpMem(stdout);
LogTest("\n-----------------------------------------");
LogTest("Test succeeded: all tests pass successfully");
exit(0);
}
int main(int argc, char *argv[])
{
SetDefaultLogging("TEST");
SetNamePgm("test_libcmc_bugdelete");
LogTest("Initialized test program");
hash_table_t *ht = NULL;
hash_parameter_t hparam;
hash_buffer_t buffval;
hash_buffer_t buffkey;
hash_buffer_t buffval2;
hash_buffer_t buffkey2;
hash_stat_t statistiques;
int i;
int rc;
struct Temps debut, fin;
char tmpstr[10];
char strtab[MAXTEST][10];
int critere_recherche = 0;
int random_val = 0;
hparam.index_size = PRIME;
hparam.alphabet_length = 10;
hparam.nb_node_prealloc = NB_PREALLOC;
hparam.hash_func_key = simple_hash_func;
hparam.hash_func_rbt = rbt_hash_func;
hparam.hash_func_both = NULL ; /* BUGAZOMEU */
hparam.compare_key = compare_string_buffer;
hparam.key_to_str = display_buff;
hparam.val_to_str = display_buff;
BuddyInit(NULL);
/* Init de la table */
if((ht = HashTable_Init(hparam)) == NULL)
{
LogTest("Test FAILED: Bad init");
exit(1);
}
MesureTemps(&debut, NULL);
LogTest("Created hash table");
for(i = 0; i < MAXTEST; i++)
{
sprintf(strtab[i], "%d", i);
buffkey.len = strlen(strtab[i]);
buffkey.pdata = strtab[i];
buffval.len = strlen(strtab[i]);
buffval.pdata = strtab[i];
rc = HashTable_Set(ht, &buffkey, &buffval);
LogFullDebug(COMPONENT_HASHTABLE,
"Added %s , %d , return code = %d", strtab[i], i, rc);
}
MesureTemps(&fin, &debut);
LogTest("Time to insert %d entries: %s", MAXTEST,
ConvertiTempsChaine(fin, NULL));
LogFullDebug(COMPONENT_HASHTABLE,
"-----------------------------------------");
HashTable_Log(COMPONENT_HASHTABLE, ht);
LogFullDebug(COMPONENT_HASHTABLE,
"=========================================");
/* Premier test simple: verif de la coherence des valeurs lues */
critere_recherche = CRITERE;
sprintf(tmpstr, "%d", critere_recherche);
buffkey.len = strlen(tmpstr);
buffkey.pdata = tmpstr;
MesureTemps(&debut, NULL);
rc = HashTable_Get(ht, &buffkey, &buffval);
MesureTemps(&fin, &debut);
LogTest("Now, I try to retrieve %d entries (taken at random, almost)",
MAXGET);
MesureTemps(&debut, NULL);
for(i = 0; i < MAXGET; i++)
{
random_val = random() % MAXTEST;
sprintf(tmpstr, "%d", random_val);
buffkey2.len = strlen(tmpstr);
buffkey2.pdata = tmpstr;
rc = HashTable_Get(ht, &buffkey2, &buffval2);
LogTest("\tPlaying key = %s --> %s", buffkey2.pdata, buffval2.pdata);
if(rc != HASHTABLE_SUCCESS)
{
LogTest("Error reading %d = %d", i, rc);
LogTest("Test FAILED: the reading is incorrect");
exit(1);
}
}
MesureTemps(&fin, &debut);
LogTest("Time to read elements %d = %s", MAXGET,
ConvertiTempsChaine(fin, NULL));
LogTest("-----------------------------------------");
sprintf(tmpstr, "%d", critere_recherche);
buffkey.len = strlen(tmpstr);
buffkey.pdata = tmpstr;
sprintf(tmpstr, "%d", critere_recherche);
buffkey.len = strlen(tmpstr);
buffkey.pdata = tmpstr;
sprintf(tmpstr, "%d", critere_recherche);
buffkey.len = strlen(tmpstr);
buffkey.pdata = tmpstr;
srandom(getpid());
MesureTemps(&debut, NULL);
for(i = 0; i < MAXDESTROY; i++)
{
random_val = bugdelete_key_array[i];
sprintf(tmpstr, "%d", random_val);
buffkey.len = strlen(tmpstr);
buffkey.pdata = tmpstr;
LogFullDebug(COMPONENT_HASHTABLE, "\t Erase %u -> %lu | %lu",
random_val,
simple_hash_func(&hparam, &buffkey),
rbt_hash_func(&hparam, &buffkey));
rc = HashTable_Del(ht, &buffkey, NULL, NULL);
if(rc != HASHTABLE_SUCCESS)
{
LogTest("Erreur lors de la destruction de %d = %d", random_val, rc);
LogTest("Test FAILED: delete incorrect");
exit(1);
}
}
MesureTemps(&fin, &debut);
LogTest("Time to delete %d elements = %s", MAXDESTROY,
ConvertiTempsChaine(fin, NULL));
LogTest("-----------------------------------------");
LogTest("Now, I try to retrieve %d entries (possibly destroyed)",
MAXGET);
MesureTemps(&debut, NULL);
for(i = 0; i < MAXGET; i++)
{
random_val = random() % MAXTEST;
sprintf(tmpstr, "%d", random_val);
buffkey.len = strlen(tmpstr);
buffkey.pdata = tmpstr;
rc = HashTable_Get(ht, &buffkey, &buffval);
}
MesureTemps(&fin, &debut);
LogTest("Time to read %d elements = %s", MAXGET,
ConvertiTempsChaine(fin, NULL));
LogTest("-----------------------------------------");
LogTest("Writing a duplicated key");
sprintf(tmpstr, "%d", CRITERE_2);
buffkey.len = strlen(tmpstr);
buffkey.pdata = tmpstr;
rc = HashTable_Test_And_Set(ht, &buffkey, &buffval, HASHTABLE_SET_HOW_SET_NO_OVERWRITE);
LogTest("The value must be HASHTABLE_ERROR_KEY_ALREADY_EXISTS = %d --> %d",
HASHTABLE_ERROR_KEY_ALREADY_EXISTS, rc);
if(rc != HASHTABLE_ERROR_KEY_ALREADY_EXISTS)
{
LogTest("Test ECHOUE : Clef redondante");
exit(1);
}
LogTest("-----------------------------------------");
HashTable_Log(COMPONENT_HASHTABLE,ht);
LogFullDebug(COMPONENT_HASHTABLE,"-----------------------------------------");
LogTest("Displaying table statistics");
HashTable_GetStats(ht, &statistiques);
LogTest(" Number of Entrees = %d", statistiques.dynamic.nb_entries);
LogTest(" Successful operations : Set = %d, Get = %d, Del = %d, Test = %d",
statistiques.dynamic.ok.nb_set, statistiques.dynamic.ok.nb_get,
statistiques.dynamic.ok.nb_del, statistiques.dynamic.ok.nb_test);
LogTest(" Failed operations : Set = %d, Get = %d, Del = %d, Test = %d",
statistiques.dynamic.err.nb_set, statistiques.dynamic.err.nb_get,
statistiques.dynamic.err.nb_del, statistiques.dynamic.err.nb_test);
LogTest(" Operations 'NotFound': Set = %d, Get = %d, Del = %d, Test = %d",
statistiques.dynamic.notfound.nb_set, statistiques.dynamic.notfound.nb_get,
statistiques.dynamic.notfound.nb_del, statistiques.dynamic.notfound.nb_test);
LogTest(" Statistics computed: min_rbt_node = %d, max_rbt_node = %d, average_rbt_node = %d",
statistiques.computed.min_rbt_num_node, statistiques.computed.max_rbt_num_node,
statistiques.computed.average_rbt_num_node);
/* Test sur la pertinence des valeurs de statistiques */
if(statistiques.dynamic.ok.nb_set != MAXTEST)
{
LogTest("Test FAILED: Incorrect statistics: ok.nb_set ");
exit(1);
}
if(statistiques.dynamic.ok.nb_get + statistiques.dynamic.notfound.nb_get !=
2 * MAXGET + 1)
{
LogTest("Test FAILED: Incorrect statistics: *.nb_get. Expected %d, got %d",
2 * MAXGET + 1,
statistiques.dynamic.ok.nb_get + statistiques.dynamic.notfound.nb_get);
exit(1);
}
if(statistiques.dynamic.ok.nb_del != MAXDESTROY)
{
LogTest("Test FAILED: Incorrect statistics: *.nb_del. Expected %d, got %d",
MAXDESTROY, statistiques.dynamic.ok.nb_del);
exit(1);
}
if(statistiques.dynamic.notfound.nb_del != 0)
{
LogTest("Test FAILED: Incorrect statistics: *.nb_del. Expected %d, got %d",
0, statistiques.dynamic.notfound.nb_del);
exit(1);
}
if(statistiques.dynamic.err.nb_test != 1)
{
LogTest("Test FAILED: Incorrect statistics: err.nb_test ");
exit(1);
}
/* Tous les tests sont ok */
BuddyDumpMem(stdout);
LogTest("\n-----------------------------------------");
LogTest("Test succeeded: all tests pass successfully");
exit(0);
}
int main(int argc, char **argv)
{
unsigned int i;
struct timeval tv1, tv2, tv3, tvdiff;
int count, rc;
char *dir;
time_t now;
if (argc != 3) {
LogTest("usage: test_handle_mapping_db <db_dir> <db_count>");
exit(1);
}
count = atoi(argv[2])
if (count == 0) {
LogTest("usage: test_handle_mapping_db <db_dir> <db_count>");
exit(1);
}
dir = argv[1];
/* Init logging */
SetNamePgm("test_handle_mapping");
SetNameFileLog("/dev/tty");
SetNameFunction("main");
SetNameHost("localhost");
/* count databases */
rc = handlemap_db_count(dir);
LogTest("handlemap_db_count(%s)=%d", dir, rc);
if (rc != 0 && count != rc) {
LogTest(
"Warning: incompatible thread count %d <> database count %d",
count, rc);
}
rc = handlemap_db_init(dir, "/tmp", count, 1024, false);
LogTest("handlemap_db_init() = %d", rc);
if (rc)
exit(rc);
rc = handlemap_db_reaload_all(NULL);
LogTest("handlemap_db_reaload_all() = %d", rc);
if (rc)
exit(rc);
gettimeofday(&tv1, NULL);
/* Now insert a set of handles */
now = time(NULL);
for (i = 0; i < 10000; i++) {
nfs23_map_handle_t nfs23_digest;
fsal_handle_t handle;
memset(&handle, i, sizeof(fsal_handle_t));
nfs23_digest.object_id = 12345 + i;
nfs23_digest.handle_hash = (1999 * i + now) % 479001599;
rc = handlemap_db_insert(&nfs23_digest, &handle);
if (rc)
exit(rc);
}
gettimeofday(&tv2, NULL);
timersub(&tv2, &tv1, &tvdiff);
LogTest("%u threads inserted 10000 handles in %d.%06ds", count,
(int)tvdiff.tv_sec, (int)tvdiff.tv_usec);
rc = handlemap_db_flush();
gettimeofday(&tv3, NULL);
timersub(&tv3, &tv1, &tvdiff);
LogTest("Total time with %u threads (including flush): %d.%06ds", count,
(int)tvdiff.tv_sec, (int)tvdiff.tv_usec);
LogTest("Now, delete operations");
for (i = 0; i < 10000; i++) {
nfs23_map_handle_t nfs23_digest;
nfs23_digest.object_id = 12345 + i;
nfs23_digest.handle_hash = (1999 * i + now) % 479001599;
rc = handlemap_db_delete(&nfs23_digest);
if (rc)
exit(rc);
}
gettimeofday(&tv2, NULL);
timersub(&tv2, &tv3, &tvdiff);
LogTest("%u threads deleted 10000 handles in %d.%06ds", count,
(int)tvdiff.tv_sec, (int)tvdiff.tv_usec);
rc = handlemap_db_flush();
gettimeofday(&tv1, NULL);
timersub(&tv1, &tv3, &tvdiff);
LogTest("Delete time with %u threads (including flush): %d.%06ds",
count, (int)tvdiff.tv_sec, (int)tvdiff.tv_usec);
exit(0);
}
int main(int argc, char *argv[])
{
SetDefaultLogging("TEST");
SetNamePgm("test_lru");
LRU_list_t *plru;
LRU_parameter_t param;
LRU_entry_t *entry = NULL;
LRU_entry_t *kept_entry = NULL;
LRU_status_t status = 0;
int i = 0;
char strtab[MAXTEST][10];
param.nb_entry_prealloc = PREALLOC;
param.entry_to_str = print_entry;
param.clean_entry = clean_entry;
param.lp_name = "Test";
BuddyInit(NULL);
if((plru = LRU_Init(param, &status)) == NULL)
{
LogTest("Test FAILED: Bad Init");
exit(1);
}
for(i = 0; i < MAXTEST; i++)
{
LogTest("Added entry %d", i);
sprintf(strtab[i], "%d", i);
if((entry = LRU_new_entry(plru, &status)) == NULL)
{
LogTest("Test FAILED: bad entry add, status = %d", status);
exit(1);
}
entry->buffdata.pdata = strtab[i];
entry->buffdata.len = strlen(strtab[i]);
if(i == KEPT_ENTRY)
kept_entry = entry;
}
/* printing the table */
LRU_Print(plru);
LRU_invalidate(plru, kept_entry);
if(isFullDebug(COMPONENT_LRU))
LRU_Print(plru);
if(LRU_gc_invalid(plru, NULL) != LRU_LIST_SUCCESS)
{
LogTest("Test FAILED: bad gc");
exit(1);
}
LRU_Print(plru);
/* Tous les tests sont ok */
LogTest("\n-----------------------------------------");
LogTest("Test succeeded: all tests pass successfully");
exit(0);
} /* main */
int main(int argc, char *argv[])
{
hash_table_t *ht_ip_stats;
struct prealloc_pool *ip_stats_pool;
exportlist_t pexport;
int root, read, write, mdonly_read, mdonly_write,
root_user, uid, operation, export_check_result,
predicted_result, nonroot, accesstype,
return_status=0;
char *ip = "192.0.2.10";
// char *match_str = "192.0.2.10";
char *match_str = "*";
char *hostname = "hostname";
SetDefaultLogging("TEST");
SetNamePgm("test_mnt_proto");
init_vars(&ht_ip_stats, &ip_stats_pool);
printf("TESTING THE NEW ACCESS LIST FORMAT\n------------------------------------\n");
printf("TEST: root read write mdonly_read mdonly_write : uid operation\n");
/* loop through all combinations of new access list uses. */
for(root=0; root < 2; root++)
for(read=0; read < 2; read++)
for(write=0; write < 2; write++)
for(mdonly_read=0; mdonly_read < 2; mdonly_read++)
for(mdonly_write=0; mdonly_write < 2; mdonly_write++)
{
memset(&pexport, 0, sizeof(pexport));
/* These strings come from local defines in ../support/exports.c */
if (root)
parseAccessParam("Root_Access", match_str, &pexport, EXPORT_OPTION_ROOT);
if (read)
parseAccessParam("R_Access", match_str, &pexport, EXPORT_OPTION_READ_ACCESS);
if (write)
parseAccessParam("RW_Access", match_str, &pexport,
EXPORT_OPTION_READ_ACCESS | EXPORT_OPTION_WRITE_ACCESS);
if (mdonly_read)
parseAccessParam("MDONLY_RO_Access", match_str, &pexport, EXPORT_OPTION_MD_READ_ACCESS);
if (mdonly_write)
parseAccessParam("MDONLY_Access", match_str, &pexport,
EXPORT_OPTION_MD_WRITE_ACCESS | EXPORT_OPTION_MD_READ_ACCESS);
/* This is critical */
pexport.new_access_list_version = 1;
/* With this export entry test both root and user access. */
for(root_user=0; root_user < 2; root_user++)
for(operation=0; operation < 5; operation++)
{
if (root_user == 0)
uid = USER_UID;
else
uid = ROOT_UID;
printf("TEST: %d %d %d %d %d : %d ",
root, read, write, mdonly_read, mdonly_write,uid);
if (operation == TEST_MOUNT)
printf("TEST_MOUNT\n");
else if (operation == TEST_READ)
printf("READ\n");
else if (operation == TEST_WRITE)
printf("WRITE\n");
else if (operation == MDONLY_READ)
printf("MDONLY_READ\n");
else if (operation == MDONLY_WRITE)
printf("MDONLY_WRITE\n");
export_check_result = test_access(ip, hostname, ht_ip_stats, ip_stats_pool,
&pexport, uid, operation);
/* predict how the result will turn out */
predicted_result = predict(ip, hostname, root, read, write,
mdonly_read, mdonly_write, uid, operation);
/* report on what was expected vs what we received */
if (expected(predicted_result, export_check_result) == 1)
return_status = 1;
}
}
/* loop through all combinations of old access list uses. */
printf("\n\nTESTING THE OLDER ACCESS LIST FORMAT\n------------------------------------\n");
printf("TEST: root nonroot accesstype : uid operation\n");
/* loop through all combinations of new access list uses. */
for(root=0; root < 2; root++)
for(nonroot=0; nonroot < 2; nonroot++)
for(accesstype=1; accesstype < 4; accesstype++)
{
memset(&pexport, 0, sizeof(pexport));
/* These strings come from local defines in ../support/exports.c */
if (root)
parseAccessParam("Root_Access", match_str, &pexport, EXPORT_OPTION_ROOT);
if (nonroot)
parseAccessParam("Access", match_str, &pexport, EXPORT_OPTION_READ_ACCESS|EXPORT_OPTION_WRITE_ACCESS);
if (accesstype == TEST_READ)
pexport.access_type = ACCESSTYPE_RO;
else if (accesstype == TEST_WRITE)
pexport.access_type = ACCESSTYPE_RW;
else if (accesstype == MDONLY_READ)
pexport.access_type = ACCESSTYPE_MDONLY_RO;
else if (accesstype == MDONLY_WRITE)
pexport.access_type = ACCESSTYPE_MDONLY;
else
printf("FAIL: INVALID access_type \n");
/* This is critical */
pexport.new_access_list_version = 0;
/* With this export entry test both root and user access. */
for(root_user=0; root_user < 2; root_user++)
for(operation=0; operation < 5; operation++)
{
if (root_user == 0)
uid = USER_UID;
else
uid = ROOT_UID;
printf("TEST: %d %d ", root, nonroot);
if (accesstype == TEST_READ)
printf("ACCESSTYPE_RO ");
else if (accesstype == TEST_WRITE)
printf("ACCESSTYPE_RW ");
else if (accesstype == MDONLY_READ)
printf("ACCESSTYPE_MDONLY_RO ");
else if (accesstype == MDONLY_WRITE)
printf("ACCESSTYPE_MDONLY ");
else
printf("INVALID ");
printf(": %d ",uid);
if (operation == TEST_MOUNT)
printf("TEST_MOUNT\n");
else if (operation == TEST_READ)
printf("READ\n");
else if (operation == TEST_WRITE)
printf("WRITE\n");
else if (operation == MDONLY_READ)
printf("MDONLY_READ\n");
else if (operation == MDONLY_WRITE)
printf("MDONLY_WRITE\n");
export_check_result = test_access(ip, hostname, ht_ip_stats, ip_stats_pool,
&pexport, uid, operation);
/* predict how the result will turn out */
if ((operation == TEST_WRITE || operation == MDONLY_WRITE) && accesstype == TEST_READ)
predicted_result = EXPORT_WRITE_ATTEMPT_WHEN_RO;
else
predicted_result = old_predict(ip, hostname, root, nonroot,
accesstype, uid, operation);
/* report on what was expected vs what we received */
if (expected(predicted_result, export_check_result) == 1)
return_status = 1;
}
}
printf("----------------------------------------------------\n");
if (!return_status)
printf("ALL ACCESS LIST TYPE TESTS COMPLETED SUCCESSFULLY!!\n");
else
printf("ACCESS LIST TYPE TESTS FAILED!!\n");
printf("----------------------------------------------------\n");
return return_status;
}
main(int argc, char *argv[])
{
char localmachine[256];
cache_inode_client_t client;
LRU_parameter_t lru_param;
LRU_status_t lru_status;
cache_inode_fsal_data_t fsdata;
fsal_status_t status;
fsal_parameter_t init_param;
fsal_name_t name;
fsal_path_t path;
fsal_attrib_mask_t mask;
fsal_path_t pathroot;
fsal_attrib_list_t attribs;
fsal_handle_t root_handle;
cache_inode_endofdir_t eod_met;
cache_inode_dir_entry_t dirent_array[100];
cache_inode_dir_entry_t dirent_array_loop[5];
unsigned int nbfound;
unsigned int begin_cookie = 0;
hash_buffer_t key, value;
uid_t uid;
fsal_cred_t cred;
cache_inode_status_t cache_status;
cache_inode_parameter_t cache_param;
cache_inode_client_parameter_t cache_client_param;
hash_table_t *ht = NULL;
fsal_attrib_list_t attrlookup;
cache_entry_t *cache_entry_root = NULL;
cache_entry_t *cache_entry_lookup = NULL;
cache_entry_t *cache_entry_lookup2 = NULL;
cache_entry_t *cache_entry_lookup3 = NULL;
cache_entry_t *cache_entry_lookup4 = NULL;
cache_entry_t *cache_entry_dircont = NULL;
cache_inode_gc_policy_t gcpol;
char *configfile = argv[1];
int i = 0;
int rc = 0;
/* Init the Buddy System allocation */
if((rc = BuddyInit(NULL)) != BUDDY_SUCCESS)
{
LogTest("Error initializing memory allocator");
exit(1);
}
/* init debug */
SetDefaultLogging("TEST");
SetNamePgm("test_cache_inode");
SetNameFunction("main");
InitLogging();
#if defined( _USE_GHOSTFS )
if(argc != 2)
{
LogTest("Please set the configuration file as parameter");
exit(1);
}
#endif
/* Obtention du nom de la machine */
if(gethostname(localmachine, sizeof(localmachine)) != 0)
{
LogError(COMPONENT_STDOUT,ERR_SYS, ERR_GETHOSTNAME, errno);
exit(1);
}
else
SetNameHost(localmachine);
AddFamilyError(ERR_FSAL, "FSAL related Errors", tab_errstatus_FSAL);
AddFamilyError(ERR_CACHE_INODE, "FSAL related Errors", tab_errstatus_cache_inode);
/* creating log */
LogTest( "Starting the test");
LogTest( "-----------------");
#if defined( _USE_GHOSTFS )
if(FSAL_IS_ERROR(status = FSAL_str2path(configfile,
strlen(configfile) + 1,
&(init_param.fs_specific_info.
definition_file))))
{
LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor);
}
#elif defined( _USE_HPSS )
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, Flags);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DebugValue);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, TransferType);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, NumRetries);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, BusyDelay);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, BusyRetries);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, TotalDelay);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, GKTotalDelay);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, LimitedRetries);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, MaxConnections);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, ReuseDataConnections);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, UsePortRange);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, RetryStageInp);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DMAPWriteUpdates);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, ServerName);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DescName);
init_param.fs_specific_info.behaviors.PrincipalName = FSAL_INIT_FORCE_VALUE;
strncpy(init_param.fs_specific_info.hpss_config.PrincipalName,
HPSS_SSM, HPSS_MAX_PRINCIPAL_NAME);
init_param.fs_specific_info.behaviors.KeytabPath = FSAL_INIT_FORCE_VALUE;
strncpy(init_param.fs_specific_info.hpss_config.KeytabPath,
HPSS_KEYTAB, HPSS_MAX_PATH_NAME);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DebugPath);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, HostName);
FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, RegistrySiteName);
#endif
/* 2-common info (default) */
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxfilesize);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxlink);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxnamelen);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxpathlen);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, no_trunc);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, chown_restricted);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, case_insensitive);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, case_preserving);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, fh_expire_type);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, link_support);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, symlink_support);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, named_attr);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, unique_handles);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, lease_time);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, acl_support);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, cansettime);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, homogenous);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxread);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxwrite);
/* Init */
if(FSAL_IS_ERROR(status = FSAL_Init(&init_param)))
{
LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor);
}
/* getting creds */
uid = getuid();
if(FSAL_IS_ERROR(status = FSAL_GetUserCred(uid, NULL, &cred)))
{
LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor);
}
/* Init of the cache inode module */
cache_param.hparam.index_size = 31;
cache_param.hparam.alphabet_length = 10; /* Buffer seen as a decimal polynom */
cache_param.hparam.nb_node_prealloc = 100;
cache_param.hparam.hash_func_key = cache_inode_fsal_hash_func;
cache_param.hparam.hash_func_rbt = cache_inode_fsal_rbt_func;
cache_param.hparam.hash_func_both = NULL ; /* BUGAZOMEU */
cache_param.hparam.compare_key = cache_inode_compare_key_fsal;
cache_param.hparam.key_to_str = display_key;
cache_param.hparam.val_to_str = display_value;
if((ht = cache_inode_init(cache_param, &cache_status)) == NULL)
{
LogTest( "Error %d while init hash ", cache_status);
}
else
LogTest( "Hash Table address = %p", ht);
/* We need a cache_client to acces the cache */
cache_client_param.attrmask =
FSAL_ATTRS_MANDATORY | FSAL_ATTR_MTIME | FSAL_ATTR_CTIME | FSAL_ATTR_ATIME;
cache_client_param.nb_prealloc_entry = 1000;
cache_client_param.nb_pre_dir_data = 200;
cache_client_param.nb_pre_parent = 1200;
cache_client_param.nb_pre_state_v4 = 100;
cache_client_param.lru_param.nb_entry_prealloc = 1000;
cache_client_param.lru_param.entry_to_str = lru_entry_to_str;
cache_client_param.lru_param.clean_entry = lru_clean_entry;
cache_client_param.grace_period_attr = 0;
cache_client_param.grace_period_link = 0;
cache_client_param.grace_period_dirent = 0;
cache_client_param.expire_type_attr = CACHE_INODE_EXPIRE_NEVER;
cache_client_param.expire_type_link = CACHE_INODE_EXPIRE_NEVER;
cache_client_param.expire_type_dirent = CACHE_INODE_EXPIRE_NEVER;
/* Init the cache_inode client */
if(cache_inode_client_init(&client, cache_client_param, 0, NULL) != 0)
exit(1);
/* Init the gc */
gcpol.file_expiration_delay = 3;
gcpol.directory_expiration_delay = 4;
gcpol.hwmark_nb_entries = 6;
gcpol.lwmark_nb_entries = 3;
gcpol.run_interval = 4;
cache_inode_set_gc_policy(gcpol);
/* Getting the root of the FS */
if((FSAL_IS_ERROR(status = FSAL_str2path("/", 2, &pathroot))))
{
LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor);
exit(1);
}
if((FSAL_IS_ERROR(status = FSAL_lookupPath(&pathroot, &cred, &root_handle, &attribs))))
{
LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor);
exit(1);
}
fsdata.cookie = 0;
fsdata.handle = root_handle;
/* Cache the root of the FS */
if((cache_entry_root =
cache_inode_make_root(&fsdata, 1, ht, &client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't init fs's root");
exit(1);
}
/* A lookup in the root fsal */
if((FSAL_IS_ERROR(status = FSAL_str2name("cea", 10, &name))))
{
LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor);
exit(1);
}
if((cache_entry_lookup = cache_inode_lookup(cache_entry_root,
&name,
&attrlookup,
ht, &client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
/* Lookup a second time (entry should now be cached) */
if((cache_entry_lookup2 = cache_inode_lookup(cache_entry_root,
&name,
&attrlookup,
ht,
&client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
if(cache_entry_lookup2 != cache_entry_lookup)
{
LogTest("Error: lookup results should be the same");
exit(1);
}
/* A lookup in the root fsal */
if((FSAL_IS_ERROR(status = FSAL_str2name("log", 10, &name))))
{
LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor);
exit(1);
}
if((cache_entry_lookup3 = cache_inode_lookup(cache_entry_root,
&name,
&attrlookup,
ht,
&client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
if((cache_entry_lookup4 = cache_inode_lookup(cache_entry_root,
&name,
&attrlookup,
ht,
&client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
if(cache_entry_lookup3 != cache_entry_lookup4)
{
LogTest("Error: lookup results should be the same");
exit(1);
}
/* A lookup in the root fsal */
if((FSAL_IS_ERROR(status = FSAL_str2name("SunOS_5", 10, &name))))
{
LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor);
exit(1);
}
cache_inode_print_dir(cache_entry_root);
/* Test readdir */
if(cache_inode_readdir(cache_entry_root,
0,
100,
&nbfound,
&eod_met,
dirent_array,
ht, &client, &cred, &cache_status) != CACHE_INODE_SUCCESS)
{
LogTest( "Error: cache_inode_readdir failed");
exit(1);
}
LogTest( "Readdir nbfound=%d, eod_met=%d", nbfound, eod_met);
for(i = 0; i < nbfound; i++)
LogTest( "dirent_array[%d] ==> %s | %p", i,
dirent_array[i].name.name, dirent_array[i].pentry);
cache_inode_print_dir(cache_entry_root);
/* looping on readir */
LogTest( "Loop directory in several pass");
eod_met = TO_BE_CONTINUED;
begin_cookie = 0;
do
{
if(cache_inode_readdir(cache_entry_root,
begin_cookie,
2,
&nbfound,
&eod_met,
dirent_array_loop,
ht, &client, &cred, &cache_status) != CACHE_INODE_SUCCESS)
{
LogTest("Error: cache_inode_readdir failed: %d", cache_status);
exit(1);
}
for(i = 0; i < nbfound; i++)
LogTest( " ==> %s | %p", dirent_array_loop[i].name.name,
dirent_array_loop[i].pentry);
begin_cookie += nbfound;
}
while(eod_met == TO_BE_CONTINUED);
LogTest( "---------------------------------");
/* A lookup in the root fsal */
if((FSAL_IS_ERROR(status = FSAL_str2name("cea", 10, &name))))
{
LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor);
exit(1);
}
if((cache_entry_lookup = cache_inode_lookup(cache_entry_root,
&name,
&attrlookup,
ht, &client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
/* A lookup in the root fsal */
if((FSAL_IS_ERROR(status = FSAL_str2name("log", 10, &name))))
{
LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor);
exit(1);
}
if((cache_entry_lookup = cache_inode_lookup(cache_entry_root,
&name,
&attrlookup,
ht, &client, &cred, &cache_status)) == NULL)
{
LogTest( "Error: can't lookup");
exit(1);
}
/* Print the Hash Table */
HashTable_Log(COMPONENT_STDOUT, ht);
#ifdef _ADDITIONAL_TEST
/* Trying to lookup from a DIR_CONTINUE */
fsdata.handle = cache_entry_root->object.dir_begin.handle;
fsdata.cookie = 3 * CHILDREN_ARRAY_SIZE;
LogTest("Input key: (Handle=%p, Cookie=%d)", fsdata.handle, fsdata.cookie);
/* Turn the input to a hash key */
if(cache_inode_fsaldata_2_key(&key, &fsdata, NULL))
{
LogTest( "Impossible to allocate a key to that value");
exit(1);
}
if(HashTable_Get(ht, &key, &value) != HASHTABLE_SUCCESS)
{
LogTest( "Key could not be found");
exit(1);
}
/* pentry for the dir cont */
cache_entry_dircont = (cache_entry_t *) value.pdata;
/* Test readdir */
if(cache_inode_readdir(cache_entry_dircont,
fsdata.cookie,
100,
&nbfound,
&eod_met,
dirent_array,
ht, &client, &cred, &cache_status) != CACHE_INODE_SUCCESS)
{
LogTest( "Error: cache_inode_readdir failed");
exit(1);
}
#endif
LogTest( "Readdir nbfound=%d, eod_met=%d", nbfound, eod_met);
for(i = 0; i < nbfound; i++)
LogTest( "dirent_array[%d] ==> %s | %p ", i,
dirent_array[i].name.name, dirent_array[i].pentry);
/* Call the GC */
LogTest( "Sleeping %d second before gc (for gc invalidation)",
gcpol.file_expiration_delay + 2);
sleep(gcpol.file_expiration_delay + 2);
if(cache_inode_gc(ht, &client, &cache_status) != CACHE_INODE_SUCCESS)
{
LogTest( "Error: cache_inode_gc failed");
exit(1);
}
LogTest( "GC performed successfully");
/* Print the Hash Table */
HashTable_Log(COMPONENT_STDOUT, ht);
/* Another readdir, after gc is made */
eod_met = TO_BE_CONTINUED;
begin_cookie = 0;
LogTest( "ANOTHER READDIR AFTER GC");
do
{
if(cache_inode_readdir(cache_entry_root,
begin_cookie,
2,
&nbfound,
&eod_met,
dirent_array_loop,
ht, &client, &cred, &cache_status) != CACHE_INODE_SUCCESS)
{
LogTest("Error: cache_inode_readdir failed: %d", cache_status);
exit(1);
}
for(i = 0; i < nbfound; i++)
LogTest( " ==> %s | %p", dirent_array_loop[i].name.name,
dirent_array_loop[i].pentry);
begin_cookie += nbfound;
}
while(eod_met == TO_BE_CONTINUED);
LogTest( "---------------------------------");
/* Print the Hash Table */
HashTable_Log(COMPONENT_STDOUT, ht);
LogTest( "---------------------------------");
/* The end of all the tests */
LogTest( "All tests exited successfully");
exit(0);
} /* main */
int main(int argc, char *argv[])
{
SetDefaultLogging("TEST");
SetNamePgm("test_rw");
pthread_attr_t attr_thr;
pthread_t ThrReaders[MAX_READERS];
pthread_t ThrWritters[MAX_WRITTERS];
int i;
int rc;
pthread_attr_init(&attr_thr);
pthread_attr_setscope(&attr_thr, PTHREAD_SCOPE_SYSTEM);
pthread_attr_setdetachstate(&attr_thr, PTHREAD_CREATE_JOINABLE);
LogTest("Init lock: %d", rw_lock_init(&lock));
LogTest("ESTIMATED TIME OF TEST: %d s",
(MAX_WRITTERS + MAX_READERS) * NB_ITER + MARGE_SECURITE);
fflush(stdout);
for(i = 0; i < MAX_WRITTERS; i++)
{
if((rc =
pthread_create(&ThrWritters[i], &attr_thr, thread_writter, (void *)NULL)) != 0)
{
LogTest("pthread_create: Error %d %d ", rc, errno);
LogTest("RW_Lock Test FAILED: Bad allocation thread");
exit(1);
}
}
for(i = 0; i < MAX_READERS; i++)
{
if((rc =
pthread_create(&ThrReaders[i], &attr_thr, thread_reader, (void *)NULL)) != 0)
{
LogTest("pthread_create: Error %d %d ", rc, errno);
LogTest("RW_Lock Test FAILED: Bad allocation thread");
exit(1);
}
}
LogTest("Main thread sleeping while threads run locking tests");
sleep((MAX_WRITTERS + MAX_READERS) * NB_ITER + MARGE_SECURITE);
LogTest("End of sleep( %d ) ",
(MAX_WRITTERS + MAX_READERS) * NB_ITER + MARGE_SECURITE);
if(OkWrite == 1 & OkRead == 1)
{
LogTest("Test RW_Lock succeeded: no deadlock detected");
exit(0);
return 0; /* for compiler */
}
else
{
if(OkWrite == 0)
LogTest("RW_Lock test FAIL: deadlock in the editors");
if(OkRead == 0)
LogTest("RW_Lock Test FAILED: deadlock in the drive");
exit(1);
return 1; /* for compiler */
}
} /* main */
