void tg_option_tests() { GOptionContext *context; GOptionContext *context1;//for testing set main group GOptionContext *context2;//for testing add group gboolean retval; GError *error = NULL; gchar **argv; int argc; gchar **argv1; int argc1; GOptionEntry entries [] = { { "test", 0, 0, G_OPTION_ARG_INT, &arg_test1_int, "test_description", "test_arg" }, { NULL } }; GOptionEntry entries1 [] = { { "try", 0, 0, G_OPTION_ARG_INT, &arg_test1_int, "try_description", "try_arg" }, { NULL } }; GOptionEntry entries2 [] = { { "again", 0, 0, G_OPTION_ARG_INT, &arg_test1_int, "again_description", "again_arg" }, { NULL } }; GOptionGroup *main_group; context = g_option_context_new (NULL); context1 = g_option_context_new (NULL); context2 = g_option_context_new (NULL); g_option_context_add_main_entries (context, entries, NULL); g_option_context_add_main_entries (context2, entries, NULL); main_group = g_option_context_get_main_group (context); //Testing g_option_context_set_main_group with another context-context1 g_option_group_add_entries (main_group,entries1); g_option_context_set_main_group(context1,main_group); //Testing g_option_context_set_help_enabled //and g_option_context_get_help_enabled //and g_option_context_get_ignore_unknown_options g_option_context_set_help_enabled(context,TRUE); g_assert(g_option_context_get_help_enabled(context)); g_assert(!g_option_context_get_ignore_unknown_options(context)); /* Now try parsing on context1*/ argv = split_string ("program --try 20 --try 30", &argc); retval = g_option_context_parse (context1, &argc, &argv, &error); g_assert (retval); /* Last arg specified is the one that should be stored */ g_assert (arg_test1_int == 30); g_option_group_set_error_hook (main_group, error_func); argv = split_string ("program --none 20 --none 30", &argc); retval = g_option_context_parse (context1, &argc, &argv, &error); g_strfreev (argv); g_option_context_free (context); }
int main(int argc, char **argv) { GtkWidget *window, *revealer, *grid, *widget; GtkCssProvider *cssprovider; GError *error = NULL; guint x, y; GOptionContext *context = g_option_context_new (NULL); g_option_context_add_main_entries (context, options, NULL); frame_stats_add_options (g_option_context_get_main_group (context)); g_option_context_add_group (context, gtk_get_option_group (TRUE)); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_printerr ("Option parsing failed: %s\n", error->message); return 1; } window = gtk_window_new (GTK_WINDOW_TOPLEVEL); frame_stats_ensure (GTK_WINDOW (window)); revealer = gtk_revealer_new (); gtk_widget_set_valign (revealer, GTK_ALIGN_START); gtk_revealer_set_transition_type (GTK_REVEALER (revealer), GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN); gtk_revealer_set_transition_duration (GTK_REVEALER (revealer), reveal_time * 1000); gtk_revealer_set_reveal_child (GTK_REVEALER (revealer), TRUE); g_signal_connect_after (revealer, "map", G_CALLBACK (toggle_reveal), NULL); g_signal_connect_after (revealer, "notify::child-revealed", G_CALLBACK (toggle_reveal), NULL); gtk_container_add (GTK_CONTAINER (window), revealer); grid = gtk_grid_new (); gtk_container_add (GTK_CONTAINER (revealer), grid); cssprovider = gtk_css_provider_new (); gtk_css_provider_load_from_data (cssprovider, "* { padding: 2px; text-shadow: 5px 5px 2px grey; }", -1, NULL); for (x = 0; x < 10; x++) { for (y = 0; y < 20; y++) { widget = gtk_label_new ("Hello World"); gtk_style_context_add_provider (gtk_widget_get_style_context (widget), GTK_STYLE_PROVIDER (cssprovider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); gtk_grid_attach (GTK_GRID (grid), widget, x, y, 1, 1); } } gtk_widget_show_all (window); gtk_main (); return 0; }
int main (int argc, char **argv) { GtkWidget *window; GtkWidget *scrolled_window; GtkWidget *viewport; GtkWidget *grid; GError *error = NULL; int i; GOptionContext *context = g_option_context_new (NULL); g_option_context_add_main_entries (context, options, NULL); frame_stats_add_options (g_option_context_get_main_group (context)); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_printerr ("Option parsing failed: %s\n", error->message); return 1; } gtk_init (); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); frame_stats_ensure (GTK_WINDOW (window)); gtk_window_set_default_size (GTK_WINDOW (window), 800, 600); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (window), scrolled_window); viewport = gtk_viewport_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (scrolled_window), viewport); grid = gtk_grid_new (); gtk_container_add (GTK_CONTAINER (viewport), grid); for (i = 0; i < 4; i++) { GtkWidget *content = create_widget_factory_content (); gtk_grid_attach (GTK_GRID (grid), content, i % 2, i / 2, 1, 1); g_object_unref (content); } gtk_widget_add_tick_callback (viewport, scroll_viewport, NULL, NULL); gtk_widget_show (window); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_main (); return 0; }
void error_test1 (void) { GOptionContext *context; gboolean retval; GError *error = NULL; gchar **argv; int argc; GOptionGroup *main_group; #ifndef SYMBIAN GOptionEntry entries [] = { { "test", 0, 0, G_OPTION_ARG_INT, &error_test1_int, NULL, NULL }, { NULL } }; #else GOptionEntry entries [2]; entries[0].long_name = "test"; entries[0].short_name = 0; entries[0].flags = 0; entries[0].arg = G_OPTION_ARG_INT; entries[0].arg_data = (gpointer)&error_test1_int; entries[0].description = NULL; entries[0].arg_description = NULL; entries[1].long_name = NULL; entries[1].short_name = 0; entries[1].arg_data = NULL; entries[1].description = NULL; entries[1].arg_description = NULL; #endif context = g_option_context_new (NULL); g_option_context_add_main_entries (context, entries, NULL); /* Set pre and post parse hooks */ main_group = g_option_context_get_main_group (context); g_option_group_set_parse_hooks (main_group, error_test1_pre_parse, error_test1_post_parse); /* Now try parsing */ argv = split_string ("program --test 20", &argc); retval = g_option_context_parse (context, &argc, &argv, &error); g_assert (retval == FALSE); /* On failure, values should be reset */ g_assert (error_test1_int == 0x12345678); g_strfreev (argv); g_option_context_free (context); }
/* nbd-ops -p pid -f fsname -c command */ int main(int argc, char *argv[]) { GError *error = NULL; GOptionContext *context; context = g_option_context_new("- tapdisk ops..."); 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\n", error->message); exit(EXIT_FAILURE); } g_message("fsname: %s\n", fsname); g_message("cmd: %s\n", cmd); g_message("param1: %d\n" ,param1); g_option_context_free(context); char ctrl_region_file[128]; sprintf(ctrl_region_file,"%s%s%s","/tmp/",fsname,"-ctrl"); int fd = open(ctrl_region_file,O_RDWR); if(fd == -1){ return -1; } // int offset = sysconf(_SC_PAGE_SIZE); char *addr = mmap(NULL,sizeof(CTRL_REGION_T), PROT_WRITE, MAP_SHARED, fd, 0); if (addr == MAP_FAILED) { g_message("%s -- mmap failed\n", __func__); exit(EXIT_FAILURE); } g_assert(addr !=NULL); CTRL_REGION_T *ctrl_region; ctrl_region = (CTRL_REGION_T*)addr; gint *_is_start_clean = &ctrl_region->is_start_clean; gint *_copy_waterlevel = &ctrl_region->copy_waterlevel; if(0 == strncmp(cmd,"start_merge",strlen("start_merge"))){ g_message("cmd is srart merge : %s",cmd); g_atomic_int_set(_is_start_clean,1); }else if(0 == strncmp(cmd,"stop_merge",strlen("stop_merge"))){ g_message("cmd is stop merge : %s",cmd); g_atomic_int_set(_is_start_clean,0); }else if (0 == strncmp(cmd, "set_copy_waterlevel", strlen("set_copy_waterlevel"))){ g_message("cmd is set copy waterlevel: %s", cmd); g_atomic_int_set(_copy_waterlevel,param1); }else if (0 == strncmp(cmd, "query_stat", strlen("query_stat"))){ g_message("cmd is query_stat: %s", cmd); g_message("is_start_clean:%d", ctrl_region->is_start_clean); g_message("copy_waterlevel:%d",ctrl_region->copy_waterlevel); }else{ g_assert(0); } return 0; }
int main(int argc, char **argv) { GError *error = NULL; GdkMonitor *monitor; GdkRectangle monitor_bounds; GOptionContext *context = g_option_context_new (NULL); g_option_context_add_main_entries (context, options, NULL); frame_stats_add_options (g_option_context_get_main_group (context)); g_option_context_add_group (context, gtk_get_option_group (TRUE)); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_printerr ("Option parsing failed: %s\n", error->message); return 1; } g_print ("# Load factor: %g\n", load_factor); g_print ("# Resizing?: %s\n", cb_no_resize ? "no" : "yes"); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); frame_stats_ensure (GTK_WINDOW (window)); gtk_window_set_keep_above (GTK_WINDOW (window), TRUE); gtk_window_set_gravity (GTK_WINDOW (window), GDK_GRAVITY_CENTER); gtk_widget_set_app_paintable (window, TRUE); g_signal_connect (window, "draw", G_CALLBACK (on_window_draw), NULL); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect (window, "map-event", G_CALLBACK (on_map_event), NULL); on_frame (0.); monitor = gdk_display_get_primary_monitor (gtk_widget_get_display (window)); gdk_monitor_get_geometry (monitor, &monitor_bounds); gtk_window_move (GTK_WINDOW (window), monitor_bounds.x + (monitor_bounds.width - window_width) / 2, monitor_bounds.y + (monitor_bounds.height - window_height) / 2); gtk_widget_show (window); gtk_main (); return 0; }
/* mkfs_rmfs -u uri */ int main(int argc, char *argv[]) { // if (log4c_init()) { // g_message("log4c_init failed!"); // } GError *error = NULL; GOptionContext *context; context = g_option_context_new("-hlfs rmfs"); 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_print("fs uri is :%s\n", uri); int ret = 0; struct back_storage *storage = init_storage_handler(uri); if (NULL == storage) { g_message("can not get storage handler for uri:%s", uri); ret = -1; goto out; } if (0 != hlfs_rmfs(storage)){ g_printf("Can not remove fs!\n"); ret = -1; goto out1; } out1: deinit_storage_handler(storage); out: g_free(uri); g_option_context_free(context); // if (log4c_fini()) { // g_message("log4c_fini failed!"); // } return 0; }
static GOptionContext *commandline_parse(int *argc, char ***argv) { GOptionContext *context = NULL; GError *error = NULL; gchar *string; string = g_strdup_printf(_("- controls extended capabilities of Roccat %s mice"), KONEXTD_DEVICE_NAME); context = g_option_context_new(string); g_free(string); g_option_context_add_main_entries(context, entries, NULL); g_option_context_set_translation_domain(context, PROJECT_NAME); g_option_group_set_parse_hooks(g_option_context_get_main_group(context), NULL, post_parse_func); if (!g_option_context_parse(context, argc, argv, &error)) { g_critical(_("Could not parse options: %s"), error->message); exit(EXIT_FAILURE); } return context; }
/* nbd-ops -p pid -u uri -c command */ int main(int argc, char *argv[]) { GError *error = NULL; GOptionContext *context; context = g_option_context_new("- nbd ops..."); 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\n", error->message); exit(EXIT_FAILURE); } g_message("nspid: %d\n",nbd_server_pid); g_message("uri: %s\n", uri); g_message("cmd: %s\n", cmd); g_message("param1: %d\n" ,param1); g_option_context_free(context); int _pid = nbd_server_pid; char FIFO_R[128]; char FIFO_W[128]; snprintf(FIFO_W,128,"%s/%s/%d","/tmp", "nbd-0-",_pid); snprintf(FIFO_R,128,"%s/%s/%d","/tmp", "nbd-1-",_pid); printf("--FIFO-R :%s\n",FIFO_R); printf("--FIFO-W :%s\n",FIFO_W); char w_buf[512]; char r_buf[512]; int nwrite; int msg_w_fd=open(FIFO_W,O_RDWR,0); if(msg_w_fd == -1){ g_message("open error: %s/n", strerror(errno)); g_message("open fifo:%s failed\n",FIFO_W); exit(-1); } int msg_r_fd=open(FIFO_R,O_RDWR,0); if(msg_r_fd == -1){ g_message("open error: %s/n", strerror(errno)); g_message("open fifo:%s failed\n",FIFO_R); exit(-1); } NBD_OPS_CMD_T nbd_cmd; NBD_OPS_RSP_T nbd_rsp; if(0 == strncmp(cmd,"start_merge",strlen("start_merge"))){ g_message("cmd is srart merge : %s",cmd); nbd_cmd.nbd_ops_cmd = start_clean; }else if(0 == strncmp(cmd,"stop_merge",strlen("stop_merge"))){ g_message("cmd is stop merge : %s",cmd); nbd_cmd.nbd_ops_cmd = start_clean; }else if (0 == strncmp(cmd, "set_copy_waterlevel", strlen("set_copy_waterlevel"))){ g_message("cmd is set copy waterlevel: %s", cmd); nbd_cmd.nbd_ops_cmd = set_copy_waterlevel; }else if (0 == strncmp(cmd, "query_stat", strlen("query_stat"))){ g_message("cmd is query_stat: %s", cmd); nbd_cmd.nbd_ops_cmd = query_stat; }else{ g_assert(0); } strncpy(nbd_cmd.uri,uri,128); nbd_cmd.value = param1; g_message("write to fifo value: %d", nbd_cmd.value); g_message("write to fifo : %s",nbd_cmd.uri); int reval = write(msg_w_fd,&nbd_cmd,sizeof(NBD_OPS_CMD_T)); if(reval != sizeof(NBD_OPS_CMD_T)) { g_message("message send error"); exit(-1); } g_message("write over %d",reval); sleep(1); g_message("read from fifo"); reval = read(msg_r_fd,&nbd_rsp,sizeof(NBD_OPS_RSP_T)); if(reval != sizeof(NBD_OPS_RSP_T)){ g_message("message send error"); exit(-1); } g_message("rsponse reval:%d errno:%d",reval,nbd_rsp.err_no); if(nbd_rsp.err_no == 0){ if (0 == strncmp(cmd, "query_stat", strlen("query_stat"))){ NBD_OPS_STAT nbd_stat; reval = read(msg_r_fd,&nbd_stat,sizeof(NBD_OPS_STAT)); g_message("start clean :%d",nbd_stat.is_start_clean); g_message("copy waterlevel :%d",nbd_stat.copy_waterlevel); } } close(msg_w_fd); close(msg_r_fd); return 0; }
/* * ./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; }
/* mkfs.lhfs -l http://<path> -s name */ int main(int argc, char *argv[]) { if (log4c_init()) { g_message("log4c_init failed!"); } GError *error = NULL; GOptionContext *context; context = g_option_context_new("- mkfs hlfs"); 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_print("location is :%s\n",location); //g_print("fsname is :%s\n",fsname); //g_print("block size is :%d\n",block_size); //g_print("segment size is :%d\n",seg_size); // seg_size = SEGMENT_SIZE; if(seg_size <= 0 || seg_size%(1024*1024)!=0){ g_message("segsize <=0 or segment size must 1M margin"); return -1; } if(block_size <=0 || block_size%(512) != 0){ g_message("blocksize <=0 or block size must 512 margin"); return -1; } if(max_fs_size <=0){ g_message("max fs size <=0"); return -1; } struct back_storage *storage = init_storage_handler(uri); if(NULL ==storage){ g_message("can not get storage handler for uri:%s",uri); g_option_context_free(context); return -1; } if((0==storage->bs_file_is_exist(storage,NULL)) && (0==storage->bs_file_is_exist(storage,"superblock"))){ g_message("hlfs with uri:%s has exist",uri); g_option_context_free(context); return 1; } if( 0!=storage->bs_file_mkdir(storage,NULL)){ g_message("can not mkdir for our fs %s",uri); g_option_context_free(context); return -1; } 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",block_size); g_key_file_set_integer(sb_keyfile,"METADATA","segment_size",seg_size); g_key_file_set_uint64(sb_keyfile,"METADATA","max_fs_size",max_fs_size); gchar *data = g_key_file_to_data(sb_keyfile,NULL,NULL); g_message("key file data :%s",data); char *head,*hostname,*dir,*fs_name; int port; parse_from_uri(uri,&head,&hostname,&dir,&fs_name,&port); char *sb_file_path = g_build_filename(dir,fs_name,"superblock",NULL); g_message("sb file path %s",sb_file_path); bs_file_t file = storage->bs_file_create(storage,"superblock"); g_message("sb file path 1%s",sb_file_path); //bs_file_t file = storage->bs_file_open(storage,"superblock",BS_WRITEABLE); if (NULL == file) { g_message("open file :superblock failed"); g_free(sb_file_path); g_option_context_free(context); return -1; } g_message("sb file path 2%s",sb_file_path); int size = storage->bs_file_append(storage, file,(char*)data,strlen(data)+1); if(size != strlen(data)+1){ g_message("can not write superblock file"); g_free(sb_file_path); g_option_context_free(context); return -1; } g_message("append size:%d",size); storage->bs_file_flush(storage,file); storage->bs_file_close(storage,file); deinit_storage_handler(storage); if (log4c_fini()) { g_message("log4c_fini failed!"); } 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; }