void test_cache() { /*---init HLFS with cache on by conf file---*/ int ret = 0; g_message("test begin..."); g_assert(fixture.ctrl->cctrl->block_size == 8192); g_assert(fixture.ctrl->cctrl->cache_size == 1024); g_assert(fixture.ctrl->cctrl->flush_interval == 10); g_assert(fixture.ctrl->cctrl->flush_trigger_level == 80); g_assert(fixture.ctrl->cctrl->flush_once_size == 100); ret = g_trash_stack_height(&(fixture.ctrl->cctrl->block_cache)); g_message("height of cache blocks:%d", ret); g_assert(ret == 1024); g_assert(fixture.ctrl->cctrl->dirty_block != NULL); g_assert(g_queue_get_length(fixture.ctrl->cctrl->dirty_block) == 0); g_assert(fixture.ctrl->cctrl->block_map != NULL); g_assert(fixture.ctrl->cctrl->flush_waken_cond != NULL); g_message("initializing HLFS successfully"); /*---Write something and check when flush---*/ uint64_t pos = 0; int loop = 0; char *buf = (char *)g_malloc0(8192); if (0 > hlfs_open(fixture.ctrl, 1)) { g_message("open HLFS error"); return; } struct stat *_stat = (struct stat *)g_malloc0(sizeof(struct stat)); for (loop = 0; loop < BLK_NO; loop++) { if (0 > hlfs_write(fixture.ctrl, buf, BLK_NO, pos)) { g_message("hlfs_write error"); return; } g_message("write the %dth blk", loop); pos += BLK_NO; if (!g_file_test("/tmp/testenv/testfs/0.seg", G_FILE_TEST_EXISTS)) { g_message("file not exists"); } else { memset(_stat, 0, sizeof(_stat)); ret = stat("/tmp/testenv/testfs/0.seg", _stat); if (ret < 0) { g_message("error no: %d", errno); perror("stat error:"); } g_assert(ret == 0); g_message("size of 0.seg:%d", _stat->st_size); g_message("inode of 0.seg:%d", _stat->st_ino); g_message("atime of 0.seg:%d", _stat->st_atime); //sleep(1); } } }
static void hlfs_get_all_snapshots_setup(Fixture *fixture, const void *data) { const char *test_dir = (const char *)data; g_print("test env dir is %s\n", test_dir); char *fs_dir = g_build_filename(test_dir, "testfs", NULL); // g_assert(g_mkdir(fs_dir, 0700) == 0); char *uri = g_malloc0(128); g_assert(uri != NULL); snprintf(uri, 128, "%s%s", "local://", fs_dir); // char *uri = g_build_path(tmp, fs_dir, NULL); g_print("uri is %s\n", uri); pid_t status; const char cmd[256]; memset((char *) cmd, 0, 256); sprintf((char *) cmd, "%s %s %s %s %d %s %d %s %d", "../mkfs.hlfs", "-u", uri, "-b", 8192, "-s", 67108864, "-m", 1024); g_message("cmd is [%s]", cmd); status = system(cmd); #if 0 GKeyFile *sb_keyfile = g_key_file_new(); g_key_file_set_string(sb_keyfile, "METADATA", "uri", uri); g_key_file_set_integer(sb_keyfile, "METADATA", "block_size", 8196); g_key_file_set_integer(sb_keyfile, "METADATA", \ "segment_size", 67108864); g_key_file_set_integer(sb_keyfile, "METADATA", \ "max_fs_size", 671088640); gchar *content = g_key_file_to_data(sb_keyfile, NULL, NULL); char *sb_file_path = g_build_filename(fs_dir, "superblock", NULL); g_print("sb file path is %s\n", sb_file_path); GError *error = NULL; if (TRUE != g_file_set_contents(sb_file_path, content, \ strlen(content) + 1, &error)) { g_print("error msg is %s", error->message); error = NULL; } #endif fixture->uri = uri; g_print("fixture->uri is %s\n", fixture->uri); fixture->ctrl = init_hlfs(fixture->uri); g_assert(fixture->ctrl != NULL); int ret = hlfs_open(fixture->ctrl, 1); g_assert(ret == 0); take_snapshot(fixture, data); // test_hlfs_find_inode_before_time(fixture, data); // g_key_file_free(sb_keyfile); // g_free(sb_file_path); g_free(fs_dir); return ; }
void case_setup() { #if 1 system("rm -rf /tmp/testenv"); system("mkdir /tmp/testenv -p"); system("cd ../../../ && ./output/bin/mkfs.hlfs -u \ local:///tmp/testenv/testfs -b 8192 -s 67108864 -m 1024"); system("cd -"); char *uri = "local:///tmp/testenv/testfs"; fixture.hctrl = init_hlfs(uri); g_assert(NULL != fixture.hctrl); int ret = 0; ret = hlfs_open(fixture.hctrl,1); g_assert(ret == 0); g_print("TEST hlfs open over \n"); int i = 0; int offset = 0; int BATCHSIZE = 8192; char content[BATCHSIZE]; for (i = 0;i < 8192 * 3;i++) { hlfs_write(fixture.hctrl, content, BATCHSIZE, offset); offset = offset + BATCHSIZE; if (offset == 8192 * 8192) { ret = hlfs_take_snapshot(fixture.hctrl, "test_snapshot1"); g_assert(ret == 0); g_print("take snapshot 1\n"); } if (offset == 8192 * 8192 * 2) { ret = hlfs_take_snapshot(fixture.hctrl, "test_snapshot2"); g_assert(ret == 0); g_print("take snapshot 2\n"); } if (offset == 8192 * 8192 * 2 + 8192 * 1) { ret = hlfs_take_snapshot(fixture.hctrl, "test_snapshot3"); g_assert(ret == 0); g_print("take snapshot 3\n"); } } hlfs_close(fixture.hctrl); deinit_hlfs(fixture.hctrl); #endif }
/* * ./test -u uri -r request_size -a total_size * uri: /tmp/testenv/testfs * request_size: 4096bytes * total_size: 409600bytes */ int main(int argc, char *argv[]){ if (log4c_init()) { g_message("log4c_init error!"); } GError *error = NULL; GOptionContext *context; context = g_option_context_new("- hlfs test -"); g_option_context_add_main_entries(context, entries, NULL); g_option_context_set_help_enabled(context, TRUE); g_option_group_set_error_hook(g_option_context_get_main_group(context), (GOptionErrorFunc)error_func); if (!g_option_context_parse(context, &argc, &argv, &error)) { g_message("option parsing failed: %s", error->message); exit(EXIT_FAILURE); } g_option_context_free(context); g_print("TEST: uri is %s, request size is %d, total size is %d\n", uri, request_size, total_size); char *content = (char*)g_malloc0(request_size); HLFS_CTRL * ctrl = init_hlfs(uri); g_assert(ctrl != NULL); uint64_t ret = 0; ret = hlfs_open(ctrl,1); g_assert(ret == 0); g_print("TEST hlfs open over \n"); g_print("test hlfs write\n"); sleep(2); int offset = 0; while(offset < total_size){ ret = hlfs_write(ctrl,content,request_size,offset); g_assert(ret==request_size); offset +=request_size; printf("offset:%d\n",offset); } g_print("TEST hlfs write over \n"); g_print("test hlfs read\n"); sleep(2); offset = 0; while(offset < total_size){ ret = hlfs_read(ctrl,content,request_size,offset); g_assert(ret==request_size); offset +=request_size; printf("offset:%d\n",offset); } g_print("again ------------------------\n"); offset = 0; /******************************************************************************************************************************************/ int fdd; int len; int rett; int i; //char read_buf[409600]; char *contentt = (char*)g_malloc0(40960); if((fdd = open("test.c", O_RDONLY )) == -1){ my_err("open", __LINE__); } else { g_print("Open file success\n"); } //if(write(fd, write_buf, strlen(write_buf)) != strlen(write_buf)){ // my_err("write", __LINE__); //} if(lseek(fdd, 0, SEEK_END) == -1){ my_err("lseek", __LINE__); } if((len = lseek(fdd, 0, SEEK_CUR)) == -1){ my_err("lseek", __LINE__); } if((lseek(fdd, 0, SEEK_SET)) == -1){ my_err("lseek", __LINE__); } printf("len: %d\n", len); if((rett = read(fdd, contentt, len)) < 0){ my_err("lseek",__LINE__); } strcpy(content, contentt); //for(i = 0; i< len; i ++){ g_print("%s ", contentt); //} g_print("\n"); g_print("/************************************************/"); if(lseek(fdd, 10, SEEK_END) == -1){ my_err("lseek", __LINE__); } //close (fdd); /****************************************************************************************************/ //FILE* srcFile = NULL; int srcLength = lseek(fdd, 0, SEEK_CUR); int SNAPPY_OK = 0; char* pSrcBuffer = (char*)g_malloc0(srcLength); read(fdd, pSrcBuffer, srcLength); size_t cbOfCompressed = 32+ srcLength + srcLength/6; char* pCompressedBuffer = (char*)g_malloc0(cbOfCompressed); if (snappy_compress(pSrcBuffer, srcLength, pCompressedBuffer, &cbOfCompressed) == SNAPPY_OK) { free(pSrcBuffer); pSrcBuffer = NULL; if (snappy_validate_compressed_buffer(pCompressedBuffer, cbOfCompressed) == SNAPPY_OK) { size_t cbDecompress = 0; snappy_uncompressed_length(pCompressedBuffer, cbOfCompressed, &cbDecompress); assert(cbDecompress == srcLength); char* pDecompressedBuffer = (char*)g_malloc0(cbDecompress); snappy_uncompress(pCompressedBuffer, cbOfCompressed, pDecompressedBuffer, (size_t*)&cbDecompress); int file; file = open("test1.txt", O_CREAT | O_RDWR ); //_wfopen_s(&file, _T("123.pdf"), _T("ab")); write(file, pDecompressedBuffer, cbDecompress); close(file); free(pDecompressedBuffer); pDecompressedBuffer = NULL; } } close (fdd); /******************************************************************************************************************************************/ // while(offset < total_size){ // ret = hlfs_write(ctrl,content,request_size,offset); // g_assert(ret==request_size); // offset +=request_size; // printf("offset:%d\n",offset); // } // g_print("TEST hlfs write over \n"); // g_print("test hlfs read\n"); // sleep(2); // offset = 0; while(offset < len+1){ ret = hlfs_read(ctrl,content,len,offset); g_assert(ret==len); offset +=len; printf("offset:%d\n",offset); } g_free(content); g_free(contentt); ret = hlfs_close(ctrl); deinit_hlfs(ctrl); g_print("TEST hlfs test over \n"); return 0; }
/* seg.clean -u uri -s segno -w copy_water -v verbose */ int main(int argc, char *argv[]) { GError *error = NULL; GOptionContext *context; context = g_option_context_new("- segment clearn..."); g_option_context_add_main_entries(context, entries, NULL); g_option_context_set_help_enabled(context, TRUE); g_option_group_set_error_hook(g_option_context_get_main_group(context), (GOptionErrorFunc)error_func); if (!g_option_context_parse(context, &argc, &argv, &error)) { g_message("option parsing failed: %s", error->message); exit(EXIT_FAILURE); } g_message("uri is :%s",uri); g_message("start segno:%d,end segno:%d",start_segno,end_segno); g_message("copy_waterlevel is: %d",copy_waterlevel); g_option_context_free(context); HLFS_CTRL * ctrl = init_hlfs(uri); g_assert(ctrl != NULL); g_message("ctrl init over"); int ret = 0; ret = hlfs_open(ctrl,1); g_message("ctrl open over"); g_assert(ret == 0); if(0!=ctrl->storage->bs_file_is_exist(ctrl->storage,SEGMENTS_USAGE_FILE)) { g_message("seg usage file not exit"); goto OUT; } GHashTable *seg_usage_hashtable = g_hash_table_new_full(g_direct_hash,g_direct_equal,NULL,NULL);//TODO GList* seg_usage_list = NULL; ret = load_all_seg_usage(ctrl->storage,SEGMENTS_USAGE_FILE,seg_usage_hashtable); g_assert(ret == 0); ret = sort_all_seg_usage(seg_usage_hashtable,&seg_usage_list); g_assert(ret == 0); int i; for(i=start_segno; i<=end_segno; i++) { SEG_USAGE_T *seg_usage = g_hash_table_lookup(seg_usage_hashtable,GINT_TO_POINTER((uint32_t)i)); char segfile[128]; build_segfile_name(i, segfile); if(seg_usage != NULL) { g_message("seg no:%d ...",seg_usage->segno); if (seg_usage->alive_block_num == 0) { g_message("seg no:%d no alive block now,delete it",i); if(0 == ctrl->storage->bs_file_is_exist(ctrl->storage,segfile)) { ret = ctrl->storage->bs_file_delete(ctrl->storage,segfile); g_assert(ret == 0); } else { g_message("seg no:%d has delete",i); } continue; } if(0 == strcmp(seg_usage->up_sname,EMPTY_UP_SNAPSHOT)) { g_message("seg no:%d is maybe need to migrate",seg_usage->segno); if (seg_usage->alive_block_num > copy_waterlevel) { g_message("seg no:%d is need to migrate",seg_usage->segno); ret = migrate_alive_blocks(ctrl,seg_usage); g_assert(ret == 0); seg_usage->alive_block_num =0; seg_usage->timestamp = get_current_time(); memset(seg_usage->bitmap,0,(seg_usage->log_num-1)/sizeof(gint)+1); ret = dump_seg_usage(ctrl->storage,SEGMENTS_USAGE_FILE,seg_usage); g_free(seg_usage->bitmap); g_free(seg_usage); ret = ctrl->storage->bs_file_delete(ctrl->storage,segfile); } } } else { g_message("seg no:%d has not yet do seg usage calc",i); } } OUT: ret = hlfs_close(ctrl); g_assert(ret == 0); ret = deinit_hlfs(ctrl); g_assert(ret ==0); return 0; }