/** * @brief Initialize NFSd prerequisites * * @param[in] program_name Name of the program * @param[in] host_name Server host name * @param[in] debug_level Debug level * @param[in] log_path Log path */ void nfs_prereq_init(char *program_name, char *host_name, int debug_level, char *log_path) { /* Initialize logging */ SetNamePgm(program_name); SetNameFunction("main"); SetNameHost(host_name); InitLogging(); if (log_path) SetDefaultLogging(log_path); if (debug_level >= 0) SetLevelDebug(debug_level); ReadLogEnvironment(); /* Register error families */ AddFamilyError(ERR_POSIX, "POSIX Errors", tab_systeme_status); AddFamilyError(ERR_HASHTABLE, "HashTable related Errors", tab_errctx_hash); AddFamilyError(ERR_FSAL, "FSAL related Errors", tab_errstatus_FSAL); AddFamilyError(ERR_CACHE_INODE, "Cache Inode related Errors", tab_errstatus_cache_inode); }
void* posix_init(const char* config_file, const char* log_file) { SetNamePgm("TC-POSIX"); SetNameFunction("posix"); SetNameHost("localhost"); init_logging(log_file, NIV_EVENT); return (void*) log_file; }
/** * @brief Initialize NFSd prerequisites * * @param[in] program_name Name of the program * @param[in] host_name Server host name * @param[in] debug_level Debug level * @param[in] log_path Log path */ void nfs_prereq_init(char *program_name, char *host_name, int debug_level, char *log_path) { /* Initialize logging */ SetNamePgm(program_name); SetNameFunction("main"); SetNameHost(host_name); init_logging(log_path, debug_level); }
main(int argc, char *argv[]) { char localmachine[256]; cache_inode_client_t client; LRU_parameter_t lru_param; LRU_status_t lru_status; cache_inode_fsal_data_t fsdata; fsal_status_t status; fsal_parameter_t init_param; fsal_name_t name; fsal_path_t path; fsal_attrib_mask_t mask; fsal_path_t pathroot; fsal_attrib_list_t attribs; fsal_handle_t root_handle; cache_inode_endofdir_t eod_met; cache_inode_dir_entry_t dirent_array[100]; cache_inode_dir_entry_t dirent_array_loop[5]; unsigned int nbfound; unsigned int begin_cookie = 0; hash_buffer_t key, value; uid_t uid; fsal_cred_t cred; cache_inode_status_t cache_status; cache_inode_parameter_t cache_param; cache_inode_client_parameter_t cache_client_param; hash_table_t *ht = NULL; fsal_attrib_list_t attrlookup; cache_entry_t *cache_entry_root = NULL; cache_entry_t *cache_entry_lookup = NULL; cache_entry_t *cache_entry_lookup2 = NULL; cache_entry_t *cache_entry_lookup3 = NULL; cache_entry_t *cache_entry_lookup4 = NULL; cache_entry_t *cache_entry_dircont = NULL; cache_inode_gc_policy_t gcpol; char *configfile = argv[1]; int i = 0; int rc = 0; /* Init the Buddy System allocation */ if((rc = BuddyInit(NULL)) != BUDDY_SUCCESS) { LogTest("Error initializing memory allocator"); exit(1); } /* init debug */ SetDefaultLogging("TEST"); SetNamePgm("test_cache_inode"); SetNameFunction("main"); InitLogging(); #if defined( _USE_GHOSTFS ) if(argc != 2) { LogTest("Please set the configuration file as parameter"); exit(1); } #endif /* Obtention du nom de la machine */ if(gethostname(localmachine, sizeof(localmachine)) != 0) { LogError(COMPONENT_STDOUT,ERR_SYS, ERR_GETHOSTNAME, errno); exit(1); } else SetNameHost(localmachine); AddFamilyError(ERR_FSAL, "FSAL related Errors", tab_errstatus_FSAL); AddFamilyError(ERR_CACHE_INODE, "FSAL related Errors", tab_errstatus_cache_inode); /* creating log */ LogTest( "Starting the test"); LogTest( "-----------------"); #if defined( _USE_GHOSTFS ) if(FSAL_IS_ERROR(status = FSAL_str2path(configfile, strlen(configfile) + 1, &(init_param.fs_specific_info. definition_file)))) { LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor); } #elif defined( _USE_HPSS ) FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, Flags); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DebugValue); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, TransferType); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, NumRetries); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, BusyDelay); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, BusyRetries); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, TotalDelay); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, GKTotalDelay); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, LimitedRetries); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, MaxConnections); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, ReuseDataConnections); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, UsePortRange); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, RetryStageInp); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DMAPWriteUpdates); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, ServerName); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DescName); init_param.fs_specific_info.behaviors.PrincipalName = FSAL_INIT_FORCE_VALUE; strncpy(init_param.fs_specific_info.hpss_config.PrincipalName, HPSS_SSM, HPSS_MAX_PRINCIPAL_NAME); init_param.fs_specific_info.behaviors.KeytabPath = FSAL_INIT_FORCE_VALUE; strncpy(init_param.fs_specific_info.hpss_config.KeytabPath, HPSS_KEYTAB, HPSS_MAX_PATH_NAME); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DebugPath); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, HostName); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, RegistrySiteName); #endif /* 2-common info (default) */ FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxfilesize); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxlink); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxnamelen); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxpathlen); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, no_trunc); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, chown_restricted); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, case_insensitive); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, case_preserving); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, fh_expire_type); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, link_support); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, symlink_support); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, named_attr); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, unique_handles); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, lease_time); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, acl_support); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, cansettime); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, homogenous); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxread); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxwrite); /* Init */ if(FSAL_IS_ERROR(status = FSAL_Init(&init_param))) { LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor); } /* getting creds */ uid = getuid(); if(FSAL_IS_ERROR(status = FSAL_GetUserCred(uid, NULL, &cred))) { LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor); } /* Init of the cache inode module */ cache_param.hparam.index_size = 31; cache_param.hparam.alphabet_length = 10; /* Buffer seen as a decimal polynom */ cache_param.hparam.nb_node_prealloc = 100; cache_param.hparam.hash_func_key = cache_inode_fsal_hash_func; cache_param.hparam.hash_func_rbt = cache_inode_fsal_rbt_func; cache_param.hparam.hash_func_both = NULL ; /* BUGAZOMEU */ cache_param.hparam.compare_key = cache_inode_compare_key_fsal; cache_param.hparam.key_to_str = display_key; cache_param.hparam.val_to_str = display_value; if((ht = cache_inode_init(cache_param, &cache_status)) == NULL) { LogTest( "Error %d while init hash ", cache_status); } else LogTest( "Hash Table address = %p", ht); /* We need a cache_client to acces the cache */ cache_client_param.attrmask = FSAL_ATTRS_MANDATORY | FSAL_ATTR_MTIME | FSAL_ATTR_CTIME | FSAL_ATTR_ATIME; cache_client_param.nb_prealloc_entry = 1000; cache_client_param.nb_pre_dir_data = 200; cache_client_param.nb_pre_parent = 1200; cache_client_param.nb_pre_state_v4 = 100; cache_client_param.lru_param.nb_entry_prealloc = 1000; cache_client_param.lru_param.entry_to_str = lru_entry_to_str; cache_client_param.lru_param.clean_entry = lru_clean_entry; cache_client_param.grace_period_attr = 0; cache_client_param.grace_period_link = 0; cache_client_param.grace_period_dirent = 0; cache_client_param.expire_type_attr = CACHE_INODE_EXPIRE_NEVER; cache_client_param.expire_type_link = CACHE_INODE_EXPIRE_NEVER; cache_client_param.expire_type_dirent = CACHE_INODE_EXPIRE_NEVER; /* Init the cache_inode client */ if(cache_inode_client_init(&client, cache_client_param, 0, NULL) != 0) exit(1); /* Init the gc */ gcpol.file_expiration_delay = 3; gcpol.directory_expiration_delay = 4; gcpol.hwmark_nb_entries = 6; gcpol.lwmark_nb_entries = 3; gcpol.run_interval = 4; cache_inode_set_gc_policy(gcpol); /* Getting the root of the FS */ if((FSAL_IS_ERROR(status = FSAL_str2path("/", 2, &pathroot)))) { LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor); exit(1); } if((FSAL_IS_ERROR(status = FSAL_lookupPath(&pathroot, &cred, &root_handle, &attribs)))) { LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor); exit(1); } fsdata.cookie = 0; fsdata.handle = root_handle; /* Cache the root of the FS */ if((cache_entry_root = cache_inode_make_root(&fsdata, 1, ht, &client, &cred, &cache_status)) == NULL) { LogTest( "Error: can't init fs's root"); exit(1); } /* A lookup in the root fsal */ if((FSAL_IS_ERROR(status = FSAL_str2name("cea", 10, &name)))) { LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor); exit(1); } if((cache_entry_lookup = cache_inode_lookup(cache_entry_root, &name, &attrlookup, ht, &client, &cred, &cache_status)) == NULL) { LogTest( "Error: can't lookup"); exit(1); } /* Lookup a second time (entry should now be cached) */ if((cache_entry_lookup2 = cache_inode_lookup(cache_entry_root, &name, &attrlookup, ht, &client, &cred, &cache_status)) == NULL) { LogTest( "Error: can't lookup"); exit(1); } if(cache_entry_lookup2 != cache_entry_lookup) { LogTest("Error: lookup results should be the same"); exit(1); } /* A lookup in the root fsal */ if((FSAL_IS_ERROR(status = FSAL_str2name("log", 10, &name)))) { LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor); exit(1); } if((cache_entry_lookup3 = cache_inode_lookup(cache_entry_root, &name, &attrlookup, ht, &client, &cred, &cache_status)) == NULL) { LogTest( "Error: can't lookup"); exit(1); } if((cache_entry_lookup4 = cache_inode_lookup(cache_entry_root, &name, &attrlookup, ht, &client, &cred, &cache_status)) == NULL) { LogTest( "Error: can't lookup"); exit(1); } if(cache_entry_lookup3 != cache_entry_lookup4) { LogTest("Error: lookup results should be the same"); exit(1); } /* A lookup in the root fsal */ if((FSAL_IS_ERROR(status = FSAL_str2name("SunOS_5", 10, &name)))) { LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor); exit(1); } cache_inode_print_dir(cache_entry_root); /* Test readdir */ if(cache_inode_readdir(cache_entry_root, 0, 100, &nbfound, &eod_met, dirent_array, ht, &client, &cred, &cache_status) != CACHE_INODE_SUCCESS) { LogTest( "Error: cache_inode_readdir failed"); exit(1); } LogTest( "Readdir nbfound=%d, eod_met=%d", nbfound, eod_met); for(i = 0; i < nbfound; i++) LogTest( "dirent_array[%d] ==> %s | %p", i, dirent_array[i].name.name, dirent_array[i].pentry); cache_inode_print_dir(cache_entry_root); /* looping on readir */ LogTest( "Loop directory in several pass"); eod_met = TO_BE_CONTINUED; begin_cookie = 0; do { if(cache_inode_readdir(cache_entry_root, begin_cookie, 2, &nbfound, &eod_met, dirent_array_loop, ht, &client, &cred, &cache_status) != CACHE_INODE_SUCCESS) { LogTest("Error: cache_inode_readdir failed: %d", cache_status); exit(1); } for(i = 0; i < nbfound; i++) LogTest( " ==> %s | %p", dirent_array_loop[i].name.name, dirent_array_loop[i].pentry); begin_cookie += nbfound; } while(eod_met == TO_BE_CONTINUED); LogTest( "---------------------------------"); /* A lookup in the root fsal */ if((FSAL_IS_ERROR(status = FSAL_str2name("cea", 10, &name)))) { LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor); exit(1); } if((cache_entry_lookup = cache_inode_lookup(cache_entry_root, &name, &attrlookup, ht, &client, &cred, &cache_status)) == NULL) { LogTest( "Error: can't lookup"); exit(1); } /* A lookup in the root fsal */ if((FSAL_IS_ERROR(status = FSAL_str2name("log", 10, &name)))) { LogError(COMPONENT_STDOUT,ERR_FSAL, status.major, status.minor); exit(1); } if((cache_entry_lookup = cache_inode_lookup(cache_entry_root, &name, &attrlookup, ht, &client, &cred, &cache_status)) == NULL) { LogTest( "Error: can't lookup"); exit(1); } /* Print the Hash Table */ HashTable_Log(COMPONENT_STDOUT, ht); #ifdef _ADDITIONAL_TEST /* Trying to lookup from a DIR_CONTINUE */ fsdata.handle = cache_entry_root->object.dir_begin.handle; fsdata.cookie = 3 * CHILDREN_ARRAY_SIZE; LogTest("Input key: (Handle=%p, Cookie=%d)", fsdata.handle, fsdata.cookie); /* Turn the input to a hash key */ if(cache_inode_fsaldata_2_key(&key, &fsdata, NULL)) { LogTest( "Impossible to allocate a key to that value"); exit(1); } if(HashTable_Get(ht, &key, &value) != HASHTABLE_SUCCESS) { LogTest( "Key could not be found"); exit(1); } /* pentry for the dir cont */ cache_entry_dircont = (cache_entry_t *) value.pdata; /* Test readdir */ if(cache_inode_readdir(cache_entry_dircont, fsdata.cookie, 100, &nbfound, &eod_met, dirent_array, ht, &client, &cred, &cache_status) != CACHE_INODE_SUCCESS) { LogTest( "Error: cache_inode_readdir failed"); exit(1); } #endif LogTest( "Readdir nbfound=%d, eod_met=%d", nbfound, eod_met); for(i = 0; i < nbfound; i++) LogTest( "dirent_array[%d] ==> %s | %p ", i, dirent_array[i].name.name, dirent_array[i].pentry); /* Call the GC */ LogTest( "Sleeping %d second before gc (for gc invalidation)", gcpol.file_expiration_delay + 2); sleep(gcpol.file_expiration_delay + 2); if(cache_inode_gc(ht, &client, &cache_status) != CACHE_INODE_SUCCESS) { LogTest( "Error: cache_inode_gc failed"); exit(1); } LogTest( "GC performed successfully"); /* Print the Hash Table */ HashTable_Log(COMPONENT_STDOUT, ht); /* Another readdir, after gc is made */ eod_met = TO_BE_CONTINUED; begin_cookie = 0; LogTest( "ANOTHER READDIR AFTER GC"); do { if(cache_inode_readdir(cache_entry_root, begin_cookie, 2, &nbfound, &eod_met, dirent_array_loop, ht, &client, &cred, &cache_status) != CACHE_INODE_SUCCESS) { LogTest("Error: cache_inode_readdir failed: %d", cache_status); exit(1); } for(i = 0; i < nbfound; i++) LogTest( " ==> %s | %p", dirent_array_loop[i].name.name, dirent_array_loop[i].pentry); begin_cookie += nbfound; } while(eod_met == TO_BE_CONTINUED); LogTest( "---------------------------------"); /* Print the Hash Table */ HashTable_Log(COMPONENT_STDOUT, ht); LogTest( "---------------------------------"); /* The end of all the tests */ LogTest( "All tests exited successfully"); exit(0); } /* main */
int main(int argc, char *argv[]) { if (argc >= 2) { /* TEST 1 Standard */ if (!strcmp(argv[1], "STD")) { char *str = "No extra string provided"; char *file = NULL; if (argc >= 3) str = argv[2]; if (argc >= 4) file = argv[3]; SetNamePgm("test_liblog"); SetNameHost("localhost"); SetDefaultLogging("TEST"); InitLogging(); AddFamilyError(ERR_POSIX, "POSIX Errors", tab_systeme_status); LogTest("AddFamilyError = %d", AddFamilyError(ERR_DUMMY, "Family Dummy", tab_test_err)); LogTest("The family which was added is %s", ReturnNameFamilyError(ERR_DUMMY)); run_Tests(true, "monothread", str, file); } /* TEST 1 multithread */ else if (!strcmp(argv[1], "MT")) { /* multithread test */ pthread_attr_t th_attr[NB_THREADS]; pthread_t threads[NB_THREADS]; int th_index, i; void *result; SetNamePgm("test_liblog"); SetNameHost("localhost"); SetDefaultLogging("STDOUT"); InitLogging(); AddFamilyError(ERR_POSIX, "POSIX Errors", tab_systeme_status); LogTest("AddFamilyError = %d", AddFamilyError(ERR_DUMMY, "Family Dummy", tab_test_err)); LogTest("The family which was added is %s", ReturnNameFamilyError(ERR_DUMMY)); /* creation of attributes */ for (th_index = 0; th_index < NB_THREADS; th_index++) { pthread_attr_init(&th_attr[th_index]); pthread_attr_setdetachstate( &th_attr[th_index], PTHREAD_CREATE_JOINABLE); } /* creation of threads with their names */ for (i = 0; i < NB_THREADS; i++) { int rc; char *thread_name = gsh_malloc(256); snprintf(thread_name, 256, "thread %3d", i); rc = pthread_create(&(threads[i]), &th_attr[i], run_MT_Tests, (void *)thread_name); } /* waiting for threads termination */ for (i = 0; i < NB_THREADS; i++) { pthread_join(threads[i], &result); if (result) return 1; } return 0; } /* unknown test */ else { fprintf(stderr, "%s", usage); exit(1); } } else { fprintf(stderr, "%s", usage); exit(1); } return 0; }
int main(int argc, char **argv) { char localmachine[256]; char *test; fsal_parameter_t init_param; fsal_status_t st; uid_t uid; fsal_export_context_t export_ctx; fsal_op_context_t op_ctx; fsal_handle_t root_handle, handle; fsal_name_t name; fsal_path_t path; fsal_attrib_list_t attribs; fsal_attrib_mask_t mask; char tracebuff[256]; if(argc < 2) { usage(); exit(-1); } test = argv[1]; /* retrieving params */ #ifndef _NO_BUDDY_SYSTEM BuddyInit(NULL); #endif /* init debug */ SetNamePgm("test_fsal"); SetDefaultLogging("TEST"); SetNameFunction("main"); InitLogging(); /* Obtention du nom de la machine */ if(gethostname(localmachine, sizeof(localmachine)) != 0) { LogError(COMPONENT_STDOUT,ERR_SYS, ERR_GETHOSTNAME, errno); exit(1); } else SetNameHost(localmachine); AddFamilyError(ERR_FSAL, "FSAL related Errors", tab_errstatus_FSAL); /* prepare fsal_init */ /* 1 - fs specific info */ #ifdef _USE_HPSS_51 init_param.fs_specific_info.behaviors.PrincipalName = FSAL_INIT_FORCE_VALUE; strcpy(init_param.fs_specific_info.hpss_config.PrincipalName, "hpss_nfs"); init_param.fs_specific_info.behaviors.KeytabPath = FSAL_INIT_FORCE_VALUE; strcpy(init_param.fs_specific_info.hpss_config.KeytabPath, "/krb5/hpssserver.keytab"); #elif defined _USE_HPSS_62 init_param.fs_specific_info.behaviors.AuthnMech = FSAL_INIT_FORCE_VALUE; init_param.fs_specific_info.hpss_config.AuthnMech = hpss_authn_mech_krb5; init_param.fs_specific_info.behaviors.Principal = FSAL_INIT_FORCE_VALUE; strcpy(init_param.fs_specific_info.Principal, "hpssfs"); init_param.fs_specific_info.behaviors.KeytabPath = FSAL_INIT_FORCE_VALUE; strcpy(init_param.fs_specific_info.KeytabPath, "/var/hpss/etc/hpss.keytab"); #endif /* 2-common info (default) */ FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxfilesize); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxlink); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxnamelen); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxpathlen); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, no_trunc); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, chown_restricted); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, case_insensitive); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, case_preserving); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, fh_expire_type); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, link_support); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, symlink_support); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, named_attr); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, unique_handles); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, lease_time); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, acl_support); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, cansettime); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, homogenous); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, supported_attrs); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxread); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxwrite); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, umask); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, auth_exportpath_xdev); /* 3- fsal info */ init_param.fsal_info.max_fs_calls = 0; /* Init */ if(FSAL_IS_ERROR(st = FSAL_Init(&init_param))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } /* getting creds */ uid = getuid(); LogTest("uid = %d", uid); st = FSAL_BuildExportContext(&export_ctx, NULL, NULL); if(FSAL_IS_ERROR(st)) LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); st = FSAL_InitClientContext(&op_ctx); if(FSAL_IS_ERROR(st)) LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); st = FSAL_GetClientContext(&op_ctx, &export_ctx, uid, -1, NULL, 0); if(FSAL_IS_ERROR(st)) LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); /* getting root handle */ if(FSAL_IS_ERROR(st = FSAL_lookup(NULL, NULL, &op_ctx, &root_handle, NULL))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } snprintHandle(tracebuff, 256, &root_handle); LogTest("Root handle = %s", tracebuff); /* getting what are the supported attributes */ attribs.asked_attributes = 0; FSAL_SET_MASK(attribs.asked_attributes, FSAL_ATTR_SUPPATTR); LogTest("asked attributes :"); printmask(attribs.asked_attributes); if(FSAL_IS_ERROR(st = ZFSFSAL_getattrs(&root_handle, &op_ctx, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } LogTest("supported attributes :"); printmask(attribs.supported_attributes); mask = attribs.supported_attributes; /* TEST 1 */ if(test[0] == '1') { attribs.asked_attributes = 0; FSAL_SET_MASK(attribs.asked_attributes, FSAL_ATTR_SUPPATTR); LogTest("asked attributes :"); printmask(attribs.asked_attributes); if(FSAL_IS_ERROR(st = ZFSFSAL_getattrs(&root_handle, &op_ctx, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } LogTest("supported attributes :"); /* getting all spported attributes of root */ attribs.asked_attributes = mask; if(FSAL_IS_ERROR(st = ZFSFSAL_getattrs(&root_handle, &op_ctx, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } printattributes(attribs); } else /* TEST 2 */ if(test[0] == '2') { /* getting handle and attributes for subdirectory "OSF1_V5" */ if(FSAL_IS_ERROR(st = FSAL_str2name("cea", 4, &name))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } attribs.asked_attributes = mask; if(FSAL_IS_ERROR(st = FSAL_lookup(&root_handle, &name, &op_ctx, &handle, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } snprintHandle(tracebuff, 256, &handle); LogTest("/cea handle = %s", tracebuff); /* displaying attributes */ printattributes(attribs); /* getting handle and attributes for subdirectory "bin" */ if(FSAL_IS_ERROR(st = FSAL_str2name("prot", 5, &name))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } root_handle = handle; attribs.asked_attributes = mask; if(FSAL_IS_ERROR(st = FSAL_lookup(&root_handle, &name, &op_ctx, &handle, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } snprintHandle(tracebuff, 256, &handle); LogTest("/cea/prot handle = %s", tracebuff); /* displaying attributes */ printattributes(attribs); /* getting handle and attributes for symlink "AglaePwrSW" */ if(FSAL_IS_ERROR(st = FSAL_str2name("lama", 5, &name))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } root_handle = handle; attribs.asked_attributes = mask; if(FSAL_IS_ERROR(st = FSAL_lookup(&root_handle, &name, &op_ctx, &handle, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } snprintHandle(tracebuff, 256, &handle); LogTest("/cea/prot/lama handle = %s", tracebuff); /* displaying attributes */ printattributes(attribs); } else /* TEST 3 */ if(test[0] == '3') { /* lookup root */ if(FSAL_IS_ERROR(st = FSAL_str2path("/", 30, &path))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } attribs.asked_attributes = mask; if(FSAL_IS_ERROR(st = FSAL_lookupPath(&path, &op_ctx, &handle, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } snprintHandle(tracebuff, 256, &handle); LogTest("/ handle = %s", tracebuff); /* displaying attributes */ printattributes(attribs); /* lookup path */ if(FSAL_IS_ERROR(st = FSAL_str2path("/cea/prot/lama", 15, &path))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } attribs.asked_attributes = mask; if(FSAL_IS_ERROR(st = FSAL_lookupPath(&path, &op_ctx, &handle, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } snprintHandle(tracebuff, 256, &handle); LogTest("/cea/prot/lama handle = %s", tracebuff); /* displaying attributes */ printattributes(attribs); } else /* TEST 4 */ if(test[0] == '4') { /* readdir on root */ fsal_dir_t dir; fsal_cookie_t from, to; fsal_dirent_t entries[READDIR_SIZE]; fsal_count_t number; fsal_boolean_t eod = FALSE; int error = FALSE; attribs.asked_attributes = mask; if(FSAL_IS_ERROR(st = FSAL_opendir(&root_handle, &op_ctx, &dir, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } LogTest("'/' attributes :"); /* displaying attributes */ printattributes(attribs); from = FSAL_READDIR_FROM_BEGINNING; while(!error && !eod) { unsigned int i; char cookiebuff[256]; snprintCookie(cookiebuff, 256, &from); LogTest("\nReaddir cookie = %s", cookiebuff); if(FSAL_IS_ERROR(st = FSAL_readdir(&dir, from, mask, READDIR_SIZE * sizeof(fsal_dirent_t), entries, &to, &number, &eod))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); error = TRUE; } for(i = 0; (!error) && (i < number); i++) { snprintHandle(tracebuff, 256, &entries[i].handle); snprintCookie(cookiebuff, 256, &entries[i].cookie); LogTest("\t%s : %s (cookie %s)", tracebuff, entries[i].name.name, cookiebuff); } /* preparing next call */ from = to; } LogTest("Fin de boucle : error=%d ; eod=%d", error, eod); } else /* TEST 5 */ if(test[0] == '5') { /* readdir on root */ fsal_dir_t dir; fsal_cookie_t from, to; fsal_dirent_t entries[READDIR_SIZE]; fsal_count_t number; fsal_boolean_t eod = FALSE; int error = FALSE; attribs.asked_attributes = mask; if(FSAL_IS_ERROR(st = FSAL_opendir(&root_handle, &op_ctx, &dir, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } LogTest("'/' attributes :"); /* displaying attributes */ printattributes(attribs); from = FSAL_READDIR_FROM_BEGINNING; while(!error && !eod) { fsal_dirent_t *curr; char cookiebuff[256]; snprintCookie(cookiebuff, 256, &from); LogTest("\nReaddir cookie = %s", cookiebuff); if(FSAL_IS_ERROR(st = FSAL_readdir(&dir, from, mask, READDIR_SIZE * sizeof(fsal_dirent_t), entries, &to, &number, &eod))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); error = TRUE; } if(number > 0) { curr = entries; do { snprintHandle(tracebuff, 256, &curr->handle); snprintCookie(cookiebuff, 256, &curr->cookie); LogTest("\t%s : %s (cookie %s)", tracebuff, curr->name.name, cookiebuff); } while(curr = curr->nextentry); } /* preparing next call */ from = to; } LogTest("Fin de boucle : error=%d ; eod=%d", error, eod); } else /* TEST 6 */ if(test[0] == '6') { /* readdir on root */ fsal_dir_t dir; fsal_cookie_t from, to; fsal_dirent_t entries[READDIR_SIZE]; fsal_count_t number; fsal_boolean_t eod = FALSE; int error = FALSE; attribs.asked_attributes = mask; if(FSAL_IS_ERROR(st = FSAL_opendir(&root_handle, &op_ctx, &dir, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } LogTest("'/' attributes :"); /* displaying attributes */ printattributes(attribs); from = FSAL_READDIR_FROM_BEGINNING; while(!error && !eod) { unsigned int i; snprintCookie(tracebuff, 256, &from); LogTest("\nReaddir cookie = %s", tracebuff); st = FSAL_readdir(&dir, from, mask, READDIR_SIZE * sizeof(fsal_dirent_t), entries, &to, &number, &eod); if(FSAL_IS_ERROR(st)) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); error = TRUE; } /* for each entry, we compare the result of FSAL_access * to FSAL_test_access. */ for(i = 0; (!error) && (i < number); i++) { fsal_status_t st1, st2; char cookiebuff[256]; snprintHandle(tracebuff, 256, &entries[i].handle); snprintCookie(cookiebuff, 256, &entries[i].cookie); LogTest("\t%s : %s (cookie %s)", tracebuff, entries[i].name.name, cookiebuff); if(FSAL_IS_ERROR(st = ZFSFSAL_getattrs(&entries[i].handle, &op_ctx, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } /* 1 - test R access */ st1 = FSAL_access(&entries[i].handle, &op_ctx, FSAL_R_OK, NULL); st2 = FSAL_test_access(&op_ctx, FSAL_R_OK, &attribs); LogError(COMPONENT_STDOUT, ERR_FSAL, st1.major, st1.minor); LogError(COMPONENT_STDOUT, ERR_FSAL, st2.major, st2.minor); if(st1.major != st2.major) { LogTest ("Error : different access permissions given by FSAL_access and FSAL_test_access : %d <>%d", st1.major, st2.major); } /* 2 - test W access */ st1 = FSAL_access(&entries[i].handle, &op_ctx, FSAL_W_OK, NULL); st2 = FSAL_test_access(&op_ctx, FSAL_W_OK, &attribs); LogError(COMPONENT_STDOUT, ERR_FSAL, st1.major, st1.minor); LogError(COMPONENT_STDOUT, ERR_FSAL, st2.major, st2.minor); if(st1.major != st2.major) { LogTest ("Error : different access permissions given by FSAL_access and FSAL_test_access : %d <>%d", st1.major, st2.major); } /* 3 - test X access */ st1 = FSAL_access(&entries[i].handle, &op_ctx, FSAL_X_OK, NULL); st2 = FSAL_test_access(&op_ctx, FSAL_X_OK, &attribs); LogError(COMPONENT_STDOUT, ERR_FSAL, st1.major, st1.minor); LogError(COMPONENT_STDOUT, ERR_FSAL, st2.major, st2.minor); if(st1.major != st2.major) { LogTest ("Error : different access permissions given by FSAL_access and FSAL_test_access : %d <>%d", st1.major, st2.major); } } /* preparing next call */ from = to; } LogTest("Fin de boucle : error=%d ; eod=%d", error, eod); } else /* TEST 7 */ if(test[0] == '7') { /* test snprintmem and sscanmem */ char test_string[] = "Ceci est une chaine d'essai.\nLes chiffres : 0123456789\nLes lettres : ABCDEFGHIJKLMNOPQRSTUVWXYZ"; char buffer[256]; char string[200]; /* 200 suffit car test_string fait <100 */ int size1, size2, size3, i; /* we put bad values in string, to see if it is correctly set. */ for(i = 0; i < 200; i++) string[i] = (char)i; LogTest("Initial data (%d Bytes) = <<%s>>", strlen(test_string), test_string); /* Write test_string to a buffer. */ /* We don't give the final '\0'. */ snprintmem(buffer, 256, test_string, strlen(test_string)); LogTest("Dest_Buffer (%d Bytes) = <<%s>>", strlen(buffer), buffer); /* read the value from the buffer */ sscanmem(string, strlen(test_string), buffer); /* sets the final 0 to print the content of the buffer */ LogTest("Retrieved string : following byte = %d", (int)string[strlen(test_string)]); string[strlen(test_string)] = '\0'; LogTest("Retrieved string (%d Bytes) = <<%s>>", strlen(string), string); /* Automatic tests : */ size1 = strlen(test_string); size2 = strlen(buffer); size3 = strlen(string); LogTest("-------------------------------------"); if(size1 <= 0) LogTest("***** ERROR: source size=0 !!!"); if(size1 != size3) LogTest("***** ERROR: source size <> target size"); else LogTest("OK: source size = target size"); if((size1 * 2) != size2) LogTest("***** ERROR: hexa size <> 2 * source size"); else LogTest("OK: hexa size = 2 * source size"); if(strcmp(test_string, string)) LogTest("***** ERROR: source string <> target string"); else LogTest("OK: source string = target string"); } else /* TEST 8 */ if(test[0] == '8') { fsal_handle_t dir_hdl, subdir_hdl; fsal_name_t subdir_name; /* lookup on /cea/prot/S/lama/s8/leibovic */ if(FSAL_IS_ERROR(st = FSAL_str2path("/cea/prot/S/lama/s8/leibovic", 40, &path))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } attribs.asked_attributes = mask; if(FSAL_IS_ERROR(st = FSAL_lookupPath(&path, &op_ctx, &handle, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } snprintHandle(tracebuff, 256, &handle); LogTest("/cea/prot/S/lama/s8/leibovic: handle = %s", tracebuff); sleep(1); /* creates a directory */ LogTest("------- Create a directory -------"); if(FSAL_IS_ERROR(st = FSAL_str2name("tests_GANESHA", 30, &name))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } attribs.asked_attributes = mask; if(FSAL_IS_ERROR(st = FSAL_mkdir(&handle, &name, &op_ctx, FSAL_MODE_RUSR | FSAL_MODE_WUSR | FSAL_MODE_XUSR | FSAL_MODE_RGRP | FSAL_MODE_WGRP, &dir_hdl, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } else { snprintHandle(tracebuff, 256, &dir_hdl); LogTest("newly created dir handle = %s", tracebuff); printattributes(attribs); } sleep(1); /* Try to create it again */ LogTest("------- Try to create it again -------"); if(FSAL_IS_ERROR(st = FSAL_mkdir(&handle, &name, &op_ctx, FSAL_MODE_RUSR | FSAL_MODE_WUSR | FSAL_MODE_XUSR | FSAL_MODE_RGRP | FSAL_MODE_WGRP, &dir_hdl, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } else { LogTest("**** Error: FSAL should have returned ERR_FSAL_EXIST"); } sleep(1); /* creates a subdirectory */ LogTest("------- Create a subdirectory -------"); if(FSAL_IS_ERROR(st = FSAL_str2name("subdir_GANESHA", 30, &subdir_name))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } if(FSAL_IS_ERROR(st = FSAL_mkdir(&dir_hdl, &subdir_name, &op_ctx, FSAL_MODE_RUSR | FSAL_MODE_WUSR | FSAL_MODE_XUSR | FSAL_MODE_RGRP | FSAL_MODE_WGRP, &subdir_hdl, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } else { snprintHandle(tracebuff, 256, &subdir_hdl); LogTest("newly created subdir handle = %s", tracebuff); printattributes(attribs); } /* try to removes the parent directory */ LogTest("------- Try to removes the parent directory -------"); if(FSAL_IS_ERROR(st = FSAL_unlink(&handle, &name, &op_ctx, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } else { LogTest("FSAL should not have unlinked %s because it is not empty", name.name); } sleep(1); /* removes the subdirectory */ LogTest("------- Removes the subdirectory -------"); if(FSAL_IS_ERROR(st = FSAL_unlink(&dir_hdl, &subdir_name, &op_ctx, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } else { LogTest("New attributes for parent directory:"); printattributes(attribs); } /* removes the parent directory */ LogTest("------- Removes the parent directory -------"); if(FSAL_IS_ERROR(st = FSAL_unlink(&handle, &name, &op_ctx, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } else { LogTest("Unlink %s OK", name.name); } } /* TEST 9 */ else if(test[0] == '9') { fsal_handle_t dir_hdl, subdir_hdl; fsal_name_t subdir_name; fsal_attrib_list_t attr_set; fsal_fsid_t set_fsid = { 1LL, 2LL }; #ifdef _LINUX struct tm jour_heure = { 56, 34, 12, 31, 12, 110, 0, 0, 0, 0, 0 }; #else struct tm jour_heure = { 56, 34, 12, 31, 12, 110, 0, 0, 0 }; #endif /* lookup on /cea/prot/S/lama/s8/leibovic */ if(FSAL_IS_ERROR(st = FSAL_str2path("/cea/prot/S/lama/s8/leibovic", 40, &path))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } attribs.asked_attributes = mask; if(FSAL_IS_ERROR(st = FSAL_lookupPath(&path, &op_ctx, &handle, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } snprintHandle(tracebuff, 256, &handle); LogTest("/cea/prot/S/lama/s8/leibovic: handle = %s", tracebuff); sleep(1); /* creates a file */ LogTest("------- Create a file -------"); if(FSAL_IS_ERROR(st = FSAL_str2name("tests_GANESHA_setattrs", 30, &name))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } attribs.asked_attributes = mask; if(FSAL_IS_ERROR(st = FSAL_create(&handle, &name, &op_ctx, FSAL_MODE_RUSR | FSAL_MODE_WUSR | FSAL_MODE_XUSR | FSAL_MODE_RGRP | FSAL_MODE_WGRP, &dir_hdl, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } else { snprintHandle(tracebuff, 256, &dir_hdl); LogTest("newly created file handle = %s", tracebuff); printattributes(attribs); } sleep(1); LogTest("------- Try to change its attributes -------"); /* Macro that try to change the value for an attribute */ #define CHANGE_ATTRS( str_nom, nom, flag, new_val ) do {\ memset(&attr_set, 0, sizeof(fsal_attrib_list_t) ); \ LogTest("\nTry to change '%s' :",str_nom); \ FSAL_SET_MASK( attr_set.asked_attributes , flag ); \ attr_set.nom = new_val; \ attribs.asked_attributes = attr_set.asked_attributes; \ /* attribs.asked_attributes = mask; */\ st = FSAL_setattrs( &dir_hdl, &op_ctx, &attr_set, &attribs );\ if ( FSAL_IS_ERROR(st) ) \ LogError(COMPONENT_STDOUT,ERR_FSAL,st.major,st.minor);\ else \ printattributes( attribs ); \ } while(0) CHANGE_ATTRS("supported_attributes", supported_attributes, FSAL_ATTR_SUPPATTR, FSAL_ATTRS_MANDATORY); CHANGE_ATTRS("type", type, FSAL_ATTR_TYPE, FSAL_TYPE_LNK); sleep(1); /* to see mtime modification by truncate */ CHANGE_ATTRS("filesize", filesize, FSAL_ATTR_SIZE, (fsal_size_t) 12); sleep(1); /* to see mtime modification by truncate */ CHANGE_ATTRS("fsid", fsid, FSAL_ATTR_FSID, set_fsid); /* @todo : ACLs */ CHANGE_ATTRS("fileid", fileid, FSAL_ATTR_FILEID, (fsal_u64_t) 1234); CHANGE_ATTRS("mode", mode, FSAL_ATTR_MODE, (FSAL_MODE_RUSR | FSAL_MODE_WUSR | FSAL_MODE_RGRP)); CHANGE_ATTRS("numlinks", numlinks, FSAL_ATTR_NUMLINKS, 7); /* FSAL_ATTR_RAWDEV */ CHANGE_ATTRS("atime", atime.seconds, FSAL_ATTR_ATIME, mktime(&jour_heure)); jour_heure.tm_min++; CHANGE_ATTRS("creation", creation.seconds, FSAL_ATTR_CREATION, mktime(&jour_heure)); jour_heure.tm_min++; CHANGE_ATTRS("mtime", mtime.seconds, FSAL_ATTR_MTIME, mktime(&jour_heure)); jour_heure.tm_min++; CHANGE_ATTRS("ctime", ctime.seconds, FSAL_ATTR_CTIME, mktime(&jour_heure)); CHANGE_ATTRS("spaceused", spaceused, FSAL_ATTR_SPACEUSED, (fsal_size_t) 12345); CHANGE_ATTRS("mounted_on_fileid", mounted_on_fileid, FSAL_ATTR_MOUNTFILEID, (fsal_u64_t) 3210); CHANGE_ATTRS("owner", owner, FSAL_ATTR_OWNER, 3051); /* deniel */ CHANGE_ATTRS("group", group, FSAL_ATTR_GROUP, 5953); /* sr */ sleep(1); /* removes the parent directory */ LogTest("------- Removes the directory -------"); if(FSAL_IS_ERROR(st = FSAL_unlink(&handle, &name, &op_ctx, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } else { LogTest("Unlink %s OK", name.name); } } else if(test[0] == 'A') { char digest_buff[FSAL_DIGEST_SIZE_HDLV3]; /* lookup on /cea/prot/S/lama/s8/leibovic */ if(FSAL_IS_ERROR(st = FSAL_str2path("/cea/prot/S/lama/s8/leibovic", 40, &path))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } attribs.asked_attributes = mask; if(FSAL_IS_ERROR(st = FSAL_lookupPath(&path, &op_ctx, &handle, &attribs))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } snprintHandle(tracebuff, 256, &handle); LogTest("/cea/prot/S/lama/s8/leibovic: handle = %s", tracebuff); /* building digest */ st = FSAL_DigestHandle(&export_ctx, FSAL_DIGEST_NFSV3, &handle, digest_buff); if(FSAL_IS_ERROR(st)) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } else { /* print digest */ snprintmem(tracebuff, 256, digest_buff, FSAL_DIGEST_SIZE_HDLV3); LogTest("/cea/prot/S/lama/s8/leibovic: handle_digest = %s", tracebuff); } memset(&handle, 0, sizeof(fsal_handle_t)); /* expend digest */ st = FSAL_ExpandHandle(&export_ctx, FSAL_DIGEST_NFSV3, digest_buff, &handle); if(FSAL_IS_ERROR(st)) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); } else { /* print expended handle */ snprintHandle(tracebuff, 256, &handle); LogTest("/cea/prot/S/lama/s8/leibovic: handle expended = %s", tracebuff); } } else if(test[0] == 'B') { fsal_dynamicfsinfo_t dyninfo; if(FSAL_IS_ERROR(st = FSAL_dynamic_fsinfo(&root_handle, &op_ctx, &dyninfo))) { LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor); exit(st.major); } LogTest("total_bytes = %llu", dyninfo.total_bytes); LogTest("free_bytes = %llu", dyninfo.free_bytes); LogTest("avail_bytes = %llu", dyninfo.avail_bytes); LogTest("total_files = %llu", dyninfo.total_files); LogTest("free_files = %llu", dyninfo.free_files); LogTest("avail_files = %llu", dyninfo.avail_files); LogTest("time_delta = %u.%u", dyninfo.time_delta.seconds, dyninfo.time_delta.nseconds); } else LogTest("%s : test inconnu", test); return 0; }
main(int argc, char *argv[]) { char localmachine[256]; cache_inode_client_t client; LRU_parameter_t lru_param; LRU_status_t lru_status; cache_inode_fsal_data_t fsdata; fsal_status_t status; fsal_parameter_t init_param; fsal_name_t name; fsal_path_t path; fsal_attrib_mask_t mask; fsal_path_t pathroot; fsal_attrib_list_t attribs; fsal_handle_t root_handle; cache_inode_endofdir_t eod_met; cache_inode_dir_entry_t dirent_array[100]; cache_inode_dir_entry_t dirent_array_loop[5]; unsigned int nbfound; unsigned int begin_cookie = 0; hash_buffer_t key, value; uid_t uid; fsal_cred_t cred; cache_inode_status_t cache_status; cache_inode_parameter_t cache_param; cache_inode_client_parameter_t cache_client_param; hash_table_t *ht = NULL; fsal_attrib_list_t attrlookup; cache_entry_t *cache_entry_root = NULL; cache_entry_t *cache_entry_lookup = NULL; cache_entry_t *cache_entry_lookup2 = NULL; cache_entry_t *cache_entry_lookup3 = NULL; cache_entry_t *cache_entry_lookup4 = NULL; cache_entry_t *cache_entry_lookup5 = NULL; cache_entry_t *cache_entry_lookup6 = NULL; cache_entry_t *cache_entry_dircont = NULL; cache_inode_gc_policy_t gcpol; char *configfile = argv[1]; int i = 0; int rc = 0; /* Init the Buddy System allocation */ if((rc = BuddyInit(NULL)) != BUDDY_SUCCESS) { LogTest("Error while initializing Buddy system allocator"); exit(1); } /* init debug */ SetNamePgm("test_cache_inode"); SetDefaultLogging("TEST"); SetNameFunction("main"); InitLogging(); #if defined( _USE_GHOSTFS ) if(argc != 2) { LogTest("Please set the configuration file as parameter"); exit(1); } #endif /* Obtention du nom de la machine */ if(gethostname(localmachine, sizeof(localmachine)) != 0) { LogError(COMPONENT_STDOUT, ERR_SYS, ERR_GETHOSTNAME, errno); exit(1); } else SetNameHost(localmachine); AddFamilyError(ERR_FSAL, "FSAL related Errors", tab_errstatus_FSAL); AddFamilyError(ERR_CACHE_INODE, "FSAL related Errors", tab_errstatus_cache_inode); LogTest( "Starting the test"); LogTest( "-----------------"); #if defined( _USE_GHOSTFS ) if(FSAL_IS_ERROR(status = FSAL_str2path(configfile, strlen(configfile) + 1, &(init_param.fs_specific_info. definition_file)))) { LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor); } #elif defined( _USE_HPSS ) FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, Flags); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DebugValue); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, TransferType); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, NumRetries); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, BusyDelay); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, BusyRetries); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, TotalDelay); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, GKTotalDelay); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, LimitedRetries); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, MaxConnections); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, ReuseDataConnections); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, UsePortRange); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, RetryStageInp); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DMAPWriteUpdates); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, ServerName); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DescName); init_param.fs_specific_info.behaviors.PrincipalName = FSAL_INIT_FORCE_VALUE; strncpy(init_param.fs_specific_info.hpss_config.PrincipalName, HPSS_SSM, HPSS_MAX_PRINCIPAL_NAME); init_param.fs_specific_info.behaviors.KeytabPath = FSAL_INIT_FORCE_VALUE; strncpy(init_param.fs_specific_info.hpss_config.KeytabPath, HPSS_KEYTAB, HPSS_MAX_PATH_NAME); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, DebugPath); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, HostName); FSAL_SET_INIT_DEFAULT(init_param.fs_specific_info, RegistrySiteName); #endif /* 2-common info (default) */ FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxfilesize); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxlink); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxnamelen); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxpathlen); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, no_trunc); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, chown_restricted); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, case_insensitive); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, case_preserving); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, fh_expire_type); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, link_support); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, symlink_support); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, named_attr); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, unique_handles); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, lease_time); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, acl_support); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, cansettime); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, homogenous); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxread); FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxwrite); /* Init */ if(FSAL_IS_ERROR(status = FSAL_Init(&init_param))) { LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor); } /* getting creds */ uid = getuid(); if(FSAL_IS_ERROR(status = FSAL_GetUserCred(uid, NULL, &cred))) { LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor); } /* Init of the cache inode module */ cache_param.hparam.index_size = 31; cache_param.hparam.alphabet_length = 10; /* Buffer seen as a decimal polynom */ cache_param.hparam.nb_node_prealloc = 100; cache_param.hparam.hash_func_key = cache_inode_fsal_hash_func; cache_param.hparam.hash_func_rbt = cache_inode_fsal_rbt_func; cache_param.hparam.hash_func_both = NULL ; /* BUGAZOMEU */ cache_param.hparam.compare_key = cache_inode_compare_key_fsal; cache_param.hparam.key_to_str = display_key; cache_param.hparam.val_to_str = display_value; if((ht = cache_inode_init(cache_param, &cache_status)) == NULL) { LogTest( "Error %d while init hash ", cache_status); } else LogTest( "Hash Table address = %p", ht); /* We need a cache_client to acces the cache */ cache_client_param.attrmask = FSAL_ATTRS_MANDATORY | FSAL_ATTR_MTIME | FSAL_ATTR_CTIME | FSAL_ATTR_ATIME; cache_client_param.nb_prealloc_entry = 1000; cache_client_param.nb_pre_dir_data = 200; cache_client_param.nb_pre_parent = 1200; cache_client_param.nb_pre_state_v4 = 100; cache_client_param.lru_param.nb_entry_prealloc = 1000; cache_client_param.lru_param.entry_to_str = lru_entry_to_str; cache_client_param.lru_param.clean_entry = lru_clean_entry; cache_client_param.grace_period_attr = 0; cache_client_param.grace_period_link = 0; cache_client_param.grace_period_dirent = 0; cache_client_param.expire_type_attr = CACHE_INODE_EXPIRE_NEVER; cache_client_param.expire_type_link = CACHE_INODE_EXPIRE_NEVER; cache_client_param.expire_type_dirent = CACHE_INODE_EXPIRE_NEVER; /* Init the cache_inode client */ if(cache_inode_client_init(&client, cache_client_param, 0) != 0) exit(1); /* Getting the root of the FS */ if((FSAL_IS_ERROR(status = FSAL_str2path("/", 2, &pathroot)))) { LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor); exit(1); } attribs.asked_attributes = cache_client_param.attrmask; if((FSAL_IS_ERROR(status = FSAL_lookupPath(pathroot, &cred, &root_handle, &attribs)))) { LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor); exit(1); } fsdata.cookie = 0; fsdata.handle = root_handle; /* Cache the root of the FS */ if((cache_entry_root = cache_inode_make_root(&fsdata, 1, ht, &client, &cred, &cache_status)) == NULL) { LogTest( "Error: can't init fs's root"); exit(1); } /* A lookup in the root fsal */ if((FSAL_IS_ERROR(status = FSAL_str2name("cea", 10, &name)))) { LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor); exit(1); } if((cache_entry_lookup = cache_inode_lookup(cache_entry_root, name, &attrlookup, ht, &client, &cred, &cache_status)) == NULL) { LogTest( "Error: can't lookup"); exit(1); } /* Lookup a second time (entry should now be cached) */ if((cache_entry_lookup2 = cache_inode_lookup(cache_entry_root, name, &attrlookup, ht, &client, &cred, &cache_status)) == NULL) { LogTest( "Error: can't lookup"); exit(1); } if(cache_entry_lookup2 != cache_entry_lookup) { LogTest("Error: lookup results should be the same"); exit(1); } /* A lookup in the root fsal */ if((FSAL_IS_ERROR(status = FSAL_str2name("log", 10, &name)))) { LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor); exit(1); } if((cache_entry_lookup3 = cache_inode_lookup(cache_entry_root, name, &attrlookup, ht, &client, &cred, &cache_status)) == NULL) { LogTest( "Error: can't lookup"); exit(1); } if((cache_entry_lookup4 = cache_inode_lookup(cache_entry_root, name, &attrlookup, ht, &client, &cred, &cache_status)) == NULL) { LogTest( "Error: can't lookup"); exit(1); } if(cache_entry_lookup3 != cache_entry_lookup4) { LogTest("Error: lookup results should be the same"); exit(1); } /* A lookup in the root fsal */ if((FSAL_IS_ERROR(status = FSAL_str2name("cea", 10, &name)))) { LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor); exit(1); } if((cache_entry_lookup = cache_inode_lookup(cache_entry_root, name, &attrlookup, ht, &client, &cred, &cache_status)) == NULL) { LogTest( "Error: can't lookup"); exit(1); } /* A lookup in the root fsal */ if((FSAL_IS_ERROR(status = FSAL_str2name("log", 10, &name)))) { LogError(COMPONENT_STDOUT, ERR_FSAL, status.major, status.minor); exit(1); } if((cache_entry_lookup = cache_inode_lookup(cache_entry_root, name, &attrlookup, ht, &client, &cred, &cache_status)) == NULL) { LogTest( "Error: can't lookup"); exit(1); } LogTest( "---------------------------------"); /* The end of all the tests */ LogTest( "All tests exited successfully"); exit(0); } /* main */
int main(int argc, char **argv) { unsigned int i; struct timeval tv1, tv2, tv3, tvdiff; int count, rc; char *dir; handle_map_param_t param; time_t now; /* Init logging */ SetNamePgm("test_handle_mapping"); SetDefaultLogging("TEST"); SetNameFunction("main"); SetNameHost("localhost"); InitLogging(); if(argc != 3 || (count = atoi(argv[2])) == 0) { LogTest("usage: test_handle_mapping <db_dir> <db_count>"); exit(1); } #ifndef _NO_BUDDY_SYSTEM if((rc = BuddyInit(NULL)) != BUDDY_SUCCESS) { /* Failed init */ LogCrit(COMPONENT_FSAL, "ERROR: Could not initialize memory manager"); exit(rc); } #endif dir = argv[1]; strcpy(param.databases_directory, dir); strcpy(param.temp_directory, "/tmp"); param.database_count = count; param.hashtable_size = 27; param.nb_handles_prealloc = 1024; param.nb_db_op_prealloc = 1024; param.synchronous_insert = FALSE; rc = HandleMap_Init(¶m); LogTest("HandleMap_Init() = %d", rc); if(rc) exit(rc); gettimeofday(&tv1, NULL); /* Now insert a set of handles */ now = time(NULL); for(i = 0; i < 10000; i++) { nfs23_map_handle_t nfs23_digest; fsal_handle_t handle; memset(&handle, i, sizeof(fsal_handle_t)); nfs23_digest.object_id = 12345 + i; nfs23_digest.handle_hash = (1999 * i + now) % 479001599; rc = HandleMap_SetFH(&nfs23_digest, &handle); if(rc && (rc != HANDLEMAP_EXISTS)) exit(rc); } gettimeofday(&tv2, NULL); timersub(&tv2, &tv1, &tvdiff); LogTest("%u threads inserted 10000 handles in %d.%06ds", count, (int)tvdiff.tv_sec, (int)tvdiff.tv_usec); /* Now get them ! */ for(i = 0; i < 10000; i++) { nfs23_map_handle_t nfs23_digest; fsal_handle_t handle; nfs23_digest.object_id = 12345 + i; nfs23_digest.handle_hash = (1999 * i + now) % 479001599; rc = HandleMap_GetFH(&nfs23_digest, &handle); if(rc) { LogTest("Error %d retrieving handle !", rc); exit(rc); } rc = HandleMap_DelFH(&nfs23_digest); if(rc) { LogTest("Error %d deleting handle !", rc); exit(rc); } } gettimeofday(&tv3, NULL); timersub(&tv3, &tv2, &tvdiff); LogTest("Retrieved and deleted 10000 handles in %d.%06ds", (int)tvdiff.tv_sec, (int)tvdiff.tv_usec); rc = HandleMap_Flush(); gettimeofday(&tv3, NULL); timersub(&tv3, &tv1, &tvdiff); LogTest("Total time with %u threads (including flush): %d.%06ds", count, (int)tvdiff.tv_sec, (int)tvdiff.tv_usec); exit(0); }
int main(int argc, char **argv) { unsigned int i; struct timeval tv1, tv2, tv3, tvdiff; int count, rc; char *dir; time_t now; if (argc != 3) { LogTest("usage: test_handle_mapping_db <db_dir> <db_count>"); exit(1); } count = atoi(argv[2]) if (count == 0) { LogTest("usage: test_handle_mapping_db <db_dir> <db_count>"); exit(1); } dir = argv[1]; /* Init logging */ SetNamePgm("test_handle_mapping"); SetNameFileLog("/dev/tty"); SetNameFunction("main"); SetNameHost("localhost"); /* count databases */ rc = handlemap_db_count(dir); LogTest("handlemap_db_count(%s)=%d", dir, rc); if (rc != 0 && count != rc) { LogTest( "Warning: incompatible thread count %d <> database count %d", count, rc); } rc = handlemap_db_init(dir, "/tmp", count, 1024, false); LogTest("handlemap_db_init() = %d", rc); if (rc) exit(rc); rc = handlemap_db_reaload_all(NULL); LogTest("handlemap_db_reaload_all() = %d", rc); if (rc) exit(rc); gettimeofday(&tv1, NULL); /* Now insert a set of handles */ now = time(NULL); for (i = 0; i < 10000; i++) { nfs23_map_handle_t nfs23_digest; fsal_handle_t handle; memset(&handle, i, sizeof(fsal_handle_t)); nfs23_digest.object_id = 12345 + i; nfs23_digest.handle_hash = (1999 * i + now) % 479001599; rc = handlemap_db_insert(&nfs23_digest, &handle); if (rc) exit(rc); } gettimeofday(&tv2, NULL); timersub(&tv2, &tv1, &tvdiff); LogTest("%u threads inserted 10000 handles in %d.%06ds", count, (int)tvdiff.tv_sec, (int)tvdiff.tv_usec); rc = handlemap_db_flush(); gettimeofday(&tv3, NULL); timersub(&tv3, &tv1, &tvdiff); LogTest("Total time with %u threads (including flush): %d.%06ds", count, (int)tvdiff.tv_sec, (int)tvdiff.tv_usec); LogTest("Now, delete operations"); for (i = 0; i < 10000; i++) { nfs23_map_handle_t nfs23_digest; nfs23_digest.object_id = 12345 + i; nfs23_digest.handle_hash = (1999 * i + now) % 479001599; rc = handlemap_db_delete(&nfs23_digest); if (rc) exit(rc); } gettimeofday(&tv2, NULL); timersub(&tv2, &tv3, &tvdiff); LogTest("%u threads deleted 10000 handles in %d.%06ds", count, (int)tvdiff.tv_sec, (int)tvdiff.tv_usec); rc = handlemap_db_flush(); gettimeofday(&tv1, NULL); timersub(&tv1, &tv3, &tvdiff); LogTest("Delete time with %u threads (including flush): %d.%06ds", count, (int)tvdiff.tv_sec, (int)tvdiff.tv_usec); exit(0); }