static void free_hosts_state(int n_all_hosts, struct gfarm_host_info *all_hosts, struct gfarm_hash_table *hosts_state) { gfarm_hash_table_free(hosts_state); gfarm_host_info_free_all(n_all_hosts, all_hosts); }
static void cache_path_info_free() { struct gfarm_hash_iterator iterator; struct gfarm_hash_entry *he; struct path_info_cache *pic; #ifdef DEBUG char *key; char path[PATH_MAX]; #endif gfarm_hash_iterator_begin(cache_table, &iterator); while (1) { he = gfarm_hash_iterator_access(&iterator); if (he == NULL) break; pic = gfarm_hash_entry_data(he); #ifdef DEBUG key = gfarm_hash_entry_key(he); memset(path, 0, PATH_MAX); memcpy(path, key, gfarm_hash_entry_key_length(he)); _debug("! free path_info cache: %d: %s\n", pic->noent, path); #endif if (pic->noent == CACHE_SET) gfarm_path_info_free(&pic->info); gfarm_hash_iterator_next(&iterator); } /* ?? gfarm_hash_iterator_purge(&iterator); */ gfarm_hash_table_free(cache_table); prepare_cache_table = 0; }
static void free_node(void *cookie, struct node *n) { #if 0 if ((n->flags & NODE_FLAG_IS_DIR) != 0) #else if (n->u.d.children != NULL) #endif gfarm_hash_table_free(n->u.d.children); free(n->name); }
static void recursive_free_children(struct node *n) { struct gfarm_hash_iterator i; struct gfarm_hash_entry *child; for (gfarm_hash_iterator_begin(n->u.d.children, &i); (child = gfarm_hash_iterator_access(&i)) != NULL; gfarm_hash_iterator_next(&i)) { recursive_free_nodes(gfarm_hash_entry_data(child)); } gfarm_hash_table_free(n->u.d.children); n->u.d.children = NULL; }
/* * this function frees all cached connections, including in-use ones. * * potential problems: * - connections which are currently in-use are freed too. * - connections which are uncached are NOT freed. * i.e. the followings are all NOT freed: * - connections which have never cached, * - connections which had been once cached but currently uncached * (since their network connections were dead) */ void gfp_cached_connection_terminate(struct gfp_conn_cache *cache) { struct gfarm_hash_iterator it; struct gfarm_hash_entry *entry; struct gfp_cached_connection *connection; static const char diag[] = "gfp_cached_connection_terminate"; gfarm_mutex_lock(&cache->mutex, diag, diag_what); if (cache->hashtab == NULL) { gfarm_mutex_unlock(&cache->mutex, diag, diag_what); return; } gfarm_mutex_unlock(&cache->mutex, diag, diag_what); /* * clear all free connections. * to makes cache->lru_list.free_cached_entries 0. */ gfp_cached_connection_gc_all(cache); gfarm_mutex_lock(&cache->mutex, diag, diag_what); /* clear all in-use connections too. XXX really necessary? */ for (gfarm_hash_iterator_begin(cache->hashtab, &it); !gfarm_hash_iterator_is_end(&it);) { entry = gfarm_hash_iterator_access(&it); connection = *(struct gfp_cached_connection **) gfarm_hash_entry_data(entry); gfarm_lru_cache_purge_entry(&connection->lru_entry); gfp_conn_hash_iterator_purge(&it); gfarm_mutex_unlock(&cache->mutex, diag, diag_what); (*cache->dispose_connection)(connection->connection_data); gfarm_mutex_lock(&cache->mutex, diag, diag_what); /* restart from the top, because maybe changed by others */ gfarm_hash_iterator_begin(cache->hashtab, &it); } /* free hash table */ gfarm_hash_table_free(cache->hashtab); cache->hashtab = NULL; gfarm_mutex_unlock(&cache->mutex, diag, diag_what); }
int main(int argc, char *argv[]) { char *src_hostfile = NULL, *dst_hostfile = NULL; gfarm_stringlist paths; gfs_glob_t types; int mode_src_ch = 0, mode_dst_ch = 0, parallel = -1; int i, ch; gfarm_error_t e; const char *errmsg, *errmsg2 = NULL; struct gfrep_arg gfrep_arg; struct flist flist; if (argc >= 1) program_name = basename(argv[0]); memset(&gfrep_arg, 0, sizeof(gfrep_arg)); memset(&flist, 0, sizeof(flist)); flist.src_domain = ""; flist.dst_domain = ""; e = gfarm_initialize(&argc, &argv); error_check(e); #ifdef _OPENMP while ((ch = getopt(argc, argv, "h:j:mnqvxS:D:H:N:?")) != -1) { #else while ((ch = getopt(argc, argv, "h:mnqvxS:D:H:N:?")) != -1) { #endif switch (ch) { case 'h': src_hostfile = optarg; conflict_check(&mode_src_ch, ch); break; #ifdef _OPENMP case 'j': parallel = strtol(optarg, NULL, 0); break; #endif case 'm': act = &migrate_mode; break; case 'n': opt_noexec = 1; break; case 'q': opt_quiet = 1; break; case 'v': opt_verbose = 1; break; case 'x': opt_remove = 1; break; case 'S': flist.src_domain = optarg; conflict_check(&mode_src_ch, ch); break; case 'D': flist.dst_domain = optarg; conflict_check(&mode_dst_ch, ch); break; case 'H': dst_hostfile = optarg; conflict_check(&mode_dst_ch, ch); break; case 'N': opt_nrep = strtol(optarg, NULL, 0); break; case '?': default: usage(); } } argc -= optind; argv += optind; /* make writing-to-stderr atomic, for GfarmFS-FUSE log output */ setvbuf(stderr, NULL, _IOLBF, 0); if (!opt_quiet) { printf("constructing file list..."); fflush(stdout); } e = gfarm_stringlist_init(&paths); if (e == GFARM_ERR_NO_ERROR) { e = gfs_glob_init(&types); if (e == GFARM_ERR_NO_ERROR) { for (i = 0; i < argc; i++) gfs_glob(argv[i], &paths, &types); gfs_glob_free(&types); } } error_check(e); e = gfarm_list_init(&flist.slist); error_check(e); e = gfarm_list_init(&flist.dlist); error_check(e); flist.srchash = gfarm_hash_table_alloc(HOSTHASH_SIZE, gfarm_hash_casefold, gfarm_hash_key_equal_casefold); if (flist.srchash == NULL) error_check(GFARM_ERR_NO_MEMORY); e = create_hosthash_from_file(src_hostfile, HOSTHASH_SIZE, &flist.src_hosthash); error_check(e); e = create_hosthash_from_file(dst_hostfile, HOSTHASH_SIZE, &flist.dst_hosthash); error_check(e); for (i = 0; i < gfarm_stringlist_length(&paths); i++) { char *file = gfarm_stringlist_elem(&paths, i), *realpath = NULL; e = gfarm_realpath_by_gfarm2fs(file, &realpath); if (e == GFARM_ERR_NO_ERROR) file = realpath; e = gfarm_foreach_directory_hierarchy( create_filelist, NULL, NULL, file, &flist); free(realpath); if (e != GFARM_ERR_NO_ERROR) break; } gfarm_stringlist_free_deeply(&paths); error_check(e); if (!opt_quiet) printf(" done\n"); if (opt_verbose) { printf("files to be replicated\n"); print_file_list(&flist.slist); } if (opt_verbose && opt_remove) { printf("files having too many replicas\n"); print_file_list(&flist.dlist); } if (gfarm_list_length(&flist.slist) <= 0 && (!opt_remove || gfarm_list_length(&flist.dlist) <= 0)) exit(0); /* no file */ /* replicate files */ e = gfarm_hash_to_string_array( flist.srchash, &gfrep_arg.nsrc, &gfrep_arg.src); error_check(e); gfarm_hash_table_free(flist.srchash); if (!opt_quiet) { printf("investigating hosts..."); fflush(stdout); } e = create_hostlist_by_domain_and_hash( gfarm_list_length(&flist.slist) > 0 ? gfarm_list_elem(&flist.slist, 0) : gfarm_list_elem(&flist.dlist, 0), flist.dst_domain, flist.dst_hosthash, &gfrep_arg.ndst, &gfrep_arg.dst, &gfrep_arg.dst_port); error_check(e); if (!opt_quiet) printf(" done\n"); errmsg = pfor_list(act, &flist.slist, parallel, &gfrep_arg); gfarm_list_free(&flist.slist); /* remove file replicas */ if (opt_remove) errmsg2 = pfor_list( &remove_mode, &flist.dlist, parallel, &gfrep_arg); gfarm_list_free(&flist.dlist); if (errmsg == NULL) errmsg = errmsg2; if (errmsg != NULL) fprintf(stderr, "%s\n", errmsg), exit(EXIT_FAILURE); gfarm_strings_free_deeply(gfrep_arg.nsrc, gfrep_arg.src); gfarm_strings_free_deeply(gfrep_arg.ndst, gfrep_arg.dst); free(gfrep_arg.dst_port); e = gfarm_terminate(); error_check(e); return (0); }