Much nicer output.

	- only print units if not human-readable was selected
	- print sizes/counts before the dirname
	- nice identation
	- human-readable output for global summary

diff --git a/adu.c b/adu.c
index 8af09cd21358c5fa68138c95ef008f86e4db9232..9b800eaf1cb2e75b6b990ba7976049d7d0e82c15 100644 (file)
--- 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;
@@ -648,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 {
@@ -684,22 +709,13 @@ 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) {
                ret = -E_LOOP_COMPLETE;
                goto err;
        }
-       if (gsi->count && (gsi->flags & GSF_PRINT_DIRNAME)) {
-               ret = get_dir_name_of_row(row, &dirname);
-               if (ret < 0)
-                       goto err;
-               printf("%s%s", dirname,
-                       (gsi->flags & (GSF_PRINT_FILES | GSF_PRINT_BYTES))?
-                               "\t" : "\n"
-               );
-       }
        if (summary || (gsi->count && (gsi->flags & GSF_PRINT_FILES))) {
                uint64_t files;
                ret = osl(osl_get_object(dir_table, row, DT_FILES, &obj));
@@ -707,10 +723,12 @@ static int global_stats_loop_function(struct osl_row *row, void *data)
                        goto err;
                files = *(uint64_t *)obj.data;
                if (gsi->count && (gsi->flags & GSF_PRINT_FILES)) {
-                       format_count_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;
@@ -722,15 +740,28 @@ static int global_stats_loop_function(struct osl_row *row, void *data)
                        goto err;
                bytes = *(uint64_t *)obj.data;
                if (gsi->count && (gsi->flags & GSF_PRINT_BYTES)) {
-                       format_count_value(conf.size_unit_arg, 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);
+       }
        if (gsi->count > 0)
                gsi->count--;
        return 1;
@@ -744,19 +775,25 @@ 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];
+               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
@@ -784,26 +821,12 @@ 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) {
                ret = -E_LOOP_COMPLETE;
                goto err;
        }
-       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",
-                       dirname,
-                       (usi->flags & (USF_PRINT_FILES | USF_PRINT_BYTES))?
-                               "\t" : "\n"
-               );
-       }
        if (summary || (usi->count && (usi->flags & USF_PRINT_FILES))) {
                uint64_t files;
                ret = osl(osl_get_object(usi->ui->table, row, UT_FILES, &obj));
@@ -811,10 +834,12 @@ static int user_stats_loop_function(struct osl_row *row, void *data)
                        goto err;
                files = *(uint64_t *)obj.data;
                if (usi->count && (usi->flags & USF_PRINT_FILES)) {
-                       format_count_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)
@@ -827,9 +852,14 @@ static int user_stats_loop_function(struct osl_row *row, void *data)
                        goto err;
                bytes = *(uint64_t *)obj.data;
                if (usi->count && (usi->flags & USF_PRINT_BYTES)) {
-                       format_count_value(conf.size_unit_arg, 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;
@@ -837,6 +867,18 @@ 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);
+       }
        if (usi->count > 0)
                usi->count--;
        return 1;
@@ -884,24 +926,47 @@ static int 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");
+               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("---------- dirs containing most files ------------\n");
+               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;
                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)
 {
        int ret;
@@ -910,23 +975,24 @@ static int print_statistics(void)
                .flags = GSF_PRINT_DIRNAME | GSF_PRINT_BYTES | GSF_COMPUTE_SUMMARY
        };
 
-       printf("----------------- Largest dirs -------------------\n");
+       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");
+       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;
@@ -1070,6 +1136,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;