X-Git-Url: http://git.tuebingen.mpg.de/?p=adu.git;a=blobdiff_plain;f=adu.c;h=54af136ad789314b88392658077fa88c926d766f;hp=b0b7cb41d139233fb2acfadae12b09d8c4230fbd;hb=e21355c5755fb738dd08b3a9e2d3c66af4b9a355;hpb=f18d309e0170e8f7b40715d8da8091cd507cea73

diff --git a/adu.c b/adu.c
index b0b7cb4..54af136 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;
@@ -30,6 +31,13 @@ struct user_info {
 	struct osl_table_description *desc;
 };
 
+/** The decimal representation of an uint64_t never exceeds that size. */
+#define FORMATED_VALUE_SIZE 25
+
+#define FOR_EACH_USER(ui) for (ui = uid_hash_table; ui && ui < uid_hash_table \
+		+ uid_hash_table_size; ui++)
+
+
 /**
  * Contains info for each user that owns at least one regular file.
  *
@@ -39,6 +47,9 @@ struct user_info {
  */
 static struct user_info *uid_hash_table;
 
+/* these get filled in by the select command. */
+static char count_unit_buf[4] = "( )", size_unit_buf[4] = "( )";
+
 static inline int ui_used(struct user_info *ui)
 {
 	return ui->flags & UI_FL_SLOT_USED;
@@ -79,10 +90,8 @@ static int parse_uid_range(const char *orig_arg, struct uid_range *ur)
 	int ret;
 	char *arg = para_strdup(orig_arg), *p = strchr(arg, '-');
 
-	if (!p || p == arg) {
-		if (p == arg) /* -42 */
-			p++;
-		ret = check_uid_arg(p, &ur->high);
+	if (!p || p == arg) { /* -42 or 42 */
+		ret = check_uid_arg(p? p + 1 : arg, &ur->high);
 		if (ret < 0)
 			goto out;
 		ur->low = p? 0 : ur->high;
@@ -113,7 +122,6 @@ out:
 	return ret;
 }
 
-
 /** evaluates to 1 if x < y, to -1 if x > y and to 0 if x == y */
 #define NUM_COMPARE(x, y) ((int)((x) < (y)) - (int)((x) > (y)))
 
@@ -303,8 +311,7 @@ static int add_directory(char *dirname, uint64_t *dir_num, uint64_t *parent_dir_
 	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;
@@ -322,12 +329,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;
@@ -365,13 +372,86 @@ 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();
 	return 1;
 }
 
+static void close_dir_table(void)
+{
+	int ret;
+
+	if (!dir_table)
+		return;
+	ret = osl(osl_close_table(dir_table, OSL_MARK_CLEAN));
+	if (ret < 0)
+		ERROR_LOG("failed to close dir table: %s\n", adu_strerror(-ret));
+	free((char *)dir_table_desc.dir);
+	dir_table = NULL;
+}
+
+static void close_user_table(struct user_info *ui)
+{
+	int ret;
+
+	if (!ui || !ui_used(ui) || !ui_admissible(ui))
+		return;
+	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, adu_strerror(-ret));
+	free((char *)ui->desc->name);
+	ui->desc->name = NULL;
+	free((char *)ui->desc->dir);
+	ui->desc->dir = NULL;
+	free(ui->desc);
+	ui->desc = NULL;
+	ui->table = NULL;
+	ui->flags = 0;
+}
+
+static void close_user_tables(void)
+{
+	struct user_info *ui;
+
+	FOR_EACH_USER(ui)
+		close_user_table(ui);
+}
+
+static void close_all_tables(void)
+{
+	close_dir_table();
+	close_user_tables();
+	free_hash_table();
+}
+
+static int signum;
+
+static void signal_handler(int s)
+{
+	signum = s;
+}
+
+static void check_signals(void)
+{
+	if (likely(!signum))
+		return;
+	EMERG_LOG("caught signal %d\n", signum);
+	close_all_tables();
+	exit(EXIT_FAILURE);
+}
+
+static int init_signals(void)
+{
+	if (signal(SIGINT, &signal_handler) == SIG_ERR)
+		return -E_SIGNAL_SIG_ERR;
+	if (signal(SIGTERM, &signal_handler) == SIG_ERR)
+		return -E_SIGNAL_SIG_ERR;
+	return 1;
+}
+
 /*
  * We use a hash table of size s=2^uid_hash_bits to map the uids into the
  * interval [0..s]. Hash collisions are treated by open addressing, i.e.
@@ -394,9 +474,6 @@ static uint32_t double_hash(uint32_t uid, uint32_t probe_num)
 		% uid_hash_table_size;
 }
 
-#define FOR_EACH_USER(ui) for (ui = uid_hash_table; ui && ui < uid_hash_table \
-		+ uid_hash_table_size; ui++)
-
 enum search_uid_flags {
 	OPEN_USER_TABLE = 1,
 	CREATE_USER_TABLE = 2,
@@ -458,9 +535,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];
@@ -473,25 +550,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));
 	}
 }
 
@@ -507,6 +584,7 @@ int scan_dir(char *dirname, uint64_t *parent_dir_num)
 	uint64_t dir_size = 0, dir_files = 0;
 	uint64_t this_dir_num = ++num_dirs;
 
+	check_signals();
 	DEBUG_LOG("----------------- %llu: %s\n", (long long unsigned)num_dirs, dirname);
 	ret = para_opendir(dirname, &dir, &cwd_fd);
 	if (ret < 0) {
@@ -576,10 +654,10 @@ static int get_dir_name_by_number(uint64_t *dirnum, char **name)
 	int ret;
 
 again:
-	ret = osl_get_row(dir_table, DT_NUM, &obj, &row);
+	ret = osl(osl_get_row(dir_table, DT_NUM, &obj, &row));
 	if (ret < 0)
 		goto out;
-	ret = osl_get_object(dir_table, row, DT_NAME, &obj);
+	ret = osl(osl_get_object(dir_table, row, DT_NAME, &obj));
 	if (ret < 0)
 		goto out;
 	if (result) {
@@ -588,7 +666,7 @@ again:
 		result = tmp;
 	} else
 		result = para_strdup((char *)obj.data);
-	ret = osl_get_object(dir_table, row, DT_PARENT_NUM, &obj);
+	ret = osl(osl_get_object(dir_table, row, DT_PARENT_NUM, &obj));
 	if (ret < 0)
 		goto out;
 	val = *(uint64_t *)obj.data;
@@ -610,11 +688,11 @@ static int get_dir_name_of_row(struct osl_row *dir_table_row, char **name)
 	char *this_dir, *prefix = NULL;
 
 	*name = NULL;
-	ret = osl_get_object(dir_table, dir_table_row, DT_NAME, &obj);
+	ret = osl(osl_get_object(dir_table, dir_table_row, DT_NAME, &obj));
 	if (ret < 0)
 		return ret;
 	this_dir = para_strdup((char *)obj.data);
-	ret = osl_get_object(dir_table, dir_table_row, DT_PARENT_NUM, &obj);
+	ret = osl(osl_get_object(dir_table, dir_table_row, DT_PARENT_NUM, &obj));
 	if (ret < 0)
 		goto out;
 	if (!*(uint64_t *)obj.data) {
@@ -650,22 +728,40 @@ const uint64_t count_unit_divisors[] = {
 };
 
 const char size_unit_abbrevs[] = " BKMGT";
-const char count_unit_abbrevs[] = "  KMGT";
+const char count_unit_abbrevs[] = "  kmgt";
 
-static void format_size_value(enum enum_size_unit unit, uint64_t value, char *result)
+static enum enum_size_unit format_size_value(enum enum_size_unit unit,
+		uint64_t value, int print_unit, char *result)
 {
+	enum enum_size_unit u = unit;
+	char unit_buf[2] = "\0\0";
+
 	if (unit == size_unit_arg_h) /* human readable */
-		for (unit = size_unit_arg_b; unit < size_unit_arg_t && value > size_unit_divisors[unit + 1]; unit++)
-				; /* nothing */
-	sprintf(result, "%llu%c", (long long unsigned)value / size_unit_divisors[unit], size_unit_abbrevs[unit]);
+		for (u = size_unit_arg_b; u < size_unit_arg_t &&
+				value > size_unit_divisors[u + 1]; u++)
+			; /* nothing */
+	if (print_unit)
+		unit_buf[0] = size_unit_abbrevs[u];
+	sprintf(result, "%llu%s",
+		(long long unsigned)value / size_unit_divisors[u], unit_buf);
+	return u;
 }
 
-static void format_count_value(enum enum_count_unit unit, uint64_t value, char *result)
+static enum enum_count_unit format_count_value(enum enum_count_unit unit,
+		uint64_t value, int print_unit, char *result)
 {
+	enum enum_count_unit u = unit;
+	char unit_buf[2] = "\0\0";
+
 	if (unit == count_unit_arg_h) /* human readable */
-		for (unit = count_unit_arg_n; unit < count_unit_arg_t && value > count_unit_divisors[unit + 1]; unit++)
-				; /* nothing */
-	sprintf(result, "%llu%c", (long long unsigned)value / count_unit_divisors[unit], count_unit_abbrevs[unit]);
+		for (u = count_unit_arg_n; u < count_unit_arg_t &&
+				value > count_unit_divisors[u + 1]; u++)
+			; /* nothing */
+	if (print_unit)
+		unit_buf[0] = count_unit_abbrevs[u];
+	sprintf(result, "%llu%s",
+		(long long unsigned)value / count_unit_divisors[u], unit_buf);
+	return u;
 }
 
 enum global_stats_flags {
@@ -677,6 +773,8 @@ enum global_stats_flags {
 
 struct global_stats_info {
 	uint32_t count;
+	int ret;
+	int osl_errno;
 	enum global_stats_flags flags;
 };
 
@@ -684,73 +782,93 @@ static int global_stats_loop_function(struct osl_row *row, void *data)
 {
 	struct global_stats_info *gsi = data;
 	struct osl_object obj;
-	char *dirname, formated_value[25];
+	char *dirname, formated_value[FORMATED_VALUE_SIZE];
 	int ret, summary = gsi->flags & GSF_COMPUTE_SUMMARY;
 
-	if (!gsi->count && !summary)
-		return -E_LOOP_COMPLETE;
-	if (gsi->count && (gsi->flags & GSF_PRINT_DIRNAME)) {
-		ret = get_dir_name_of_row(row, &dirname);
-		if (ret < 0)
-			return ret;
-		printf("%s%s", dirname,
-			(gsi->flags & (GSF_PRINT_FILES | GSF_PRINT_BYTES))?
-				"\t" : "\n"
-		);
+	check_signals();
+	if (!gsi->count && !summary) {
+		ret = -E_LOOP_COMPLETE;
+		goto err;
 	}
 	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,
+			format_count_value(conf.count_unit_arg, files,
+				conf.count_unit_arg == count_unit_arg_h,
 				formated_value);
-			printf("%s%s", formated_value,
-				(gsi->flags & GSF_PRINT_BYTES)? "\t" : "\n");
+			printf("\t%s%s", formated_value,
+				(gsi->flags & (GSF_PRINT_BYTES | GSF_PRINT_DIRNAME))?
+				"\t" : "\n");
 		}
 		if (summary)
 			num_files += files;
 	}
 	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,
+				conf.size_unit_arg == size_unit_arg_h,
 				formated_value);
-			printf("%s\n", formated_value);
+			printf("%s%s%s",
+				(gsi->flags & GSF_PRINT_FILES)? "" : "\t",
+				formated_value,
+				(gsi->flags & GSF_PRINT_DIRNAME)? "\t" : "\n"
+			);
 		}
 		if (summary) {
 			num_bytes += bytes;
 			num_dirs++;
 		}
 	}
+	if (gsi->count && (gsi->flags & GSF_PRINT_DIRNAME)) {
+		ret = get_dir_name_of_row(row, &dirname);
+		if (ret < 0)
+			goto err;
+		printf("%s%s\n",
+			(gsi->flags & (GSF_PRINT_BYTES | GSF_PRINT_FILES))? "" : "\t",
+			dirname);
+		free(dirname);
+	}
 	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)
 {
 	struct user_info *ui;
 
-	printf("--------------------- user summary (uid/dirs/files/bytes):\n");
+	printf("User summary "
+		"(uid/dirs%s/files%s/size%s):\n",
+		count_unit_buf, count_unit_buf, size_unit_buf);
 	FOR_EACH_USER(ui) {
-		char formated_dir_count[25], formated_file_count[25],
-			formated_bytes[25];
-		if (!ui_used(ui))
+		char formated_dir_count[FORMATED_VALUE_SIZE],
+			formated_file_count[FORMATED_VALUE_SIZE],
+			formated_bytes[FORMATED_VALUE_SIZE ];
+		if (!ui_used(ui) || !ui_admissible(ui))
 			continue;
 		format_count_value(conf.count_unit_arg, ui->dirs,
+			conf.count_unit_arg == count_unit_arg_h,
 			formated_dir_count);
 		format_count_value(conf.count_unit_arg, ui->files,
+			conf.count_unit_arg == count_unit_arg_h,
 			formated_file_count);
 		format_size_value(conf.size_unit_arg, ui->bytes,
+			conf.size_unit_arg == size_unit_arg_h,
 			formated_bytes);
-		printf("%u\t%s\t%s\t%s\n", (unsigned)ui->uid,
+		printf("\t%u\t%s\t%s\t%s\n", (unsigned)ui->uid,
 			formated_dir_count,
 			formated_file_count,
 			formated_bytes
@@ -768,6 +886,8 @@ 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;
 };
 
@@ -776,35 +896,26 @@ static int user_stats_loop_function(struct osl_row *row, void *data)
 	struct user_stats_info *usi = data;
 	struct osl_object obj;
 	int ret, summary = usi->flags & GSF_COMPUTE_SUMMARY;
-	char formated_value[25];
+	char formated_value[FORMATED_VALUE_SIZE];
 
-	if (!usi->count && !summary)
-		return -E_LOOP_COMPLETE;
-	if (usi->count && (usi->flags & USF_PRINT_DIRNAME)) {
-		char *dirname;
-		ret = osl_get_object(usi->ui->table, row, UT_DIR_NUM, &obj);
-		if (ret < 0)
-			return ret;
-		ret = get_dir_name_by_number((uint64_t *)obj.data, &dirname);
-		if (ret < 0)
-			return ret;
-		printf("%s%s",
-			dirname,
-			(usi->flags & (USF_PRINT_FILES | USF_PRINT_BYTES))?
-				"\t" : "\n"
-		);
+	check_signals();
+	if (!usi->count && !summary) {
+		ret = -E_LOOP_COMPLETE;
+		goto err;
 	}
 	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,
+			format_count_value(conf.count_unit_arg, files,
+				conf.count_unit_arg == count_unit_arg_h,
 				formated_value);
-			printf("%s%s", formated_value,
-				(usi->flags & USF_PRINT_BYTES)? "\t" : "\n"
+			printf("\t%s%s", formated_value,
+				(usi->flags & (USF_PRINT_BYTES | USF_PRINT_DIRNAME))?
+					"\t" : "\n"
 			);
 		}
 		if (summary)
@@ -812,14 +923,19 @@ 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,
+				conf.size_unit_arg == size_unit_arg_h,
 				formated_value);
-			printf("%s\n", formated_value);
+			printf("%s%s%s",
+				(usi->flags & USF_PRINT_FILES)? "" : "\t",
+				formated_value,
+				usi->flags & USF_PRINT_DIRNAME?  "\t" : "\n"
+			);
 		}
 		if (summary) {
 			usi->ui->bytes += bytes;
@@ -827,14 +943,57 @@ static int user_stats_loop_function(struct osl_row *row, void *data)
 		}
 
 	}
+	if (usi->count && (usi->flags & USF_PRINT_DIRNAME)) {
+		char *dirname;
+		ret = osl(osl_get_object(usi->ui->table, row, UT_DIR_NUM, &obj));
+		if (ret < 0)
+			goto err;
+		ret = get_dir_name_by_number((uint64_t *)obj.data, &dirname);
+		if (ret < 0)
+			goto err;
+		printf("%s%s\n",
+			(usi->flags & (USF_PRINT_BYTES | USF_PRINT_FILES))? "" : "\t",
+			dirname);
+		free(dirname);
+	}
 	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 = {
@@ -844,17 +1003,45 @@ static void print_user_stats(void)
 		if (!ui_used(ui) || !ui_admissible(ui))
 			continue;
 		usi.flags = USF_PRINT_DIRNAME | USF_PRINT_BYTES | USF_COMPUTE_SUMMARY;
-		printf("************************************************ uid %u\n",
-			(unsigned) ui->uid);
-		printf("----------------- Largest dirs -------------------\n");
-		osl_rbtree_loop_reverse(ui->table, UT_BYTES, &usi,
-			user_stats_loop_function);
-		printf("---------- dirs containing most files ------------\n");
+		printf("uid %u, by size%s:\n",
+			(unsigned) ui->uid, size_unit_buf);
+		ret = adu_loop_reverse(ui->table, UT_BYTES, &usi, user_stats_loop_function,
+			&usi.ret, &usi.osl_errno);
+		if (ret < 0)
+			return ret;
+		printf("\nuid %u, by file count%s:\n",
+			(unsigned) ui->uid, count_unit_buf);
 		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;
+		printf("\n");
 	}
+	return 1;
+}
+
+static void print_global_summary(void)
+{
+	char d[FORMATED_VALUE_SIZE], f[FORMATED_VALUE_SIZE],
+		s[FORMATED_VALUE_SIZE];
+	enum enum_count_unit ud, uf;
+	enum enum_size_unit us;
+
+	ud = format_count_value(conf.count_unit_arg, num_dirs, 0, d);
+	uf = format_count_value(conf.count_unit_arg, num_files, 0, f);
+	us = format_size_value(conf.size_unit_arg, num_bytes, 0, s);
+
+	printf("Global summary "
+		"(dirs(%c)/files(%c)/size(%c))\n"
+		"\t%s\t%s\t%s\n\n",
+		count_unit_abbrevs[ud],
+		count_unit_abbrevs[uf],
+		size_unit_abbrevs[us],
+		d, f, s
+	);
+
 }
 
 static int print_statistics(void)
@@ -865,24 +1052,24 @@ static int print_statistics(void)
 		.flags = GSF_PRINT_DIRNAME | GSF_PRINT_BYTES | GSF_COMPUTE_SUMMARY
 	};
 
-	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)
+	printf("By size%s:\n",
+		size_unit_buf);
+	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;
+	printf("\n");
 
+	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)
+	printf("By file count%s:\n",
+		count_unit_buf);
+	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,
-		(long long unsigned)num_bytes);
+	printf("\n");
+	print_global_summary();
 	print_user_stats();
 	print_id_stats();
 	return 1;
@@ -921,57 +1108,8 @@ 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);
-}
-
-static void close_dir_table(void)
-{
-	int ret;
-
-	if (!dir_table)
-		return;
-	ret = osl_close_table(dir_table, OSL_MARK_CLEAN);
-	if (ret < 0)
-		ERROR_LOG("failed to close dir table: %s\n", error_txt(-ret));
-	free((char *)dir_table_desc.dir);
-	dir_table = NULL;
-}
-
-static void close_user_table(struct user_info *ui)
-{
-	int ret;
-
-	if (!ui || !ui_used(ui) || !ui_admissible(ui))
-		return;
-	ret = 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));
-	free((char *)ui->desc->name);
-	ui->desc->name = NULL;
-	free((char *)ui->desc->dir);
-	ui->desc->dir = NULL;
-	free(ui->desc);
-	ui->desc = NULL;
-	ui->table = NULL;
-	ui->flags = 0;
-}
-
-static void close_user_tables(void)
-{
-	struct user_info *ui;
-
-	FOR_EACH_USER(ui)
-		close_user_table(ui);
-}
-
-static void close_all_tables(void)
-{
-	close_dir_table();
-	close_user_tables();
-	free_hash_table();
+	return osl(osl_open_table(&dir_table_desc, &dir_table));
 }
-
 static int com_create()
 {
 	uint64_t zero = 0ULL;
@@ -979,9 +1117,11 @@ static int com_create()
 
 	if (ret < 0)
 		return ret;
+	check_signals();
 	ret = open_dir_table();
 	if (ret < 0)
 		return ret;
+	check_signals();
 	ret = scan_dir(conf.base_dir_arg, &zero);
 	if (ret < 0)
 		goto out;
@@ -1026,12 +1166,23 @@ static int com_select(void)
 {
 	int ret;
 
+	if (conf.count_unit_arg != count_unit_arg_h)
+		count_unit_buf[1] = count_unit_abbrevs[conf.count_unit_arg];
+	else
+		count_unit_buf[0] = '\0';
+	if (conf.size_unit_arg != size_unit_arg_h)
+		size_unit_buf[1] = size_unit_abbrevs[conf.size_unit_arg];
+	else
+		size_unit_buf[0] = '\0';
+
 	ret = open_dir_table();
 	if (ret < 0)
 		return ret;
+	check_signals();
 	ret = read_uid_file();
 	if (ret < 0)
 		return ret;
+	check_signals();
 	ret = print_statistics();
 	close_all_tables();
 	return ret;
@@ -1041,11 +1192,22 @@ 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)
@@ -1070,6 +1232,9 @@ int main(int argc, char **argv)
 	};
 
 	cmdline_parser_ext(argc, argv, &conf, &params); /* aborts on errors */
+	ret = init_signals();
+	if (ret < 0)
+		goto out;
 	ret = check_args();
 	if (ret < 0)
 		goto out;
@@ -1083,7 +1248,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;