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 */