X-Git-Url: http://git.tuebingen.mpg.de/?p=adu.git;a=blobdiff_plain;f=adu.c;h=8721089f67eec9064967a46b399f02bb284e3613;hp=d43f5fe4e13edf04b33ee82fd1b4617eb362b644;hb=f40f993c99e6c42faab7cac8958bc12da0fee599;hpb=5738935ef1e34d1a82e9b4fcdb741f2b06667b96 diff --git a/adu.c b/adu.c index d43f5fe..8721089 100644 --- a/adu.c +++ b/adu.c @@ -9,6 +9,7 @@ #include "portable_io.h" DEFINE_ERRLIST; +int osl_errno; /** Command line and config file options. */ static struct gengetopt_args_info conf; @@ -167,29 +168,6 @@ static int size_compare(const struct osl_object *obj1, const struct osl_object * return NUM_COMPARE(obj2->data, obj1->data); } -/** - * Compare two osl objects of string type. - * - * \param obj1 Pointer to the first object. - * \param obj2 Pointer to the second object. - * - * In any case, only \p MIN(obj1->size, obj2->size) characters of each string - * are taken into account. - * - * \return It returns an integer less than, equal to, or greater than zero if - * \a obj1 is found, respectively, to be less than, to match, or be greater - * than obj2. - * - * \sa strcmp(3), strncmp(3), osl_compare_func. - */ -static int string_compare(const struct osl_object *obj1, - const struct osl_object *obj2) -{ - const char *str1 = (const char *)obj1->data; - const char *str2 = (const char *)obj2->data; - return strncmp(str1, str2, MIN(obj1->size, obj2->size)); -} - /** * Compare two osl objects pointing to unsigned integers of 64 bit size. * @@ -219,6 +197,8 @@ enum dir_table_columns { DT_NAME, /** The dir count number. */ DT_NUM, + /** The number of the parent directory. */ + DT_PARENT_NUM, /** The number of bytes of all regular files. */ DT_BYTES, /** The number of all regular files. */ @@ -230,9 +210,8 @@ enum dir_table_columns { static struct osl_column_description dir_table_cols[] = { [DT_NAME] = { .storage_type = OSL_MAPPED_STORAGE, - .storage_flags = OSL_RBTREE | OSL_UNIQUE, + .storage_flags = 0, .name = "dir", - .compare_function = string_compare, }, [DT_NUM] = { .storage_type = OSL_MAPPED_STORAGE, @@ -241,6 +220,13 @@ static struct osl_column_description dir_table_cols[] = { .compare_function = uint64_compare, .data_size = sizeof(uint64_t) }, + [DT_PARENT_NUM] = { + .storage_type = OSL_MAPPED_STORAGE, + .storage_flags = OSL_RBTREE | OSL_FIXED_SIZE | OSL_UNIQUE, + .name = "parent_num", + .compare_function = size_compare, + .data_size = sizeof(uint64_t) + }, [DT_BYTES] = { .storage_type = OSL_MAPPED_STORAGE, .storage_flags = OSL_RBTREE | OSL_FIXED_SIZE, @@ -302,22 +288,23 @@ static struct osl_column_description user_table_cols[] = { static struct osl_table *dir_table; -static int add_directory(char *dirname, uint64_t dir_num, uint64_t *dir_size, - uint64_t *dir_files) +static int add_directory(char *dirname, uint64_t *dir_num, uint64_t *parent_dir_num, + uint64_t *dir_size, uint64_t *dir_files) { struct osl_object dir_objects[NUM_DT_COLUMNS]; - INFO_LOG("adding #%llu: %s\n", (long long unsigned)dir_num, dirname); + INFO_LOG("adding #%llu: %s\n", (long long unsigned)*dir_num, dirname); dir_objects[DT_NAME].data = dirname; dir_objects[DT_NAME].size = strlen(dirname) + 1; - dir_objects[DT_NUM].data = &dir_num; - dir_objects[DT_NUM].size = sizeof(dir_num); + dir_objects[DT_NUM].data = dir_num; + dir_objects[DT_NUM].size = sizeof(*dir_num); + dir_objects[DT_PARENT_NUM].data = parent_dir_num; + dir_objects[DT_PARENT_NUM].size = sizeof(*parent_dir_num); dir_objects[DT_BYTES].data = dir_size; dir_objects[DT_BYTES].size = sizeof(*dir_size); dir_objects[DT_FILES].data = dir_files; dir_objects[DT_FILES].size = sizeof(*dir_files); - - return osl_add_row(dir_table, dir_objects); + return osl(osl_add_row(dir_table, dir_objects)); } static uint32_t num_uids; @@ -335,12 +322,12 @@ static int open_user_table(struct user_info *ui, int create) INFO_LOG(".............................uid #%u: %u\n", (unsigned)num_uids, (unsigned)ui->uid); if (create) { - ret = osl_create_table(ui->desc); + ret = osl(osl_create_table(ui->desc)); if (ret < 0) goto err; num_uids++; } - ret = osl_open_table(ui->desc, &ui->table); + ret = osl(osl_open_table(ui->desc, &ui->table)); if (ret < 0) goto err; return 1; @@ -378,7 +365,7 @@ static int create_tables(void) int ret; dir_table_desc.dir = para_strdup(conf.database_dir_arg); - ret = osl_create_table(&dir_table_desc); + ret = osl(osl_create_table(&dir_table_desc)); if (ret < 0) return ret; create_hash_table(); @@ -471,9 +458,9 @@ static int update_user_row(struct osl_table *t, uint64_t dir_num, struct osl_row *row; struct osl_object obj = {.data = &dir_num, .size = sizeof(dir_num)}; - int ret = osl_get_row(t, UT_DIR_NUM, &obj, &row); + int ret = osl(osl_get_row(t, UT_DIR_NUM, &obj, &row)); - if (ret < 0 && ret != -E_RB_KEY_NOT_FOUND) + if (ret == -E_OSL && osl_errno != E_OSL_RB_KEY_NOT_FOUND) return ret; if (ret < 0) { /* this is the first file we add */ struct osl_object objects[NUM_UT_COLUMNS]; @@ -486,25 +473,25 @@ static int update_user_row(struct osl_table *t, uint64_t dir_num, objects[UT_FILES].data = &num_files; objects[UT_FILES].size = sizeof(num_files); INFO_LOG("######################### ret: %d\n", ret); - ret = osl_add_row(t, objects); + ret = osl(osl_add_row(t, objects)); INFO_LOG("######################### ret: %d\n", ret); return ret; } else { /* add size and increment file count */ uint64_t num; struct osl_object obj1, obj2 = {.data = &num, .size = sizeof(num)}; - ret = osl_get_object(t, row, UT_BYTES, &obj1); + ret = osl(osl_get_object(t, row, UT_BYTES, &obj1)); if (ret < 0) return ret; num = *(uint64_t *)obj1.data + *add; - ret = osl_update_object(t, row, UT_BYTES, &obj2); + ret = osl(osl_update_object(t, row, UT_BYTES, &obj2)); if (ret < 0) return ret; - ret = osl_get_object(t, row, UT_FILES, &obj1); + ret = osl(osl_get_object(t, row, UT_FILES, &obj1)); if (ret < 0) return ret; num = *(uint64_t *)obj1.data + 1; - return osl_update_object(t, row, UT_FILES, &obj2); + return osl(osl_update_object(t, row, UT_FILES, &obj2)); } } @@ -512,13 +499,13 @@ static uint64_t num_dirs; static uint64_t num_files; static uint64_t num_bytes; -int scan_dir(char *dirname) +int scan_dir(char *dirname, uint64_t *parent_dir_num) { DIR *dir; struct dirent *entry; int ret, cwd_fd, ret2; uint64_t dir_size = 0, dir_files = 0; - uint64_t this_dir_num = num_dirs++; + uint64_t this_dir_num = ++num_dirs; DEBUG_LOG("----------------- %llu: %s\n", (long long unsigned)num_dirs, dirname); ret = para_opendir(dirname, &dir, &cwd_fd); @@ -530,7 +517,6 @@ int scan_dir(char *dirname) } while ((entry = readdir(dir))) { mode_t m; - char *tmp; struct stat s; uint32_t uid; uint64_t size; @@ -549,9 +535,7 @@ int scan_dir(char *dirname) if (!S_ISREG(m) && !S_ISDIR(m)) continue; if (S_ISDIR(m)) { - tmp = make_message("%s/%s", dirname, entry->d_name); - ret = scan_dir(tmp); - free(tmp); + ret = scan_dir(entry->d_name, &this_dir_num); if (ret < 0) goto out; continue; @@ -572,7 +556,8 @@ int scan_dir(char *dirname) if (ret < 0) goto out; } - ret = add_directory(dirname, this_dir_num, &dir_size, &dir_files); + ret = add_directory(dirname, &this_dir_num, parent_dir_num, + &dir_size, &dir_files); out: closedir(dir); ret2 = para_fchdir(cwd_fd); @@ -582,15 +567,69 @@ out: return ret; } -static int get_dir_name(struct osl_row *row, char **name) +static int get_dir_name_by_number(uint64_t *dirnum, char **name) +{ + char *result = NULL, *tmp; + struct osl_row *row; + uint64_t val = *dirnum; + struct osl_object obj = {.data = &val, .size = sizeof(val)}; + int ret; + +again: + ret = osl(osl_get_row(dir_table, DT_NUM, &obj, &row)); + if (ret < 0) + goto out; + ret = osl(osl_get_object(dir_table, row, DT_NAME, &obj)); + if (ret < 0) + goto out; + if (result) { + tmp = make_message("%s/%s", (char *)obj.data, result); + free(result); + result = tmp; + } else + result = para_strdup((char *)obj.data); + ret = osl(osl_get_object(dir_table, row, DT_PARENT_NUM, &obj)); + if (ret < 0) + goto out; + val = *(uint64_t *)obj.data; + if (val) + goto again; +out: + if (ret < 0) { + free(result); + *name = NULL; + } else + *name = result; + return ret; +} + +static int get_dir_name_of_row(struct osl_row *dir_table_row, char **name) { struct osl_object obj; - int ret = osl_get_object(dir_table, row, DT_NAME, &obj); + int ret; + char *this_dir, *prefix = NULL; + *name = NULL; + ret = osl(osl_get_object(dir_table, dir_table_row, DT_NAME, &obj)); if (ret < 0) return ret; - *name = obj.data; - return 1; + this_dir = para_strdup((char *)obj.data); + ret = osl(osl_get_object(dir_table, dir_table_row, DT_PARENT_NUM, &obj)); + if (ret < 0) + goto out; + if (!*(uint64_t *)obj.data) { + *name = this_dir; + return 1; + } + ret = get_dir_name_by_number((uint64_t *)obj.data, &prefix); + if (ret < 0) + goto out; + *name = make_message("%s/%s", prefix, this_dir); + free(prefix); + ret = 1; +out: + free(this_dir); + return ret; } const uint64_t size_unit_divisors[] = { @@ -638,6 +677,8 @@ enum global_stats_flags { struct global_stats_info { uint32_t count; + int ret; + int osl_errno; enum global_stats_flags flags; }; @@ -648,12 +689,14 @@ static int global_stats_loop_function(struct osl_row *row, void *data) char *dirname, formated_value[25]; int ret, summary = gsi->flags & GSF_COMPUTE_SUMMARY; - if (!gsi->count && !summary) - return -E_LOOP_COMPLETE; + if (!gsi->count && !summary) { + ret = -E_LOOP_COMPLETE; + goto err; + } if (gsi->count && (gsi->flags & GSF_PRINT_DIRNAME)) { - ret = get_dir_name(row, &dirname); + ret = get_dir_name_of_row(row, &dirname); if (ret < 0) - return ret; + goto err; printf("%s%s", dirname, (gsi->flags & (GSF_PRINT_FILES | GSF_PRINT_BYTES))? "\t" : "\n" @@ -661,9 +704,9 @@ static int global_stats_loop_function(struct osl_row *row, void *data) } if (summary || (gsi->count && (gsi->flags & GSF_PRINT_FILES))) { uint64_t files; - ret = osl_get_object(dir_table, row, DT_FILES, &obj); + ret = osl(osl_get_object(dir_table, row, DT_FILES, &obj)); if (ret < 0) - return ret; + goto err; files = *(uint64_t *)obj.data; if (gsi->count && (gsi->flags & GSF_PRINT_FILES)) { format_size_value(conf.size_unit_arg, files, @@ -676,9 +719,9 @@ static int global_stats_loop_function(struct osl_row *row, void *data) } if (summary || (gsi->count && (gsi->flags & GSF_PRINT_BYTES))) { uint64_t bytes; - ret = osl_get_object(dir_table, row, DT_BYTES, &obj); + ret = osl(osl_get_object(dir_table, row, DT_BYTES, &obj)); if (ret < 0) - return ret; + goto err; bytes = *(uint64_t *)obj.data; if (gsi->count && (gsi->flags & GSF_PRINT_BYTES)) { format_size_value(conf.size_unit_arg, bytes, @@ -693,6 +736,10 @@ static int global_stats_loop_function(struct osl_row *row, void *data) if (gsi->count > 0) gsi->count--; return 1; +err: + gsi->ret = ret; + gsi->osl_errno = (ret == -E_OSL)? osl_errno : 0; + return -1; } static void print_id_stats(void) @@ -729,31 +776,30 @@ enum user_stats_flags { struct user_stats_info { uint32_t count; enum user_stats_flags flags; + int ret; + int osl_errno; struct user_info *ui; }; static int user_stats_loop_function(struct osl_row *row, void *data) { struct user_stats_info *usi = data; - struct osl_row *dir_row; struct osl_object obj; int ret, summary = usi->flags & GSF_COMPUTE_SUMMARY; char formated_value[25]; - if (!usi->count && !summary) - return -E_LOOP_COMPLETE; + if (!usi->count && !summary) { + ret = -E_LOOP_COMPLETE; + goto err; + } if (usi->count && (usi->flags & USF_PRINT_DIRNAME)) { char *dirname; - ret = osl_get_object(usi->ui->table, row, UT_DIR_NUM, &obj); + ret = osl(osl_get_object(usi->ui->table, row, UT_DIR_NUM, &obj)); if (ret < 0) - return ret; - ret = osl_get_row(dir_table, DT_NUM, &obj, &dir_row); - if (ret < 0) - return ret; - ret = osl_get_object(dir_table, dir_row, DT_NAME, &obj); + goto err; + ret = get_dir_name_by_number((uint64_t *)obj.data, &dirname); if (ret < 0) - return ret; - dirname = obj.data; + goto err; printf("%s%s", dirname, (usi->flags & (USF_PRINT_FILES | USF_PRINT_BYTES))? @@ -762,9 +808,9 @@ static int user_stats_loop_function(struct osl_row *row, void *data) } if (summary || (usi->count && (usi->flags & USF_PRINT_FILES))) { uint64_t files; - ret = osl_get_object(usi->ui->table, row, UT_FILES, &obj); + ret = osl(osl_get_object(usi->ui->table, row, UT_FILES, &obj)); if (ret < 0) - return ret; + goto err; files = *(uint64_t *)obj.data; if (usi->count && (usi->flags & USF_PRINT_FILES)) { format_size_value(conf.size_unit_arg, files, @@ -778,9 +824,9 @@ static int user_stats_loop_function(struct osl_row *row, void *data) } if (summary || (usi->count && (usi->flags & USF_PRINT_BYTES))) { uint64_t bytes; - ret = osl_get_object(usi->ui->table, row, UT_BYTES, &obj); + ret = osl(osl_get_object(usi->ui->table, row, UT_BYTES, &obj)); if (ret < 0) - return ret; + goto err; bytes = *(uint64_t *)obj.data; if (usi->count && (usi->flags & USF_PRINT_BYTES)) { format_size_value(conf.size_unit_arg, bytes, @@ -796,11 +842,41 @@ static int user_stats_loop_function(struct osl_row *row, void *data) if (usi->count > 0) usi->count--; return 1; +err: + usi->ret = ret; + usi->osl_errno = (ret == -E_OSL)? osl_errno : 0; + return -1; +} + +static int check_loop_return(int ret, int loop_ret, int loop_osl_errno) +{ + if (ret >= 0) + return ret; + assert(ret == -E_OSL); + if (osl_errno != E_OSL_LOOP) + /* error not caused by loop function returning negative. */ + return ret; + assert(loop_ret < 0); + if (loop_ret == -E_LOOP_COMPLETE) /* no error */ + return 1; + if (loop_ret == -E_OSL) { /* osl error in loop function */ + assert(loop_osl_errno); + osl_errno = loop_osl_errno; + } + return loop_ret; } -static void print_user_stats(void) +static int adu_loop_reverse(struct osl_table *t, unsigned col_num, void *private_data, + osl_rbtree_loop_func *func, int *loop_ret, int *loop_osl_errno) +{ + int ret = osl(osl_rbtree_loop_reverse(t, col_num, private_data, func)); + return check_loop_return(ret, *loop_ret, *loop_osl_errno); +} + +static int print_user_stats(void) { struct user_info *ui; + int ret; FOR_EACH_USER(ui) { struct user_stats_info usi = { @@ -813,14 +889,19 @@ static void print_user_stats(void) printf("************************************************ uid %u\n", (unsigned) ui->uid); printf("----------------- Largest dirs -------------------\n"); - osl_rbtree_loop_reverse(ui->table, UT_BYTES, &usi, - user_stats_loop_function); + ret = adu_loop_reverse(ui->table, UT_BYTES, &usi, user_stats_loop_function, + &usi.ret, &usi.osl_errno); + if (ret < 0) + return ret; printf("---------- dirs containing most files ------------\n"); usi.count = conf.limit_arg, usi.flags = USF_PRINT_DIRNAME | USF_PRINT_FILES; - osl_rbtree_loop_reverse(ui->table, UT_FILES, &usi, - user_stats_loop_function); + ret = adu_loop_reverse(ui->table, UT_FILES, &usi, user_stats_loop_function, + &usi.ret, &usi.osl_errno); + if (ret < 0) + return ret; } + return 1; } static int print_statistics(void) @@ -832,19 +913,18 @@ static int print_statistics(void) }; printf("----------------- Largest dirs -------------------\n"); - ret = osl_rbtree_loop_reverse(dir_table, DT_BYTES, &gsi, - global_stats_loop_function); - if (ret < 0 && ret != -E_LOOP_COMPLETE) + ret = adu_loop_reverse(dir_table, DT_BYTES, &gsi, + global_stats_loop_function, &gsi.ret, &gsi.osl_errno); + if (ret < 0) return ret; gsi.count = conf.limit_arg; gsi.flags = GSF_PRINT_DIRNAME | GSF_PRINT_FILES; printf("---------- dirs containing most files ------------\n"); - ret = osl_rbtree_loop_reverse(dir_table, DT_FILES, &gsi, - global_stats_loop_function); - if (ret < 0 && ret != -E_LOOP_COMPLETE) + ret = adu_loop_reverse(dir_table, DT_FILES, &gsi, + global_stats_loop_function, &gsi.ret, &gsi.osl_errno); + if (ret < 0) return ret; - printf("------------------ Global summary (dirs/files/bytes)\n" "%llu\t%llu\t%llu\n", (long long unsigned)num_dirs, (long long unsigned)num_files, @@ -887,7 +967,7 @@ static int open_dir_table(void) { if (!dir_table_desc.dir) /* we did not create the table */ dir_table_desc.dir = para_strdup(conf.database_dir_arg); - return osl_open_table(&dir_table_desc, &dir_table); + return osl(osl_open_table(&dir_table_desc, &dir_table)); } static void close_dir_table(void) @@ -896,9 +976,9 @@ static void close_dir_table(void) if (!dir_table) return; - ret = osl_close_table(dir_table, OSL_MARK_CLEAN); + ret = osl(osl_close_table(dir_table, OSL_MARK_CLEAN)); if (ret < 0) - ERROR_LOG("failed to close dir table: %s\n", error_txt(-ret)); + ERROR_LOG("failed to close dir table: %s\n", adu_strerror(-ret)); free((char *)dir_table_desc.dir); dir_table = NULL; } @@ -909,10 +989,10 @@ static void close_user_table(struct user_info *ui) if (!ui || !ui_used(ui) || !ui_admissible(ui)) return; - ret = osl_close_table(ui->table, OSL_MARK_CLEAN); + ret = osl(osl_close_table(ui->table, OSL_MARK_CLEAN)); if (ret < 0) ERROR_LOG("failed to close user table %u: %s\n", - (unsigned) ui->uid, error_txt(-ret)); + (unsigned) ui->uid, adu_strerror(-ret)); free((char *)ui->desc->name); ui->desc->name = NULL; free((char *)ui->desc->dir); @@ -940,13 +1020,15 @@ static void close_all_tables(void) static int com_create() { + uint64_t zero = 0ULL; int ret = create_tables(); + if (ret < 0) return ret; ret = open_dir_table(); if (ret < 0) return ret; - ret = scan_dir(conf.base_dir_arg); + ret = scan_dir(conf.base_dir_arg, &zero); if (ret < 0) goto out; ret = write_uid_list(); @@ -962,10 +1044,14 @@ static int read_uid_file(void) char *filename = get_uid_list_name(), *map; int ret = mmap_full_file(filename, O_RDONLY, (void **)&map, &size, NULL); - free(filename); - if (ret < 0) + if (ret < 0) { + INFO_LOG("failed to map %s\n", filename); + free(filename); return ret; + } num_uids = size / 4; + INFO_LOG("found %u uids in %s\n", (unsigned)num_uids, filename); + free(filename); /* hash table size should be a power of two and larger than the number of uids */ uid_hash_table_size = 4; while (uid_hash_table_size < num_uids) @@ -992,20 +1078,31 @@ static int com_select(void) ret = read_uid_file(); if (ret < 0) return ret; - print_statistics(); + ret = print_statistics(); close_all_tables(); - return 1; + return ret; } static int check_args(void) { int i, ret; + /* remove trailing slashes from base-dir arg */ + if (conf.base_dir_given) { + size_t len = strlen(conf.base_dir_arg); + for (;;) { + if (!len) /* empty string */ + return -ERRNO_TO_ERROR(EINVAL); + if (!--len) /* length 1 is always OK */ + break; + if (conf.base_dir_arg[len] != '/') + break; /* no trailing slash, also OK */ + conf.base_dir_arg[len] = '\0'; + } + } if (!conf.uid_given) return 0; - admissible_uids = para_malloc(conf.uid_given * sizeof(*admissible_uids)); - for (i = 0; i < conf.uid_given; i++) { ret = parse_uid_range(conf.uid_arg[i], admissible_uids + i); if (ret < 0) @@ -1043,7 +1140,7 @@ int main(int argc, char **argv) out: free(admissible_uids); if (ret < 0) { - ERROR_LOG("%s\n", error_txt(-ret)); + ERROR_LOG("%s\n", adu_strerror(-ret)); return -EXIT_FAILURE; } return EXIT_SUCCESS;