X-Git-Url: http://git.tuebingen.mpg.de/?p=adu.git;a=blobdiff_plain;f=adu.c;h=3a676c4dd29dc6c33c09001d12a9aedfdbc712ba;hp=deb3e94ccd88bf309263b57a87e307de9e00944c;hb=f5049d14a17ddcd0fe70e55090086f2f70ff5de1;hpb=9136aabe2adc143a9ceff69bf5449bf87976dce6

diff --git a/adu.c b/adu.c
index deb3e94..3a676c4 100644
--- a/adu.c
+++ b/adu.c
@@ -31,6 +31,10 @@ struct user_info {
 	struct osl_table_description *desc;
 };
 
+/** The decimal representation of an uint64_t never exceeds that size. */
+#define FORMATED_VALUE_SIZE 25
+
+
 /**
  * Contains info for each user that owns at least one regular file.
  *
@@ -40,6 +44,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;
@@ -80,10 +87,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;
@@ -650,22 +655,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 +700,8 @@ enum global_stats_flags {
 
 struct global_stats_info {
 	uint32_t count;
+	int ret;
+	int osl_errno;
 	enum global_stats_flags flags;
 };
 
@@ -684,31 +709,26 @@ 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"
-		);
+	if (!gsi->count && !summary) {
+		ret = -E_LOOP_COMPLETE;
+		goto err;
 	}
 	if (summary || (gsi->count && (gsi->flags & GSF_PRINT_FILES))) {
 		uint64_t files;
 		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;
@@ -717,40 +737,64 @@ static int global_stats_loop_function(struct osl_row *row, void *data)
 		uint64_t bytes;
 		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 +812,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 +822,25 @@ 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(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"
-		);
+	if (!usi->count && !summary) {
+		ret = -E_LOOP_COMPLETE;
+		goto err;
 	}
 	if (summary || (usi->count && (usi->flags & USF_PRINT_FILES))) {
 		uint64_t files;
 		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)
@@ -814,12 +850,17 @@ static int user_stats_loop_function(struct osl_row *row, void *data)
 		uint64_t bytes;
 		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 +868,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 +928,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(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(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 +977,24 @@ static int print_statistics(void)
 		.flags = GSF_PRINT_DIRNAME | GSF_PRINT_BYTES | GSF_COMPUTE_SUMMARY
 	};
 
-	printf("----------------- Largest dirs -------------------\n");
-	ret = osl(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(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;
@@ -1026,6 +1138,15 @@ 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;