void init_vars(hash_table_t **ht_ip_stats, struct prealloc_pool **ip_stats_pool)
{
int rc;
/* Get the FSAL functions */
FSAL_LoadFunctions();
/* Get the FSAL consts */
FSAL_LoadConsts();
/* Initialize buddy malloc */
if((rc = BuddyInit(NULL)) != BUDDY_SUCCESS)
{
/* Failed init */
LogTest("Memory manager could not be initialized");
exit(1);
}
nfs_set_param_default(&nfs_param);
/*ht_ip_stats*/
return;
*ht_ip_stats = nfs_Init_ip_stats(nfs_param.ip_stats_param);
/* if((*ht_ip_stats = HashTable_Init(nfs_param.ip_stats_param.hash_param)) == NULL)
{
LogCrit(COMPONENT_INIT, "NFS IP_STATS: Cannot init IP stats cache");
return NULL;
}*/
if(*ht_ip_stats == NULL)
{
LogCrit(COMPONENT_INIT, "NFS_INIT: Error while initializing IP/stats cache");
exit(1);
}
/*ip_stats_pool*/
MakePool(*ip_stats_pool,
100,// nfs_param.worker_param.nb_ip_stats_prealloc,
nfs_ip_stats_t, NULL, NULL);
NamePool(*ip_stats_pool, "IP Stats Cache Pool");
if(!IsPoolPreallocated(*ip_stats_pool))
{
LogCrit(COMPONENT_INIT, "NFS_INIT: Error while allocating IP stats cache pool");
LogError(COMPONENT_INIT, ERR_SYS, ERR_MALLOC, errno);
exit(1);
}
}
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 */
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)
{
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;
}
/**
* FSAL_proxy_clientid_renewer_thread: this thread is made for refreshing the clientid used by the FSAL, automatically.
*
* This thread is made for refreshing the clientid used by the FSAL, automatically.
*
*
* \return never returns... This is a infinite loop that will die when the daemon stops
*/
void *FSAL_proxy_clientid_renewer_thread(void *Arg)
{
int rc;
COMPOUND4args argnfs4;
COMPOUND4res resnfs4;
struct timeval timeout = TIMEOUTRPC;
fsal_status_t fsal_status;
proxyfsal_op_context_t fsal_context;
proxyfsal_op_context_t *p_context = &fsal_context;
#define FSAL_RENEW_LEASE_NB_OP_ALLOC 1
nfs_argop4 argoparray[FSAL_RENEW_LEASE_NB_OP_ALLOC];
nfs_resop4 resoparray[FSAL_RENEW_LEASE_NB_OP_ALLOC];
#ifndef _NO_BUDDY_SYSTEM
buddy_parameter_t buddy_param = default_buddy_parameter;
#endif
LogEvent(COMPONENT_FSAL, "FSAL_proxy_clientid_refresher_thread: starting...");
sleep(6); /** @todo: use getattr to have an actual value of server's lease duration */
#ifndef _NO_BUDDY_SYSTEM
if((rc = BuddyInit(&buddy_param)) != BUDDY_SUCCESS)
{
/* Failed init */
LogCrit(COMPONENT_FSAL,
"FSAL_proxy_clientid_renewer_thread: Memory manager could not be initialized, exiting...");
exit(1);
}
#endif
memset((char *)&fsal_context, 0, sizeof(proxyfsal_op_context_t));
fsal_status = PROXYFSAL_InitClientContext((fsal_op_context_t *)p_context);
if(FSAL_IS_ERROR(fsal_status))
{
LogCrit(COMPONENT_FSAL,
"FSAL_proxy_clientid_refresher_thread: FSAL error(%u,%u) during init... exiting",
fsal_status.major, fsal_status.minor);
exit(1);
}
/* Setup results structures */
argnfs4.argarray.argarray_val = argoparray;
resnfs4.resarray.resarray_val = resoparray;
argnfs4.minorversion = 0;
argnfs4.tag.utf8string_val = NULL;
argnfs4.tag.utf8string_len = 0;
argnfs4.argarray.argarray_len = 0;
argnfs4.argarray.argarray_val[0].argop = NFS4_OP_RENEW;
argnfs4.argarray.argarray_val[0].nfs_argop4_u.oprenew.clientid = fsal_clientid;
argnfs4.argarray.argarray_len = 1;
while(1)
{
sleep(60); /** @todo: use getattr to have an actual value of server's lease duration */
/* Call the NFSv4 function */
TakeTokenFSCall();
COMPOUNDV4_EXECUTE(p_context, argnfs4, resnfs4, rc);
if(rc != RPC_SUCCESS)
{
ReleaseTokenFSCall();
LogCrit(COMPONENT_FSAL, "FSAL_PROXY: /!\\ RPC error when connecting to the server");
}
ReleaseTokenFSCall();
if(resnfs4.status != NFS4_OK)
LogCrit(COMPONENT_FSAL,
"FSAL_PROXY: /!\\ NFSv4 error %u occured when trying to new clienitf %llu",
resnfs4.status, (long long unsigned int)fsal_clientid);
} /* while( 1 ) */
} /* FSAL_proxy_clientid_renewer_thread */
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[])
{
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 */
void *stats_thread(void *addr)
{
FILE *stats_file = NULL;
struct stat statref;
struct stat stattest;
time_t current_time;
struct tm current_time_struct;
struct tm boot_time_struct;
char strdate[1024];
char strbootdate[1024];
unsigned int i = 0;
unsigned int j = 0;
int reopen_stats = FALSE;
nfs_worker_data_t *workers_data = addr;
cache_inode_stat_t global_cache_inode_stat;
nfs_worker_stat_t global_worker_stat;
hash_stat_t hstat;
hash_stat_t hstat_reverse;
unsigned long long total_fsal_calls;
fsal_statistics_t global_fsal_stat;
unsigned int min_pending_request;
unsigned int max_pending_request;
unsigned int total_pending_request;
unsigned int average_pending_request;
unsigned int len_pending_request = 0;
unsigned int avg_latency;
#ifndef _NO_BUDDY_SYSTEM
int rc = 0;
buddy_stats_t global_buddy_stat;
#endif
SetNameFunction("stat_thr");
#ifndef _NO_BUDDY_SYSTEM
if((rc = BuddyInit(NULL)) != BUDDY_SUCCESS)
{
/* Failed init */
LogFatal(COMPONENT_MAIN,
"NFS STATS : Memory manager could not be initialized");
}
LogInfo(COMPONENT_MAIN,
"NFS STATS : Memory manager successfully initialized");
#endif
/* Open the stats file, in append mode */
if((stats_file = fopen(nfs_param.core_param.stats_file_path, "a")) == NULL)
{
LogCrit(COMPONENT_MAIN,
"NFS STATS : Could not open stats file %s, no stats will be made...",
nfs_param.core_param.stats_file_path);
return NULL;
}
if(stat(nfs_param.core_param.stats_file_path, &statref) != 0)
{
LogCrit(COMPONENT_MAIN,
"NFS STATS : Could not get inode for %s, no stats will be made...",
nfs_param.core_param.stats_file_path);
fclose(stats_file);
return NULL;
}
#ifdef _SNMP_ADM_ACTIVE
/* start snmp library */
if(stats_snmp(workers_data) == 0)
LogInfo(COMPONENT_MAIN,
"NFS STATS: SNMP stats service was started successfully");
else
LogCrit(COMPONENT_MAIN,
"NFS STATS: ERROR starting SNMP stats export thread");
#endif /*_SNMP_ADM_ACTIVE*/
while(1)
{
/* Initial wait */
sleep(nfs_param.core_param.stats_update_delay);
/* Debug trace */
LogInfo(COMPONENT_MAIN, "NFS STATS : now dumping stats");
/* Stats main loop */
if(stat(nfs_param.core_param.stats_file_path, &stattest) == 0)
{
if(stattest.st_ino != statref.st_ino)
reopen_stats = TRUE;
}
else
{
if(errno == ENOENT)
reopen_stats = TRUE;
}
/* Check is file has changed (the inode number will be different) */
if(reopen_stats == TRUE)
{
/* Stats file has changed */
LogEvent(COMPONENT_MAIN,
"NFS STATS : stats file has changed or was removed, I close and reopen it");
fflush(stats_file);
fclose(stats_file);
if((stats_file = fopen(nfs_param.core_param.stats_file_path, "a")) == NULL)
{
LogCrit(COMPONENT_MAIN,
"NFS STATS : Could not open stats file %s, no further stats will be made...",
nfs_param.core_param.stats_file_path);
return NULL;
}
statref = stattest;
reopen_stats = FALSE;
}
/* Get the current epoch time */
current_time = time(NULL);
memcpy(¤t_time_struct, localtime(¤t_time), sizeof(current_time_struct));
snprintf(strdate, 1024, "%u, %.2d/%.2d/%.4d %.2d:%.2d:%.2d ",
(unsigned int)current_time,
current_time_struct.tm_mday,
current_time_struct.tm_mon + 1,
1900 + current_time_struct.tm_year,
current_time_struct.tm_hour,
current_time_struct.tm_min, current_time_struct.tm_sec);
/* Printing the general Stats */
memcpy(&boot_time_struct, localtime(&ServerBootTime), sizeof(boot_time_struct));
snprintf(strbootdate, 1024, "%u, %.2d/%.2d/%.4d %.2d:%.2d:%.2d ",
(unsigned int)ServerBootTime,
boot_time_struct.tm_mday,
boot_time_struct.tm_mon + 1,
1900 + boot_time_struct.tm_year,
boot_time_struct.tm_hour,
boot_time_struct.tm_min, boot_time_struct.tm_sec);
fprintf(stats_file, "NFS_SERVER_GENERAL,%s;%s\n", strdate, strbootdate);
/* Zeroing the cache_stats */
global_cache_inode_stat.nb_gc_lru_active = 0;
global_cache_inode_stat.nb_gc_lru_total = 0;
global_cache_inode_stat.nb_call_total = 0;
memset(global_cache_inode_stat.func_stats.nb_err_unrecover, 0,
sizeof(unsigned int) * CACHE_INODE_NB_COMMAND);
/* Merging the cache inode stats for every thread */
for(i = 0; i < nfs_param.core_param.nb_worker; i++)
{
global_cache_inode_stat.nb_gc_lru_active +=
workers_data[i].cache_inode_client.stat.nb_gc_lru_active;
global_cache_inode_stat.nb_gc_lru_total +=
workers_data[i].cache_inode_client.stat.nb_gc_lru_total;
global_cache_inode_stat.nb_call_total +=
workers_data[i].cache_inode_client.stat.nb_call_total;
for(j = 0; j < CACHE_INODE_NB_COMMAND; j++)
{
if(i == 0)
{
global_cache_inode_stat.func_stats.nb_success[j] =
workers_data[i].cache_inode_client.stat.func_stats.nb_success[j];
global_cache_inode_stat.func_stats.nb_call[j] =
workers_data[i].cache_inode_client.stat.func_stats.nb_call[j];
global_cache_inode_stat.func_stats.nb_err_retryable[j] =
workers_data[i].cache_inode_client.stat.func_stats.
nb_err_retryable[j];
global_cache_inode_stat.func_stats.nb_err_unrecover[j] =
workers_data[i].cache_inode_client.stat.func_stats.
nb_err_unrecover[j];
}
else
{
global_cache_inode_stat.func_stats.nb_success[j] +=
workers_data[i].cache_inode_client.stat.func_stats.nb_success[j];
global_cache_inode_stat.func_stats.nb_call[j] +=
workers_data[i].cache_inode_client.stat.func_stats.nb_call[j];
global_cache_inode_stat.func_stats.nb_err_retryable[j] +=
workers_data[i].cache_inode_client.stat.func_stats.
nb_err_retryable[j];
global_cache_inode_stat.func_stats.nb_err_unrecover[j] +=
workers_data[i].cache_inode_client.stat.func_stats.
nb_err_unrecover[j];
}
}
}
/* Printing the cache_inode stat */
fprintf(stats_file, "CACHE_INODE_CALLS,%s;%u,%u,%u",
strdate,
global_cache_inode_stat.nb_call_total,
global_cache_inode_stat.nb_gc_lru_total,
global_cache_inode_stat.nb_gc_lru_active);
for(j = 0; j < CACHE_INODE_NB_COMMAND; j++)
fprintf(stats_file, "|%u,%u,%u,%u",
global_cache_inode_stat.func_stats.nb_call[j],
global_cache_inode_stat.func_stats.nb_success[j],
global_cache_inode_stat.func_stats.nb_err_retryable[j],
global_cache_inode_stat.func_stats.nb_err_unrecover[j]);
fprintf(stats_file, "\n");
/* Pinting the cache inode hash stat */
/* This is done only on worker[0]: the hashtable is shared and worker 0 always exists */
HashTable_GetStats(workers_data[0].ht, &hstat);
fprintf(stats_file,
"CACHE_INODE_HASH,%s;%u,%u,%u,%u|%u,%u,%u|%u,%u,%u|%u,%u,%u|%u,%u,%u\n",
strdate, hstat.dynamic.nb_entries, hstat.computed.min_rbt_num_node,
hstat.computed.max_rbt_num_node, hstat.computed.average_rbt_num_node,
hstat.dynamic.ok.nb_set, hstat.dynamic.notfound.nb_set,
hstat.dynamic.err.nb_set, hstat.dynamic.ok.nb_test,
hstat.dynamic.notfound.nb_test, hstat.dynamic.err.nb_test,
hstat.dynamic.ok.nb_get, hstat.dynamic.notfound.nb_get,
hstat.dynamic.err.nb_get, hstat.dynamic.ok.nb_del,
hstat.dynamic.notfound.nb_del, hstat.dynamic.err.nb_del);
/* Merging the NFS protocols stats together */
global_worker_stat.nb_total_req = 0;
global_worker_stat.nb_udp_req = 0;
global_worker_stat.nb_tcp_req = 0;
global_worker_stat.stat_req.nb_mnt1_req = 0;
global_worker_stat.stat_req.nb_mnt3_req = 0;
global_worker_stat.stat_req.nb_nfs2_req = 0;
global_worker_stat.stat_req.nb_nfs3_req = 0;
global_worker_stat.stat_req.nb_nfs4_req = 0;
global_worker_stat.stat_req.nb_nlm4_req = 0;
global_worker_stat.stat_req.nb_nfs40_op = 0;
global_worker_stat.stat_req.nb_nfs41_op = 0;
global_worker_stat.stat_req.nb_rquota1_req = 0;
global_worker_stat.stat_req.nb_rquota2_req = 0;
/* prepare for computing pending request stats */
min_pending_request = 10000000;
max_pending_request = 0;
total_pending_request = 0;
average_pending_request = 0;
len_pending_request = 0;
for(i = 0; i < nfs_param.core_param.nb_worker; i++)
{
global_worker_stat.nb_total_req += workers_data[i].stats.nb_total_req;
global_worker_stat.nb_udp_req += workers_data[i].stats.nb_udp_req;
global_worker_stat.nb_tcp_req += workers_data[i].stats.nb_tcp_req;
global_worker_stat.stat_req.nb_mnt1_req +=
workers_data[i].stats.stat_req.nb_mnt1_req;
global_worker_stat.stat_req.nb_mnt3_req +=
workers_data[i].stats.stat_req.nb_mnt3_req;
global_worker_stat.stat_req.nb_nfs2_req +=
workers_data[i].stats.stat_req.nb_nfs2_req;
global_worker_stat.stat_req.nb_nfs3_req +=
workers_data[i].stats.stat_req.nb_nfs3_req;
global_worker_stat.stat_req.nb_nfs4_req +=
workers_data[i].stats.stat_req.nb_nfs4_req;
global_worker_stat.stat_req.nb_nfs40_op +=
workers_data[i].stats.stat_req.nb_nfs40_op;
global_worker_stat.stat_req.nb_nfs41_op +=
workers_data[i].stats.stat_req.nb_nfs41_op;
global_worker_stat.stat_req.nb_nlm4_req +=
workers_data[i].stats.stat_req.nb_nlm4_req;
global_worker_stat.stat_req.nb_rquota1_req +=
workers_data[i].stats.stat_req.nb_nlm4_req;
global_worker_stat.stat_req.nb_rquota2_req +=
workers_data[i].stats.stat_req.nb_nlm4_req;
for(j = 0; j < MNT_V1_NB_COMMAND; j++)
{
if(i == 0)
{
global_worker_stat.stat_req.stat_req_mnt1[j].total =
workers_data[i].stats.stat_req.stat_req_mnt1[j].total;
global_worker_stat.stat_req.stat_req_mnt1[j].success =
workers_data[i].stats.stat_req.stat_req_mnt1[j].success;
global_worker_stat.stat_req.stat_req_mnt1[j].dropped =
workers_data[i].stats.stat_req.stat_req_mnt1[j].dropped;
}
else
{
global_worker_stat.stat_req.stat_req_mnt1[j].total +=
workers_data[i].stats.stat_req.stat_req_mnt1[j].total;
global_worker_stat.stat_req.stat_req_mnt1[j].success +=
workers_data[i].stats.stat_req.stat_req_mnt1[j].success;
global_worker_stat.stat_req.stat_req_mnt1[j].dropped +=
workers_data[i].stats.stat_req.stat_req_mnt1[j].dropped;
}
}
for(j = 0; j < MNT_V3_NB_COMMAND; j++)
{
if(i == 0)
{
global_worker_stat.stat_req.stat_req_mnt3[j].total =
workers_data[i].stats.stat_req.stat_req_mnt3[j].total;
global_worker_stat.stat_req.stat_req_mnt3[j].success =
workers_data[i].stats.stat_req.stat_req_mnt3[j].success;
global_worker_stat.stat_req.stat_req_mnt3[j].dropped =
workers_data[i].stats.stat_req.stat_req_mnt3[j].dropped;
}
else
{
global_worker_stat.stat_req.stat_req_mnt3[j].total +=
workers_data[i].stats.stat_req.stat_req_mnt3[j].total;
global_worker_stat.stat_req.stat_req_mnt3[j].success +=
workers_data[i].stats.stat_req.stat_req_mnt3[j].success;
global_worker_stat.stat_req.stat_req_mnt3[j].dropped +=
workers_data[i].stats.stat_req.stat_req_mnt3[j].dropped;
}
}
for(j = 0; j < NFS_V2_NB_COMMAND; j++)
{
if(i == 0)
{
global_worker_stat.stat_req.stat_req_nfs2[j].total =
workers_data[i].stats.stat_req.stat_req_nfs2[j].total;
global_worker_stat.stat_req.stat_req_nfs2[j].success =
workers_data[i].stats.stat_req.stat_req_nfs2[j].success;
global_worker_stat.stat_req.stat_req_nfs2[j].dropped =
workers_data[i].stats.stat_req.stat_req_nfs2[j].dropped;
}
else
{
global_worker_stat.stat_req.stat_req_nfs2[j].total +=
workers_data[i].stats.stat_req.stat_req_nfs2[j].total;
global_worker_stat.stat_req.stat_req_nfs2[j].success +=
workers_data[i].stats.stat_req.stat_req_nfs2[j].success;
global_worker_stat.stat_req.stat_req_nfs2[j].dropped +=
workers_data[i].stats.stat_req.stat_req_nfs2[j].dropped;
}
}
for(j = 0; j < NFS_V3_NB_COMMAND; j++)
{
if(i == 0)
{
global_worker_stat.stat_req.stat_req_nfs3[j].total =
workers_data[i].stats.stat_req.stat_req_nfs3[j].total;
global_worker_stat.stat_req.stat_req_nfs3[j].success =
workers_data[i].stats.stat_req.stat_req_nfs3[j].success;
global_worker_stat.stat_req.stat_req_nfs3[j].dropped =
workers_data[i].stats.stat_req.stat_req_nfs3[j].dropped;
global_worker_stat.stat_req.stat_req_nfs3[j].tot_latency =
workers_data[i].stats.stat_req.stat_req_nfs3[j].tot_latency;
global_worker_stat.stat_req.stat_req_nfs3[j].min_latency =
workers_data[i].stats.stat_req.stat_req_nfs3[j].min_latency;
global_worker_stat.stat_req.stat_req_nfs3[j].max_latency =
workers_data[i].stats.stat_req.stat_req_nfs3[j].max_latency;
}
else
{
global_worker_stat.stat_req.stat_req_nfs3[j].total +=
workers_data[i].stats.stat_req.stat_req_nfs3[j].total;
global_worker_stat.stat_req.stat_req_nfs3[j].success +=
workers_data[i].stats.stat_req.stat_req_nfs3[j].success;
global_worker_stat.stat_req.stat_req_nfs3[j].dropped +=
workers_data[i].stats.stat_req.stat_req_nfs3[j].dropped;
global_worker_stat.stat_req.stat_req_nfs3[j].tot_latency +=
workers_data[i].stats.stat_req.stat_req_nfs3[j].tot_latency;
set_min_latency(&(global_worker_stat.stat_req.stat_req_nfs3[j]),
workers_data[i].stats.stat_req.stat_req_nfs3[j].min_latency);
set_max_latency(&(global_worker_stat.stat_req.stat_req_nfs3[j]),
workers_data[i].stats.stat_req.stat_req_nfs3[j].max_latency);
}
}
for(j = 0; j < NFS_V4_NB_COMMAND; j++)
{
if(i == 0)
{
global_worker_stat.stat_req.stat_req_nfs4[j].total =
workers_data[i].stats.stat_req.stat_req_nfs4[j].total;
global_worker_stat.stat_req.stat_req_nfs4[j].success =
workers_data[i].stats.stat_req.stat_req_nfs4[j].success;
global_worker_stat.stat_req.stat_req_nfs4[j].dropped =
workers_data[i].stats.stat_req.stat_req_nfs4[j].dropped;
}
else
{
global_worker_stat.stat_req.stat_req_nfs4[j].total +=
workers_data[i].stats.stat_req.stat_req_nfs4[j].total;
global_worker_stat.stat_req.stat_req_nfs4[j].success +=
workers_data[i].stats.stat_req.stat_req_nfs4[j].success;
global_worker_stat.stat_req.stat_req_nfs4[j].dropped +=
workers_data[i].stats.stat_req.stat_req_nfs4[j].dropped;
}
}
for(j = 0; j < NFS_V40_NB_OPERATION; j++)
{
if(i == 0)
{
global_worker_stat.stat_req.stat_op_nfs40[j].total =
workers_data[i].stats.stat_req.stat_op_nfs40[j].total;
global_worker_stat.stat_req.stat_op_nfs40[j].success =
workers_data[i].stats.stat_req.stat_op_nfs40[j].success;
global_worker_stat.stat_req.stat_op_nfs40[j].failed =
workers_data[i].stats.stat_req.stat_op_nfs40[j].failed;
}
else
{
global_worker_stat.stat_req.stat_op_nfs40[j].total +=
workers_data[i].stats.stat_req.stat_op_nfs40[j].total;
global_worker_stat.stat_req.stat_op_nfs40[j].success +=
workers_data[i].stats.stat_req.stat_op_nfs40[j].success;
global_worker_stat.stat_req.stat_op_nfs40[j].failed +=
workers_data[i].stats.stat_req.stat_op_nfs40[j].failed;
}
}
for(j = 0; j < NFS_V41_NB_OPERATION; j++)
{
if(i == 0)
{
global_worker_stat.stat_req.stat_op_nfs41[j].total =
workers_data[i].stats.stat_req.stat_op_nfs41[j].total;
global_worker_stat.stat_req.stat_op_nfs41[j].success =
workers_data[i].stats.stat_req.stat_op_nfs41[j].success;
global_worker_stat.stat_req.stat_op_nfs41[j].failed =
workers_data[i].stats.stat_req.stat_op_nfs41[j].failed;
}
else
{
global_worker_stat.stat_req.stat_op_nfs41[j].total +=
workers_data[i].stats.stat_req.stat_op_nfs41[j].total;
global_worker_stat.stat_req.stat_op_nfs41[j].success +=
workers_data[i].stats.stat_req.stat_op_nfs41[j].success;
global_worker_stat.stat_req.stat_op_nfs41[j].failed +=
workers_data[i].stats.stat_req.stat_op_nfs41[j].failed;
}
}
for(j = 0; j < NLM_V4_NB_OPERATION; j++)
{
if(i == 0)
{
global_worker_stat.stat_req.stat_req_nlm4[j].total =
workers_data[i].stats.stat_req.stat_req_nlm4[j].total;
global_worker_stat.stat_req.stat_req_nlm4[j].success =
workers_data[i].stats.stat_req.stat_req_nlm4[j].success;
global_worker_stat.stat_req.stat_req_nlm4[j].dropped =
workers_data[i].stats.stat_req.stat_req_nlm4[j].dropped;
}
else
{
global_worker_stat.stat_req.stat_req_nlm4[j].total +=
workers_data[i].stats.stat_req.stat_req_nlm4[j].total;
global_worker_stat.stat_req.stat_req_nlm4[j].success +=
workers_data[i].stats.stat_req.stat_req_nlm4[j].success;
global_worker_stat.stat_req.stat_req_nlm4[j].dropped +=
workers_data[i].stats.stat_req.stat_req_nlm4[j].dropped;
}
}
for(j = 0; j < RQUOTA_NB_COMMAND; j++)
{
if(i == 0)
{
global_worker_stat.stat_req.stat_req_rquota1[j].total =
workers_data[i].stats.stat_req.stat_req_rquota1[j].total;
global_worker_stat.stat_req.stat_req_rquota1[j].success =
workers_data[i].stats.stat_req.stat_req_rquota1[j].success;
global_worker_stat.stat_req.stat_req_rquota1[j].dropped =
workers_data[i].stats.stat_req.stat_req_rquota1[j].dropped;
global_worker_stat.stat_req.stat_req_rquota2[j].total =
workers_data[i].stats.stat_req.stat_req_rquota2[j].total;
global_worker_stat.stat_req.stat_req_rquota2[j].success =
workers_data[i].stats.stat_req.stat_req_rquota2[j].success;
global_worker_stat.stat_req.stat_req_rquota2[j].dropped =
workers_data[i].stats.stat_req.stat_req_rquota2[j].dropped;
}
else
{
global_worker_stat.stat_req.stat_req_rquota1[j].total +=
workers_data[i].stats.stat_req.stat_req_rquota1[j].total;
global_worker_stat.stat_req.stat_req_rquota1[j].success +=
workers_data[i].stats.stat_req.stat_req_rquota1[j].success;
global_worker_stat.stat_req.stat_req_rquota1[j].dropped +=
workers_data[i].stats.stat_req.stat_req_rquota1[j].dropped;
global_worker_stat.stat_req.stat_req_rquota2[j].total +=
workers_data[i].stats.stat_req.stat_req_rquota2[j].total;
global_worker_stat.stat_req.stat_req_rquota2[j].success +=
workers_data[i].stats.stat_req.stat_req_rquota2[j].success;
global_worker_stat.stat_req.stat_req_rquota2[j].dropped +=
workers_data[i].stats.stat_req.stat_req_rquota2[j].dropped;
}
}
/* Computing the pending request stats */
len_pending_request =
workers_data[i].pending_request->nb_entry -
workers_data[i].pending_request->nb_invalid;
if(len_pending_request < min_pending_request)
min_pending_request = len_pending_request;
if(len_pending_request > max_pending_request)
max_pending_request = len_pending_request;
total_pending_request += len_pending_request;
} /* for( i = 0 ; i < nfs_param.core_param.nb_worker ; i++ ) */
/* Compute average pending request */
average_pending_request = total_pending_request / nfs_param.core_param.nb_worker;
fprintf(stats_file, "NFS/MOUNT STATISTICS,%s;%u,%u,%u|%u,%u,%u,%u,%u|%u,%u,%u,%u\n",
strdate,
global_worker_stat.nb_total_req,
global_worker_stat.nb_udp_req,
global_worker_stat.nb_tcp_req,
global_worker_stat.stat_req.nb_mnt1_req,
global_worker_stat.stat_req.nb_mnt3_req,
global_worker_stat.stat_req.nb_nfs2_req,
global_worker_stat.stat_req.nb_nfs3_req,
global_worker_stat.stat_req.nb_nfs4_req,
total_pending_request,
min_pending_request, max_pending_request, average_pending_request);
fprintf(stats_file, "MNT V1 REQUEST,%s;%u", strdate,
global_worker_stat.stat_req.nb_mnt1_req);
for(j = 0; j < MNT_V1_NB_COMMAND; j++)
fprintf(stats_file, "|%u,%u,%u",
global_worker_stat.stat_req.stat_req_mnt1[j].total,
global_worker_stat.stat_req.stat_req_mnt1[j].success,
global_worker_stat.stat_req.stat_req_mnt1[j].dropped);
fprintf(stats_file, "\n");
fprintf(stats_file, "MNT V3 REQUEST,%s;%u", strdate,
global_worker_stat.stat_req.nb_mnt3_req);
for(j = 0; j < MNT_V3_NB_COMMAND; j++)
fprintf(stats_file, "|%u,%u,%u",
global_worker_stat.stat_req.stat_req_mnt3[j].total,
global_worker_stat.stat_req.stat_req_mnt3[j].success,
global_worker_stat.stat_req.stat_req_mnt3[j].dropped);
fprintf(stats_file, "\n");
fprintf(stats_file, "NFS V2 REQUEST,%s;%u", strdate,
global_worker_stat.stat_req.nb_nfs2_req);
for(j = 0; j < NFS_V2_NB_COMMAND; j++)
fprintf(stats_file, "|%u,%u,%u",
global_worker_stat.stat_req.stat_req_nfs2[j].total,
global_worker_stat.stat_req.stat_req_nfs2[j].success,
global_worker_stat.stat_req.stat_req_nfs2[j].dropped);
fprintf(stats_file, "\n");
fprintf(stats_file, "NFS V3 REQUEST,%s;%u", strdate,
global_worker_stat.stat_req.nb_nfs3_req);
for(j = 0; j < NFS_V3_NB_COMMAND; j++)
{
if(global_worker_stat.stat_req.stat_req_nfs3[j].total > 0)
{
avg_latency = (global_worker_stat.stat_req.stat_req_nfs3[j].tot_latency /
global_worker_stat.stat_req.stat_req_nfs3[j].total);
}
else
{
avg_latency = 0;
}
fprintf(stats_file, "|%u,%u,%u,%u,%u,%u,%u",
global_worker_stat.stat_req.stat_req_nfs3[j].total,
global_worker_stat.stat_req.stat_req_nfs3[j].success,
global_worker_stat.stat_req.stat_req_nfs3[j].dropped,
global_worker_stat.stat_req.stat_req_nfs3[j].tot_latency,
avg_latency,
global_worker_stat.stat_req.stat_req_nfs3[j].min_latency,
global_worker_stat.stat_req.stat_req_nfs3[j].max_latency);
}
fprintf(stats_file, "\n");
fprintf(stats_file, "NFS V4 REQUEST,%s;%u", strdate,
global_worker_stat.stat_req.nb_nfs4_req);
for(j = 0; j < NFS_V4_NB_COMMAND; j++)
fprintf(stats_file, "|%u,%u,%u",
global_worker_stat.stat_req.stat_req_nfs4[j].total,
global_worker_stat.stat_req.stat_req_nfs4[j].success,
global_worker_stat.stat_req.stat_req_nfs4[j].dropped);
fprintf(stats_file, "\n");
fprintf(stats_file, "NFS V4.0 OPERATIONS,%s;%u", strdate,
global_worker_stat.stat_req.nb_nfs40_op);
for(j = 0; j < NFS_V40_NB_OPERATION; j++)
fprintf(stats_file, "|%u,%u,%u",
global_worker_stat.stat_req.stat_op_nfs40[j].total,
global_worker_stat.stat_req.stat_op_nfs40[j].success,
global_worker_stat.stat_req.stat_op_nfs40[j].failed);
fprintf(stats_file, "\n");
fprintf(stats_file, "NFS V4.1 OPERATIONS,%s;%u", strdate,
global_worker_stat.stat_req.nb_nfs41_op);
for(j = 0; j < NFS_V41_NB_OPERATION; j++)
fprintf(stats_file, "|%u,%u,%u",
global_worker_stat.stat_req.stat_op_nfs41[j].total,
global_worker_stat.stat_req.stat_op_nfs41[j].success,
global_worker_stat.stat_req.stat_op_nfs41[j].failed);
fprintf(stats_file, "\n");
fprintf(stats_file, "NLM V4 REQUEST,%s;%u", strdate,
global_worker_stat.stat_req.nb_nlm4_req);
for(j = 0; j < NLM_V4_NB_OPERATION; j++)
fprintf(stats_file, "|%u,%u,%u",
global_worker_stat.stat_req.stat_req_nlm4[j].total,
global_worker_stat.stat_req.stat_req_nlm4[j].success,
global_worker_stat.stat_req.stat_req_nlm4[j].dropped);
fprintf(stats_file, "\n");
fprintf(stats_file, "RQUOTA V1 REQUEST,%s;%u", strdate,
global_worker_stat.stat_req.nb_rquota1_req);
for(j = 0; j < RQUOTA_NB_COMMAND; j++)
fprintf(stats_file, "|%u,%u,%u",
global_worker_stat.stat_req.stat_req_rquota1[j].total,
global_worker_stat.stat_req.stat_req_rquota1[j].success,
global_worker_stat.stat_req.stat_req_rquota1[j].dropped);
fprintf(stats_file, "\n");
fprintf(stats_file, "RQUOTA V2 REQUEST,%s;%u", strdate,
global_worker_stat.stat_req.nb_rquota2_req);
for(j = 0; j < RQUOTA_NB_COMMAND; j++)
fprintf(stats_file, "|%u,%u,%u",
global_worker_stat.stat_req.stat_req_rquota2[j].total,
global_worker_stat.stat_req.stat_req_rquota2[j].success,
global_worker_stat.stat_req.stat_req_rquota2[j].dropped);
fprintf(stats_file, "\n");
/* Printing the cache inode hash stat */
nfs_dupreq_get_stats(&hstat);
fprintf(stats_file,
"DUP_REQ_HASH,%s;%u,%u,%u,%u|%u,%u,%u|%u,%u,%u|%u,%u,%u|%u,%u,%u\n",
strdate, hstat.dynamic.nb_entries, hstat.computed.min_rbt_num_node,
hstat.computed.max_rbt_num_node, hstat.computed.average_rbt_num_node,
hstat.dynamic.ok.nb_set, hstat.dynamic.notfound.nb_set,
hstat.dynamic.err.nb_set, hstat.dynamic.ok.nb_test,
hstat.dynamic.notfound.nb_test, hstat.dynamic.err.nb_test,
hstat.dynamic.ok.nb_get, hstat.dynamic.notfound.nb_get,
hstat.dynamic.err.nb_get, hstat.dynamic.ok.nb_del,
hstat.dynamic.notfound.nb_del, hstat.dynamic.err.nb_del);
/* Printing the UIDMAP_TYPE hash table stats */
idmap_get_stats(UIDMAP_TYPE, &hstat, &hstat_reverse);
fprintf(stats_file,
"UIDMAP_HASH,%s;%u,%u,%u,%u|%u,%u,%u|%u,%u,%u|%u,%u,%u|%u,%u,%u\n", strdate,
hstat.dynamic.nb_entries, hstat.computed.min_rbt_num_node,
hstat.computed.max_rbt_num_node, hstat.computed.average_rbt_num_node,
hstat.dynamic.ok.nb_set, hstat.dynamic.notfound.nb_set,
hstat.dynamic.err.nb_set, hstat.dynamic.ok.nb_test,
hstat.dynamic.notfound.nb_test, hstat.dynamic.err.nb_test,
hstat.dynamic.ok.nb_get, hstat.dynamic.notfound.nb_get,
hstat.dynamic.err.nb_get, hstat.dynamic.ok.nb_del,
hstat.dynamic.notfound.nb_del, hstat.dynamic.err.nb_del);
fprintf(stats_file,
"UNAMEMAP_HASH,%s;%u,%u,%u,%u|%u,%u,%u|%u,%u,%u|%u,%u,%u|%u,%u,%u\n",
strdate, hstat_reverse.dynamic.nb_entries,
hstat_reverse.computed.min_rbt_num_node,
hstat_reverse.computed.max_rbt_num_node,
hstat_reverse.computed.average_rbt_num_node,
hstat_reverse.dynamic.ok.nb_set, hstat_reverse.dynamic.notfound.nb_set,
hstat_reverse.dynamic.err.nb_set, hstat_reverse.dynamic.ok.nb_test,
hstat_reverse.dynamic.notfound.nb_test, hstat_reverse.dynamic.err.nb_test,
hstat_reverse.dynamic.ok.nb_get, hstat_reverse.dynamic.notfound.nb_get,
hstat_reverse.dynamic.err.nb_get, hstat_reverse.dynamic.ok.nb_del,
hstat_reverse.dynamic.notfound.nb_del, hstat_reverse.dynamic.err.nb_del);
/* Printing the GIDMAP_TYPE hash table stats */
idmap_get_stats(GIDMAP_TYPE, &hstat, &hstat_reverse);
fprintf(stats_file,
"GIDMAP_HASH,%s;%u,%u,%u,%u|%u,%u,%u|%u,%u,%u|%u,%u,%u|%u,%u,%u\n", strdate,
hstat.dynamic.nb_entries, hstat.computed.min_rbt_num_node,
hstat.computed.max_rbt_num_node, hstat.computed.average_rbt_num_node,
hstat.dynamic.ok.nb_set, hstat.dynamic.notfound.nb_set,
hstat.dynamic.err.nb_set, hstat.dynamic.ok.nb_test,
hstat.dynamic.notfound.nb_test, hstat.dynamic.err.nb_test,
hstat.dynamic.ok.nb_get, hstat.dynamic.notfound.nb_get,
hstat.dynamic.err.nb_get, hstat.dynamic.ok.nb_del,
hstat.dynamic.notfound.nb_del, hstat.dynamic.err.nb_del);
fprintf(stats_file,
"GNAMEMAP_HASH,%s;%u,%u,%u,%u|%u,%u,%u|%u,%u,%u|%u,%u,%u|%u,%u,%u\n",
strdate, hstat_reverse.dynamic.nb_entries,
hstat_reverse.computed.min_rbt_num_node,
hstat_reverse.computed.max_rbt_num_node,
hstat_reverse.computed.average_rbt_num_node,
hstat_reverse.dynamic.ok.nb_set, hstat_reverse.dynamic.notfound.nb_set,
hstat_reverse.dynamic.err.nb_set, hstat_reverse.dynamic.ok.nb_test,
hstat_reverse.dynamic.notfound.nb_test, hstat_reverse.dynamic.err.nb_test,
hstat_reverse.dynamic.ok.nb_get, hstat_reverse.dynamic.notfound.nb_get,
hstat_reverse.dynamic.err.nb_get, hstat_reverse.dynamic.ok.nb_del,
hstat_reverse.dynamic.notfound.nb_del, hstat_reverse.dynamic.err.nb_del);
/* Stats for the IP/Name hashtable */
nfs_ip_name_get_stats(&hstat);
fprintf(stats_file,
"IP_NAME_HASH,%s;%u,%u,%u,%u|%u,%u,%u|%u,%u,%u|%u,%u,%u|%u,%u,%u\n",
strdate, hstat_reverse.dynamic.nb_entries,
hstat_reverse.computed.min_rbt_num_node,
hstat_reverse.computed.max_rbt_num_node,
hstat_reverse.computed.average_rbt_num_node,
hstat_reverse.dynamic.ok.nb_set, hstat_reverse.dynamic.notfound.nb_set,
hstat_reverse.dynamic.err.nb_set, hstat_reverse.dynamic.ok.nb_test,
hstat_reverse.dynamic.notfound.nb_test, hstat_reverse.dynamic.err.nb_test,
hstat_reverse.dynamic.ok.nb_get, hstat_reverse.dynamic.notfound.nb_get,
hstat_reverse.dynamic.err.nb_get, hstat_reverse.dynamic.ok.nb_del,
hstat_reverse.dynamic.notfound.nb_del, hstat_reverse.dynamic.err.nb_del);
/* fsal statistics */
memset(&global_fsal_stat, 0, sizeof(fsal_statistics_t));
total_fsal_calls = 0;
for(i = 0; i < nfs_param.core_param.nb_worker; i++)
{
for(j = 0; j < FSAL_NB_FUNC; j++)
{
total_fsal_calls += workers_data[i].stats.fsal_stats.func_stats.nb_call[j];
global_fsal_stat.func_stats.nb_call[j] +=
workers_data[i].stats.fsal_stats.func_stats.nb_call[j];
global_fsal_stat.func_stats.nb_success[j] +=
workers_data[i].stats.fsal_stats.func_stats.nb_success[j];
global_fsal_stat.func_stats.nb_err_retryable[j] +=
workers_data[i].stats.fsal_stats.func_stats.nb_err_retryable[j];
global_fsal_stat.func_stats.nb_err_unrecover[j] +=
workers_data[i].stats.fsal_stats.func_stats.nb_err_unrecover[j];
}
}
fprintf(stats_file, "FSAL_CALLS,%s;%llu", strdate, total_fsal_calls);
for(j = 0; j < FSAL_NB_FUNC; j++)
fprintf(stats_file, "|%u,%u,%u,%u",
global_fsal_stat.func_stats.nb_call[j],
global_fsal_stat.func_stats.nb_success[j],
global_fsal_stat.func_stats.nb_err_retryable[j],
global_fsal_stat.func_stats.nb_err_unrecover[j]);
fprintf(stats_file, "\n");
#ifndef _NO_BUDDY_SYSTEM
/* buddy memory */
memset(&global_buddy_stat, 0, sizeof(buddy_stats_t));
for(i = 0; i < nfs_param.core_param.nb_worker; i++)
{
global_buddy_stat.TotalMemSpace +=
workers_data[i].stats.buddy_stats.TotalMemSpace;
global_buddy_stat.ExtraMemSpace +=
workers_data[i].stats.buddy_stats.ExtraMemSpace;
global_buddy_stat.StdMemSpace += workers_data[i].stats.buddy_stats.StdMemSpace;
global_buddy_stat.StdUsedSpace +=
workers_data[i].stats.buddy_stats.StdUsedSpace;
if(workers_data[i].stats.buddy_stats.StdUsedSpace >
global_buddy_stat.WM_StdUsedSpace)
global_buddy_stat.WM_StdUsedSpace =
workers_data[i].stats.buddy_stats.StdUsedSpace;
global_buddy_stat.NbStdPages += workers_data[i].stats.buddy_stats.NbStdPages;
global_buddy_stat.NbStdUsed += workers_data[i].stats.buddy_stats.NbStdUsed;
if(workers_data[i].stats.buddy_stats.NbStdUsed > global_buddy_stat.WM_NbStdUsed)
global_buddy_stat.WM_NbStdUsed = workers_data[i].stats.buddy_stats.NbStdUsed;
}
/* total memory space preallocated, total space preallocated for pages, total space that overflows pages */
/* total memory, used memory, avg used memory/worker, max used memory/worker */
/* total pages, used pages, avg used pages/worker, max used pages/worker */
fprintf(stats_file, "BUDDY_MEMORY,%s;%lu,%lu,%lu|%lu,%lu,%lu|%u,%u,%u,%u\n",
strdate,
(unsigned long)global_buddy_stat.TotalMemSpace,
(unsigned long)global_buddy_stat.StdMemSpace,
(unsigned long)global_buddy_stat.ExtraMemSpace,
(unsigned long)global_buddy_stat.StdUsedSpace,
(unsigned long)(global_buddy_stat.StdUsedSpace /
nfs_param.core_param.nb_worker),
(unsigned long)global_buddy_stat.WM_StdUsedSpace,
global_buddy_stat.NbStdPages, global_buddy_stat.NbStdUsed,
global_buddy_stat.NbStdUsed / nfs_param.core_param.nb_worker,
global_buddy_stat.WM_NbStdUsed);
#endif
/* Flush the data written */
fprintf(stats_file, "END, ----- NO MORE STATS FOR THIS PASS ----\n");
fflush(stats_file);
/* Now managed IP stats dump */
nfs_ip_stats_dump(ht_ip_stats,
nfs_param.core_param.nb_worker,
nfs_param.core_param.stats_per_client_directory);
} /* while ( 1 ) */
return NULL;
} /* stats_thread */
void *reaper_thread(void *unused)
{
hash_table_t *ht = ht_client_id;
struct rbt_head *head_rbt;
hash_data_t *pdata = NULL;
int i, v4;
struct rbt_node *pn;
nfs_client_id_t *clientp;
#ifndef _NO_BUDDY_SYSTEM
if((i = BuddyInit(&nfs_param.buddy_param_admin)) != BUDDY_SUCCESS) {
/* Failed init */
LogFatal(COMPONENT_MAIN,
"Memory manager could not be initialized");
}
LogInfo(COMPONENT_MAIN, "Memory manager successfully initialized");
#endif
SetNameFunction("reaper_thr");
while(1) {
/* Initial wait */
/* TODO: should this be configurable? */
/* sleep(nfs_param.core_param.reaper_delay); */
sleep(reaper_delay);
LogFullDebug(COMPONENT_MAIN,
"NFS reaper : now checking clients");
/* For each bucket of the hashtable */
for(i = 0; i < ht->parameter.index_size; i++) {
head_rbt = &(ht->array_rbt[i]);
restart:
/* acquire mutex */
P_w(&(ht->array_lock[i]));
/* go through all entries in the red-black-tree*/
RBT_LOOP(head_rbt, pn) {
pdata = RBT_OPAQ(pn);
clientp =
(nfs_client_id_t *)pdata->buffval.pdata;
/*
* little hack: only want to reap v4 clients
* 4.1 initializess this field to '1'
*/
v4 = (clientp->create_session_sequence == 0);
if (clientp->confirmed != EXPIRED_CLIENT_ID &&
nfs4_is_lease_expired(clientp) && v4) {
V_w(&(ht->array_lock[i]));
LogDebug(COMPONENT_MAIN,
"NFS reaper: expire client %s",
clientp->client_name);
nfs_client_id_expire(clientp);
goto restart;
}
if (clientp->confirmed == EXPIRED_CLIENT_ID) {
LogDebug(COMPONENT_MAIN,
"reaper: client %s already expired",
clientp->client_name);
}
RBT_INCREMENT(pn);
}
V_w(&(ht->array_lock[i]));
}
} /* while ( 1 ) */
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[])
{
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 */
void *fsal_up_thread(void *Arg)
{
fsal_status_t status;
int rc;
fsal_up_arg_t *fsal_up_args = (fsal_up_arg_t *)Arg;
fsal_up_event_bus_context_t fsal_up_context;
fsal_up_event_bus_parameter_t fsal_up_bus_param;
fsal_up_event_bus_filter_t * pupebfilter = NULL;
fsal_up_filter_list_t *filter = NULL;
fsal_up_event_t *pevent_head, *event, *tmpevent;
fsal_up_event_functions_t *event_func;
fsal_count_t nb_events_found, event_nb;
fsal_time_t timeout;
char thr_name[40];
memset(&fsal_up_bus_param, 0, sizeof(fsal_up_event_bus_parameter_t));
memset(&fsal_up_context, 0, sizeof(fsal_up_event_bus_context_t));
snprintf(thr_name, sizeof(thr_name), "FSAL UP Thread for filesystem %llu.%llu",
fsal_up_args->export_entry->filesystem_id.major,
fsal_up_args->export_entry->filesystem_id.minor);
SetNameFunction(thr_name);
#ifndef _NO_BUDDY_SYSTEM
if((rc = BuddyInit(&nfs_param.buddy_param_fsal_up)) != BUDDY_SUCCESS)
{
/* Failed init */
LogFatal(COMPONENT_FSAL_UP,
"FSAL_UP: Memory manager could not be initialized");
Fatal();
}
LogInfo(COMPONENT_FSAL_UP,
"FSAL_UP: Memory manager for filesystem %llu.%llu export id %d"
" successfully initialized",
fsal_up_args->export_entry->filesystem_id.major,
fsal_up_args->export_entry->filesystem_id.minor,
fsal_up_args->export_entry->id);
#endif
/* Set the FSAL UP functions that will be used to process events. */
event_func = get_fsal_up_functions(fsal_up_args->export_entry->fsal_up_type);
if (event_func == NULL)
{
LogCrit(COMPONENT_FSAL_UP, "Error: FSAL UP TYPE: %s does not exist. "
"Exiting FSAL UP thread.", fsal_up_args->export_entry->fsal_up_type);
Mem_Free(Arg);
return NULL;
}
/* Get fsal up context from FSAL */
/* It is expected that the export entry and event_pool will be referenced
* in the returned callback context structure. */
memcpy(&fsal_up_context.FS_export_context,
&fsal_up_args->export_entry->FS_export_context,
sizeof(fsal_export_context_t));
fsal_up_context.event_pool = &nfs_param.fsal_up_param.event_pool;
LogDebug(COMPONENT_FSAL_UP, "Initializing FSAL Callback context.");
status = FSAL_UP_Init(&fsal_up_bus_param, &fsal_up_context);
if (FSAL_IS_ERROR(status))
{
LogCrit(COMPONENT_FSAL_UP, "Error: Could not initialize FSAL UP for"
" filesystem %llu.%llu export %d. Exiting FSAL UP thread.",
fsal_up_args->export_entry->filesystem_id.major,
fsal_up_args->export_entry->filesystem_id.minor,
fsal_up_args->export_entry->id);
}
/* Add filters ... later if needed we could add arguments to filters
* configurable from configuration files. */
for(filter = fsal_up_args->export_entry->fsal_up_filter_list;
filter != NULL; filter = filter->next)
{
LogEvent(COMPONENT_FSAL_UP, "Applying filter \"%s\" to FSAL UP thread "
"for filesystem id %llu.%llu export id %d.", filter->name,
fsal_up_args->export_entry->filesystem_id.major,
fsal_up_args->export_entry->filesystem_id.minor,
fsal_up_args->export_entry->id);
/* Find predefined filter */
pupebfilter = find_filter(filter->name);
if (pupebfilter == NULL)
{
LogCrit(COMPONENT_FSAL_UP, "Error: Could not find filter named \"%s\".",
filter->name);
}
/* Applying filter */
FSAL_UP_AddFilter(pupebfilter, &fsal_up_context);
}
/* Set the timeout for getting events. */
timeout = fsal_up_args->export_entry->fsal_up_timeout;
/* Start querying for events and processing. */
while(1)
{
/* pevent is passed in as a single empty node, it's expected the
* FSAL will use the event_pool in the bus_context to populate
* this array by adding to the pevent_head->next attribute. */
event_nb = 0;
nb_events_found = 0;
pevent_head = NULL;
LogDebug(COMPONENT_FSAL_UP, "Requesting event from FSAL Callback interface.");
status = FSAL_UP_GetEvents(&pevent_head, /* out */
&event_nb, /* in/out */
timeout, /* in */
&nb_events_found, /* out */
&fsal_up_context);/* in */
if (FSAL_IS_ERROR(status))
{
if (status.major == ERR_FSAL_TIMEOUT)
LogDebug(COMPONENT_FSAL_UP, "FSAL_UP_EB_GetEvents() hit the timeout"
" limit of %u.%u seconds for filesystem id %llu.%llu export id"
" %d.", timeout.seconds, timeout.nseconds,
fsal_up_args->export_entry->filesystem_id.major,
fsal_up_args->export_entry->filesystem_id.minor,
fsal_up_args->export_entry->id);
else if (status.major == ERR_FSAL_NOTSUPP)
{
LogCrit(COMPONENT_FSAL_UP, "Exiting FSAL UP Thread for filesystem"
" id %llu.%llu export id %u because the FSAL Callback"
" Interface is not supported for this FSAL type.",
fsal_up_args->export_entry->filesystem_id.major,
fsal_up_args->export_entry->filesystem_id.minor,
fsal_up_args->export_entry->id);
return NULL;
}
else
LogDebug(COMPONENT_FSAL_UP, "Error: FSAL_UP_EB_GetEvents() "
"failed");
}
LogDebug(COMPONENT_FSAL_UP, "Received %lu events to process for filesystem"
" id %llu.%llu export id %u.",
event_nb,
fsal_up_args->export_entry->filesystem_id.major,
fsal_up_args->export_entry->filesystem_id.minor,
fsal_up_args->export_entry->id);
/* process the list of events */
for(event = pevent_head; event != NULL;)
{
status = process_event(event, event_func);
if (FSAL_IS_ERROR(status))
{
LogDebug(COMPONENT_FSAL_UP, "Error: Event could not be processed "
"for filesystem %llu.%llu export id %u.",
fsal_up_args->export_entry->filesystem_id.major,
fsal_up_args->export_entry->filesystem_id.minor,
fsal_up_args->export_entry->id);
}
tmpevent = event;
event = event->next_event;
ReleaseToPool(tmpevent, &nfs_param.fsal_up_param.event_pool);
event_nb--;
}
LogDebug(COMPONENT_FSAL_UP, "%lu events not found for filesystem"
" %llu.%llu export id %u", event_nb,
fsal_up_args->export_entry->filesystem_id.major,
fsal_up_args->export_entry->filesystem_id.minor,
fsal_up_args->export_entry->id);
}
Mem_Free(Arg);
return NULL;
} /* fsal_up_thread */
