static void
sweep_nodes(struct node *n)
{
struct gfarm_hash_iterator i;
struct gfarm_hash_entry *child;
/* assert((n->flags & NODE_FLAG_IS_DIR) != 0); */
/*
* We don't have to honor the PURGED flag here,
* because the mark phase overrides the flag.
*/
for (gfarm_hash_iterator_begin(n->u.d.children, &i);
(child = gfarm_hash_iterator_access(&i)) != NULL;
gfarm_hash_iterator_next(&i)) {
struct node *c = gfarm_hash_entry_data(child);
if ((c->flags & NODE_FLAG_MARKED) == 0) {
if (opendir_count > 0) {
recursive_delayed_purge_nodes(c);
} else {
recursive_free_nodes(c);
gfarm_hash_iterator_purge(&i);
}
} else {
if ((c->flags & NODE_FLAG_IS_DIR) != 0)
sweep_nodes(c);
else if (opendir_count == 0 && c->u.d.children != NULL)
recursive_free_children(c);
c->flags &= ~NODE_FLAG_MARKED;
}
}
}
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
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;
}
static char *
hosts_for_program(char *program,
int *n_all_hostsp, struct gfarm_host_info **all_hostsp,
struct gfarm_hash_table **hosts_statep, int *n_runnable_hostsp)
{
char *e;
int n_all_hosts, n_runnable_hosts;
struct gfarm_host_info *all_hosts;
struct gfarm_hash_table *hosts_state;
struct gfarm_hash_table *arch_set;
struct gfarm_hash_iterator it;
struct gfarm_hash_entry *entry;
struct search_idle_host_state *h;
e = alloc_hosts_state(&n_all_hosts, &all_hosts, &hosts_state);
if (e == NULL) {
e = program_arch_set(program, &arch_set);
if (e == NULL) {
n_runnable_hosts = 0;
for (gfarm_hash_iterator_begin(hosts_state, &it);
!gfarm_hash_iterator_is_end(&it);
gfarm_hash_iterator_next(&it)) {
entry = gfarm_hash_iterator_access(&it);
h = gfarm_hash_entry_data(entry);
if (IS_IN_ARCH_SET(h->host_info->architecture,
arch_set)) {
h->flags |= HOST_STATE_FLAG_RUNNABLE;
++n_runnable_hosts;
}
}
free_arch_set(arch_set);
if (n_runnable_hosts > 0) {
*n_all_hostsp = n_all_hosts;
*all_hostsp = all_hosts;
*hosts_statep = hosts_state;
*n_runnable_hostsp = n_runnable_hosts;
return (NULL);
}
e = "there is no host which can run the program";
}
free_hosts_state(n_all_hosts, all_hosts, hosts_state);
}
return (e);
}
static gfarm_error_t
gfarm_hash_to_string_array(struct gfarm_hash_table *hash,
int *array_lengthp, char ***arrayp)
{
struct gfarm_hash_iterator iter;
struct gfarm_hash_entry *entry;
gfarm_stringlist ls;
char *ent, **array;
gfarm_error_t e;
e = gfarm_stringlist_init(&ls);
if (e != GFARM_ERR_NO_ERROR)
return (e);
for (gfarm_hash_iterator_begin(hash, &iter);
!gfarm_hash_iterator_is_end(&iter);
gfarm_hash_iterator_next(&iter)) {
entry = gfarm_hash_iterator_access(&iter);
if (entry != NULL) {
ent = strdup(gfarm_hash_entry_key(entry));
if (ent == NULL)
e = GFARM_ERR_NO_MEMORY;
else
e = gfarm_stringlist_add(&ls, ent);
}
if (e != GFARM_ERR_NO_ERROR)
goto stringlist_free;
}
array = gfarm_strings_alloc_from_stringlist(&ls);
if (array == NULL) {
e = GFARM_ERR_NO_MEMORY;
goto stringlist_free;
}
*array_lengthp = gfarm_stringlist_length(&ls);
*arrayp = array;
stringlist_free:
if (e == GFARM_ERR_NO_ERROR)
gfarm_stringlist_free(&ls);
else
gfarm_stringlist_free_deeply(&ls);
return (e);
}
static void
for_each_node(struct node *n, void (*f)(void *, struct node *), void *cookie)
{
#if 0
if ((n->flags & NODE_FLAG_IS_DIR) != 0)
#else
if (n->u.d.children != NULL)
#endif
{
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)) {
for_each_node(gfarm_hash_entry_data(child), f, cookie);
}
}
(*f)(cookie, n);
}
char *
gfs_readdir(GFS_Dir dir, struct gfs_dirent **entry)
{
struct gfarm_hash_entry *he;
struct node *n;
if (dir->index == 0) {
n = dir->dir;
dir->buffer.d_namlen = 1;
dir->buffer.d_name[0] = '.';
dir->index++;
} else if (dir->index == 1) {
n = dir->dir->parent;
dir->buffer.d_namlen = 2;
dir->buffer.d_name[0] = dir->buffer.d_name[1] = '.';
dir->index++;
} else {
for (;;) {
he = gfarm_hash_iterator_access(&dir->iterator);
if (he == NULL) {
*entry = NULL;
return (NULL);
}
n = gfarm_hash_entry_data(he);
gfarm_hash_iterator_next(&dir->iterator);
dir->index++;
if ((n->flags & NODE_FLAG_PURGED) == 0)
break;
}
dir->buffer.d_namlen = gfarm_hash_entry_key_length(he);
memcpy(dir->buffer.d_name, gfarm_hash_entry_key(he),
dir->buffer.d_namlen);
}
dir->buffer.d_name[dir->buffer.d_namlen] = '\0';
dir->buffer.d_type = (n->flags & NODE_FLAG_IS_DIR) ?
GFS_DT_DIR : GFS_DT_REG;
dir->buffer.d_reclen = 0x100; /* XXX */
dir->buffer.d_fileno = INUMBER(n);
*entry = &dir->buffer;
return (NULL);
}
