int nfs_ip_stats_add(hash_table_t * ht_ip_stats,
unsigned int ipaddr, nfs_ip_stats_t * nfs_ip_stats_pool)
{
hash_buffer_t buffkey;
hash_buffer_t buffdata;
nfs_ip_stats_t *pnfs_ip_stats = NULL;
unsigned long int local_ipaddr = ipaddr;
/* Do nothing if configuration disables IP_Stats */
if(nfs_param.core_param.dump_stats_per_client == 0)
return IP_STATS_SUCCESS;
#ifdef _DEBUG_MEMLEAKS
/* For debugging memory leaks */
BuddySetDebugLabel("nfs_ip_stats_t");
#endif
/* Entry to be cached */
GET_PREALLOC(pnfs_ip_stats,
nfs_ip_stats_pool,
nfs_param.worker_param.nb_ip_stats_prealloc, nfs_ip_stats_t, next_alloc);
#ifdef _DEBUG_MEMLEAKS
/* For debugging memory leaks */
BuddySetDebugLabel("N/A");
#endif
if(pnfs_ip_stats == NULL)
return IP_STATS_INSERT_MALLOC_ERROR;
/* I have to keep an integer as key, I wil use the pointer buffkey->pdata for this,
* this also means that buffkey->len will be 0 */
buffkey.pdata = (caddr_t) local_ipaddr;
buffkey.len = 0;
/* I build the data with the request pointer that should be in state 'IN USE' */
pnfs_ip_stats->nb_call = 0;
pnfs_ip_stats->nb_req_nfs2 = 0;
pnfs_ip_stats->nb_req_nfs3 = 0;
pnfs_ip_stats->nb_req_nfs4 = 0;
pnfs_ip_stats->nb_req_mnt1 = 0;
pnfs_ip_stats->nb_req_mnt3 = 0;
memset(pnfs_ip_stats->req_mnt1, 0, MNT_V1_NB_COMMAND * sizeof(int));
memset(pnfs_ip_stats->req_mnt3, 0, MNT_V3_NB_COMMAND * sizeof(int));
memset(pnfs_ip_stats->req_nfs2, 0, NFS_V2_NB_COMMAND * sizeof(int));
memset(pnfs_ip_stats->req_nfs3, 0, NFS_V3_NB_COMMAND * sizeof(int));
buffdata.pdata = (caddr_t) pnfs_ip_stats;
buffdata.len = sizeof(nfs_ip_stats_t);
if(HashTable_Set(ht_ip_stats, &buffkey, &buffdata) != HASHTABLE_SUCCESS)
return IP_STATS_INSERT_MALLOC_ERROR;
return IP_STATS_SUCCESS;
} /* nfs_ip_stats_add */
int nfs_ip_stats_add(hash_table_t * ht_ip_stats,
sockaddr_t * ipaddr, pool_t *ip_stats_pool)
{
hash_buffer_t buffkey;
hash_buffer_t buffdata;
nfs_ip_stats_t *g = NULL;
sockaddr_t *pipaddr = NULL;
/* Do nothing if configuration disables IP_Stats */
if(nfs_param.core_param.dump_stats_per_client == 0)
return IP_STATS_SUCCESS;
/* Entry to be cached */
g = pool_alloc(ip_stats_pool, NULL);
if(g == NULL)
return IP_STATS_INSERT_MALLOC_ERROR;
if((pipaddr = gsh_malloc(sizeof(sockaddr_t))) == NULL)
{
pool_free(ip_stats_pool, g);
return IP_STATS_INSERT_MALLOC_ERROR;
}
/* I have to keep an integer as key, I wil use the pointer
* buffkey->pdata for this, this also means that buffkey->len will
* be 0 */
memcpy(pipaddr, ipaddr, sizeof(sockaddr_t));
buffkey.pdata = pipaddr;
buffkey.len = sizeof(sockaddr_t);
/* I build the data with the request pointer that should be in state 'IN USE' */
g->nb_call = 0;
g->nb_req_nfs2 = 0;
g->nb_req_nfs3 = 0;
g->nb_req_nfs4 = 0;
g->nb_req_mnt1 = 0;
g->nb_req_mnt3 = 0;
memset(g->req_mnt1, 0, MNT_V1_NB_COMMAND * sizeof(int));
memset(g->req_mnt3, 0, MNT_V3_NB_COMMAND * sizeof(int));
memset(g->req_nfs2, 0, NFS_V2_NB_COMMAND * sizeof(int));
memset(g->req_nfs3, 0, NFS_V3_NB_COMMAND * sizeof(int));
buffdata.pdata = (caddr_t) g;
buffdata.len = sizeof(nfs_ip_stats_t);
if(HashTable_Set(ht_ip_stats, &buffkey, &buffdata) != HASHTABLE_SUCCESS)
return IP_STATS_INSERT_MALLOC_ERROR;
return IP_STATS_SUCCESS;
} /* nfs_ip_stats_add */
int nfs_ip_stats_add(hash_table_t * ht_ip_stats,
sockaddr_t * ipaddr, struct prealloc_pool *ip_stats_pool)
{
hash_buffer_t buffkey;
hash_buffer_t buffdata;
nfs_ip_stats_t *pnfs_ip_stats = NULL;
sockaddr_t *pipaddr = NULL;
/* Do nothing if configuration disables IP_Stats */
if(nfs_param.core_param.dump_stats_per_client == 0)
return IP_STATS_SUCCESS;
/* Entry to be cached */
GetFromPool(pnfs_ip_stats, ip_stats_pool, nfs_ip_stats_t);
if(pnfs_ip_stats == NULL)
return IP_STATS_INSERT_MALLOC_ERROR;
if((pipaddr = (sockaddr_t *) Mem_Alloc(sizeof(sockaddr_t))) == NULL)
{
ReleaseToPool(pnfs_ip_stats, ip_stats_pool);
return IP_STATS_INSERT_MALLOC_ERROR;
}
/* I have to keep an integer as key, I wil use the pointer buffkey->pdata for this,
* this also means that buffkey->len will be 0 */
memcpy(pipaddr, ipaddr, sizeof(sockaddr_t));
buffkey.pdata = (caddr_t) pipaddr;
buffkey.len = sizeof(sockaddr_t);
/* I build the data with the request pointer that should be in state 'IN USE' */
pnfs_ip_stats->nb_call = 0;
pnfs_ip_stats->nb_req_nfs2 = 0;
pnfs_ip_stats->nb_req_nfs3 = 0;
pnfs_ip_stats->nb_req_nfs4 = 0;
pnfs_ip_stats->nb_req_mnt1 = 0;
pnfs_ip_stats->nb_req_mnt3 = 0;
memset(pnfs_ip_stats->req_mnt1, 0, MNT_V1_NB_COMMAND * sizeof(int));
memset(pnfs_ip_stats->req_mnt3, 0, MNT_V3_NB_COMMAND * sizeof(int));
memset(pnfs_ip_stats->req_nfs2, 0, NFS_V2_NB_COMMAND * sizeof(int));
memset(pnfs_ip_stats->req_nfs3, 0, NFS_V3_NB_COMMAND * sizeof(int));
buffdata.pdata = (caddr_t) pnfs_ip_stats;
buffdata.len = sizeof(nfs_ip_stats_t);
if(HashTable_Set(ht_ip_stats, &buffkey, &buffdata) != HASHTABLE_SUCCESS)
return IP_STATS_INSERT_MALLOC_ERROR;
return IP_STATS_SUCCESS;
} /* nfs_ip_stats_add */
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 nfs_ip_name_add(sockaddr_t *ipaddr, char *hostname, size_t size)
{
struct gsh_buffdesc buffkey;
struct gsh_buffdesc buffdata;
nfs_ip_name_t *nfs_ip_name = NULL;
sockaddr_t *pipaddr = NULL;
struct timeval tv0, tv1, dur;
int rc;
char ipstring[SOCK_NAME_MAX + 1];
nfs_ip_name = gsh_malloc(sizeof(nfs_ip_name_t));
pipaddr = gsh_malloc(sizeof(sockaddr_t));
/* I have to keep an integer as key, I wil use the pointer buffkey->addr
* for this, this also means that buffkey->len will be 0
*/
memcpy(pipaddr, ipaddr, sizeof(sockaddr_t));
buffkey.addr = pipaddr;
buffkey.len = sizeof(sockaddr_t);
gettimeofday(&tv0, NULL);
rc = getnameinfo((struct sockaddr *)pipaddr, sizeof(sockaddr_t),
nfs_ip_name->hostname, sizeof(nfs_ip_name->hostname),
NULL, 0, 0);
gettimeofday(&tv1, NULL);
timersub(&tv1, &tv0, &dur);
sprint_sockip(pipaddr, ipstring, sizeof(ipstring));
/* display warning if DNS resolution took more that 1.0s */
if (dur.tv_sec >= 1) {
LogEvent(COMPONENT_DISPATCH,
"Warning: long DNS query for %s: %u.%06u sec",
ipstring, (unsigned int)dur.tv_sec,
(unsigned int)dur.tv_usec);
}
/* Ask for the name to be cached */
if (rc != 0) {
strmaxcpy(nfs_ip_name->hostname, ipstring,
sizeof(nfs_ip_name->hostname));
LogEvent(COMPONENT_DISPATCH,
"Cannot resolve address %s, error %s, using %s as hostname",
ipstring, gai_strerror(rc), nfs_ip_name->hostname);
}
LogDebug(COMPONENT_DISPATCH, "Inserting %s->%s to addr cache", ipstring,
nfs_ip_name->hostname);
/* I build the data with the request pointer
* that should be in state 'IN USE'
*/
nfs_ip_name->timestamp = time(NULL);
buffdata.addr = nfs_ip_name;
buffdata.len = sizeof(nfs_ip_name_t);
if (HashTable_Set(ht_ip_name, &buffkey, &buffdata) != HASHTABLE_SUCCESS)
return IP_NAME_INSERT_MALLOC_ERROR;
/* Copy the value for the caller */
strmaxcpy(hostname, nfs_ip_name->hostname, size);
return IP_NAME_SUCCESS;
} /* nfs_ip_name_add */
int nfs_ip_name_populate(char *path)
{
config_file_t config_file;
config_item_t block;
int var_max;
int var_index;
int err;
char *key_name;
char *key_value;
char label[MAXNAMLEN];
sockaddr_t ipaddr;
nfs_ip_name_t *nfs_ip_name;
sockaddr_t *pipaddr;
hash_buffer_t buffkey;
hash_buffer_t buffdata;
config_file = config_ParseFile(path);
if(!config_file)
{
LogCrit(COMPONENT_CONFIG, "Can't open file %s", path);
return IP_NAME_NOT_FOUND;
}
/* Get the config BLOCK */
if((block = config_FindItemByName(config_file, CONF_LABEL_IP_NAME_HOSTS)) == NULL)
{
LogCrit(COMPONENT_CONFIG,
"Can't get label %s in file %s",
CONF_LABEL_IP_NAME_HOSTS, path);
return IP_NAME_NOT_FOUND;
}
else if(config_ItemType(block) != CONFIG_ITEM_BLOCK)
{
/* Expected to be a block */
return IP_NAME_NOT_FOUND;
}
var_max = config_GetNbItems(block);
for(var_index = 0; var_index < var_max; var_index++)
{
config_item_t item;
item = config_GetItemByIndex(block, var_index);
/* Get key's name */
if((err = config_GetKeyValue(item, &key_name, &key_value)) != 0)
{
LogCrit(COMPONENT_CONFIG,
"Error reading key[%d] from section \"%s\" of configuration file.",
var_index, label);
return IP_NAME_NOT_FOUND;
}
err = ipstring_to_sockaddr(key_value, &ipaddr);
if(err != 0)
{
LogCrit(COMPONENT_CONFIG,
"Error converting %s to an ipaddress %s",
key_value, gai_strerror(err));
return IP_NAME_NOT_FOUND;
}
/* Entry to be cached */
nfs_ip_name = gsh_malloc(sizeof(nfs_ip_name_t));
if(nfs_ip_name == NULL)
return IP_NAME_INSERT_MALLOC_ERROR;
pipaddr = gsh_malloc(sizeof(sockaddr_t));
if(pipaddr == NULL)
{
gsh_free(nfs_ip_name);
return IP_NAME_INSERT_MALLOC_ERROR;
}
strncpy(nfs_ip_name->hostname, key_name, MAXHOSTNAMELEN);
nfs_ip_name->timestamp = time(NULL);
memcpy(pipaddr, &ipaddr, sizeof(sockaddr_t));
buffdata.pdata = (caddr_t) nfs_ip_name;
buffdata.len = sizeof(nfs_ip_name_t);
buffkey.pdata = (caddr_t) pipaddr;
buffkey.len = sizeof(sockaddr_t);
if(HashTable_Set(ht_ip_name, &buffkey, &buffdata) != HASHTABLE_SUCCESS)
{
gsh_free(nfs_ip_name);
gsh_free(pipaddr);
return IP_NAME_INSERT_MALLOC_ERROR;
}
}
if(isFullDebug(COMPONENT_CONFIG))
HashTable_Log(COMPONENT_CONFIG, ht_ip_name);
return IP_NAME_SUCCESS;
} /* nfs_ip_name_populate */
