select.c

   1 /*
   2  * Copyright (C) 2008 Andre Noll <maan@systemlinux.org>
   3  *
   4  * Licensed under the GPL v2. For licencing details see COPYING.
   5  */
   6
   7 /** \file select.c The select mode of adu. */
   8
   9 #include <dirent.h> /* readdir() */
  10 #include "adu.h"
  11 #include "gcc-compat.h"
  12 #include "cmdline.h"
  13 #include "fd.h"
  14 #include "string.h"
  15 #include "error.h"
  16 #include "portable_io.h"
  17
  18 /** Global dir count. */
  19 static uint64_t num_dirs;
  20 /** Global files count. */
  21 static uint64_t num_files;
  22 /** Global bytes count. */
  23 static uint64_t num_bytes;
  24
  25 /** The decimal representation of an uint64_t never exceeds that size. */
  26 #define FORMATED_VALUE_SIZE 25
  27
  28 /* these get filled in by the select command. */
  29 static char count_unit_buf[4] = "( )", size_unit_buf[4] = "( )";
  30
  31 enum global_stats_flags {
  32         GSF_PRINT_DIRNAME = 1,
  33         GSF_PRINT_BYTES = 2,
  34         GSF_PRINT_FILES = 4,
  35         GSF_COMPUTE_SUMMARY = 8,
  36 };
  37
  38 struct global_stats_info {
  39         uint32_t count;
  40         int ret;
  41         int osl_errno;
  42         enum global_stats_flags flags;
  43 };
  44
  45 enum user_stats_flags {
  46         USF_PRINT_DIRNAME = 1,
  47         USF_PRINT_BYTES = 2,
  48         USF_PRINT_FILES = 4,
  49         USF_COMPUTE_SUMMARY = 8,
  50 };
  51
  52 struct user_stats_info {
  53         uint32_t count;
  54         enum user_stats_flags flags;
  55         int ret;
  56         int osl_errno;
  57         struct user_info *ui;
  58 };
  59
  60 static const uint64_t size_unit_divisors[] = {
  61         [size_unit_arg_b] = 1ULL,
  62         [size_unit_arg_k] = 1024ULL,
  63         [size_unit_arg_m] = 1024ULL * 1024ULL,
  64         [size_unit_arg_g] = 1024ULL * 1024ULL * 1024ULL,
  65         [size_unit_arg_t] = 1024ULL * 1024ULL * 1024ULL * 1024ULL,
  66 };
  67
  68 static const uint64_t count_unit_divisors[] = {
  69
  70         [count_unit_arg_n] = 1ULL,
  71         [count_unit_arg_k] = 1000ULL,
  72         [count_unit_arg_m] = 1000ULL * 1000ULL,
  73         [count_unit_arg_g] = 1000ULL * 1000ULL * 1000ULL,
  74         [count_unit_arg_t] = 1000ULL * 1000ULL * 1000ULL * 1000ULL,
  75 };
  76
  77 static const char size_unit_abbrevs[] = " BKMGT";
  78 static const char count_unit_abbrevs[] = "  kmgt";
  79
  80 static enum enum_size_unit format_size_value(enum enum_size_unit unit,
  81                 uint64_t value, int print_unit, char *result)
  82 {
  83         enum enum_size_unit u = unit;
  84         char unit_buf[2] = "\0\0";
  85
  86         if (unit == size_unit_arg_h) /* human readable */
  87                 for (u = size_unit_arg_b; u < size_unit_arg_t &&
  88                                 value > size_unit_divisors[u + 1]; u++)
  89                         ; /* nothing */
  90         if (print_unit)
  91                 unit_buf[0] = size_unit_abbrevs[u];
  92         sprintf(result, "%llu%s",
  93                 (long long unsigned)value / size_unit_divisors[u], unit_buf);
  94         return u;
  95 }
  96
  97 static enum enum_count_unit format_count_value(enum enum_count_unit unit,
  98                 uint64_t value, int print_unit, char *result)
  99 {
 100         enum enum_count_unit u = unit;
 101         char unit_buf[2] = "\0\0";
 102
 103         if (unit == count_unit_arg_h) /* human readable */
 104                 for (u = count_unit_arg_n; u < count_unit_arg_t &&
 105                                 value > count_unit_divisors[u + 1]; u++)
 106                         ; /* nothing */
 107         if (print_unit)
 108                 unit_buf[0] = count_unit_abbrevs[u];
 109         sprintf(result, "%llu%s",
 110                 (long long unsigned)value / count_unit_divisors[u], unit_buf);
 111         return u;
 112 }
 113
 114 static int get_dir_name_by_number(uint64_t *dirnum, char **name)
 115 {
 116         char *result = NULL, *tmp;
 117         struct osl_row *row;
 118         uint64_t val = *dirnum;
 119         struct osl_object obj = {.data = &val, .size = sizeof(val)};
 120         int ret;
 121
 122 again:
 123         ret = osl(osl_get_row(dir_table, DT_NUM, &obj, &row));
 124         if (ret < 0)
 125                 goto out;
 126         ret = osl(osl_get_object(dir_table, row, DT_NAME, &obj));
 127         if (ret < 0)
 128                 goto out;
 129         if (result) {
 130                 tmp = make_message("%s/%s", (char *)obj.data, result);
 131                 free(result);
 132                 result = tmp;
 133         } else
 134                 result = adu_strdup((char *)obj.data);
 135         ret = osl(osl_get_object(dir_table, row, DT_PARENT_NUM, &obj));
 136         if (ret < 0)
 137                 goto out;
 138         val = *(uint64_t *)obj.data;
 139         if (val)
 140                 goto again;
 141 out:
 142         if (ret < 0) {
 143                 free(result);
 144                 *name = NULL;
 145         } else
 146                 *name = result;
 147         return ret;
 148 }
 149
 150 static int get_dir_name_of_row(struct osl_row *dir_table_row, char **name)
 151 {
 152         struct osl_object obj;
 153         int ret;
 154         char *this_dir, *prefix = NULL;
 155
 156         *name = NULL;
 157         ret = osl(osl_get_object(dir_table, dir_table_row, DT_NAME, &obj));
 158         if (ret < 0)
 159                 return ret;
 160         this_dir = adu_strdup((char *)obj.data);
 161         ret = osl(osl_get_object(dir_table, dir_table_row, DT_PARENT_NUM, &obj));
 162         if (ret < 0)
 163                 goto out;
 164         if (!*(uint64_t *)obj.data) {
 165                 *name = this_dir;
 166                 return 1;
 167         }
 168         ret = get_dir_name_by_number((uint64_t *)obj.data, &prefix);
 169         if (ret < 0)
 170                 goto out;
 171         *name = make_message("%s/%s", prefix, this_dir);
 172         free(prefix);
 173         ret = 1;
 174 out:
 175         free(this_dir);
 176         return ret;
 177 }
 178 static int user_stats_loop_function(struct osl_row *row, void *data)
 179 {
 180         struct user_stats_info *usi = data;
 181         struct osl_object obj;
 182         int ret, summary = usi->flags & GSF_COMPUTE_SUMMARY;
 183         char formated_value[FORMATED_VALUE_SIZE];
 184
 185         check_signals();
 186         if (!usi->count && !summary) {
 187                 ret = -E_LOOP_COMPLETE;
 188                 goto err;
 189         }
 190         if (summary || (usi->count && (usi->flags & USF_PRINT_FILES))) {
 191                 uint64_t files;
 192                 ret = osl(osl_get_object(usi->ui->table, row, UT_FILES, &obj));
 193                 if (ret < 0)
 194                         goto err;
 195                 files = *(uint64_t *)obj.data;
 196                 if (usi->count && (usi->flags & USF_PRINT_FILES)) {
 197                         format_count_value(conf.count_unit_arg, files,
 198                                 conf.count_unit_arg == count_unit_arg_h,
 199                                 formated_value);
 200                         printf("\t%s%s", formated_value,
 201                                 (usi->flags & (USF_PRINT_BYTES | USF_PRINT_DIRNAME))?
 202                                         "\t" : "\n"
 203                         );
 204                 }
 205                 if (summary)
 206                         usi->ui->files += files;
 207         }
 208         if (summary || (usi->count && (usi->flags & USF_PRINT_BYTES))) {
 209                 uint64_t bytes;
 210                 ret = osl(osl_get_object(usi->ui->table, row, UT_BYTES, &obj));
 211                 if (ret < 0)
 212                         goto err;
 213                 bytes = *(uint64_t *)obj.data;
 214                 if (usi->count && (usi->flags & USF_PRINT_BYTES)) {
 215                         format_size_value(conf.size_unit_arg, bytes,
 216                                 conf.size_unit_arg == size_unit_arg_h,
 217                                 formated_value);
 218                         printf("%s%s%s",
 219                                 (usi->flags & USF_PRINT_FILES)? "" : "\t",
 220                                 formated_value,
 221                                 usi->flags & USF_PRINT_DIRNAME?  "\t" : "\n"
 222                         );
 223                 }
 224                 if (summary) {
 225                         usi->ui->bytes += bytes;
 226                         usi->ui->dirs++;
 227                 }
 228
 229         }
 230         if (usi->count && (usi->flags & USF_PRINT_DIRNAME)) {
 231                 char *dirname;
 232                 ret = osl(osl_get_object(usi->ui->table, row, UT_DIR_NUM, &obj));
 233                 if (ret < 0)
 234                         goto err;
 235                 ret = get_dir_name_by_number((uint64_t *)obj.data, &dirname);
 236                 if (ret < 0)
 237                         goto err;
 238                 printf("%s%s\n",
 239                         (usi->flags & (USF_PRINT_BYTES | USF_PRINT_FILES))? "" : "\t",
 240                         dirname);
 241                 free(dirname);
 242         }
 243         if (usi->count > 0)
 244                 usi->count--;
 245         return 1;
 246 err:
 247         usi->ret = ret;
 248         usi->osl_errno = (ret == -E_OSL)? osl_errno : 0;
 249         return -1;
 250 }
 251
 252 static int global_stats_loop_function(struct osl_row *row, void *data)
 253 {
 254         struct global_stats_info *gsi = data;
 255         struct osl_object obj;
 256         char *dirname, formated_value[FORMATED_VALUE_SIZE];
 257         int ret, summary = gsi->flags & GSF_COMPUTE_SUMMARY;
 258
 259         check_signals();
 260         if (!gsi->count && !summary) {
 261                 ret = -E_LOOP_COMPLETE;
 262                 goto err;
 263         }
 264         if (summary || (gsi->count && (gsi->flags & GSF_PRINT_FILES))) {
 265                 uint64_t files;
 266                 ret = osl(osl_get_object(dir_table, row, DT_FILES, &obj));
 267                 if (ret < 0)
 268                         goto err;
 269                 files = *(uint64_t *)obj.data;
 270                 if (gsi->count && (gsi->flags & GSF_PRINT_FILES)) {
 271                         format_count_value(conf.count_unit_arg, files,
 272                                 conf.count_unit_arg == count_unit_arg_h,
 273                                 formated_value);
 274                         printf("\t%s%s", formated_value,
 275                                 (gsi->flags & (GSF_PRINT_BYTES | GSF_PRINT_DIRNAME))?
 276                                 "\t" : "\n");
 277                 }
 278                 if (summary)
 279                         num_files += files;
 280         }
 281         if (summary || (gsi->count && (gsi->flags & GSF_PRINT_BYTES))) {
 282                 uint64_t bytes;
 283                 ret = osl(osl_get_object(dir_table, row, DT_BYTES, &obj));
 284                 if (ret < 0)
 285                         goto err;
 286                 bytes = *(uint64_t *)obj.data;
 287                 if (gsi->count && (gsi->flags & GSF_PRINT_BYTES)) {
 288                         format_size_value(conf.size_unit_arg, bytes,
 289                                 conf.size_unit_arg == size_unit_arg_h,
 290                                 formated_value);
 291                         printf("%s%s%s",
 292                                 (gsi->flags & GSF_PRINT_FILES)? "" : "\t",
 293                                 formated_value,
 294                                 (gsi->flags & GSF_PRINT_DIRNAME)? "\t" : "\n"
 295                         );
 296                 }
 297                 if (summary) {
 298                         num_bytes += bytes;
 299                         num_dirs++;
 300                 }
 301         }
 302         if (gsi->count && (gsi->flags & GSF_PRINT_DIRNAME)) {
 303                 ret = get_dir_name_of_row(row, &dirname);
 304                 if (ret < 0)
 305                         goto err;
 306                 printf("%s%s\n",
 307                         (gsi->flags & (GSF_PRINT_BYTES | GSF_PRINT_FILES))? "" : "\t",
 308                         dirname);
 309                 free(dirname);
 310         }
 311         if (gsi->count > 0)
 312                 gsi->count--;
 313         return 1;
 314 err:
 315         gsi->ret = ret;
 316         gsi->osl_errno = (ret == -E_OSL)? osl_errno : 0;
 317         return -1;
 318 }
 319
 320 static int check_loop_return(int ret, int loop_ret, int loop_osl_errno)
 321 {
 322         if (ret >= 0)
 323                 return ret;
 324         assert(ret == -E_OSL);
 325         if (osl_errno != E_OSL_LOOP)
 326                 /* error not caused by loop function returning negative. */
 327                 return ret;
 328         assert(loop_ret < 0);
 329         if (loop_ret == -E_LOOP_COMPLETE) /* no error */
 330                 return 1;
 331         if (loop_ret == -E_OSL) { /* osl error in loop function */
 332                 assert(loop_osl_errno);
 333                 osl_errno = loop_osl_errno;
 334         }
 335         return loop_ret;
 336 }
 337
 338 static int adu_loop_reverse(struct osl_table *t, unsigned col_num, void *private_data,
 339                 osl_rbtree_loop_func *func, int *loop_ret, int *loop_osl_errno)
 340 {
 341         int ret = osl(osl_rbtree_loop_reverse(t, col_num, private_data, func));
 342         return check_loop_return(ret, *loop_ret, *loop_osl_errno);
 343 }
 344
 345 static void print_global_summary(void)
 346 {
 347         char d[FORMATED_VALUE_SIZE], f[FORMATED_VALUE_SIZE],
 348                 s[FORMATED_VALUE_SIZE];
 349         enum enum_count_unit ud, uf;
 350         enum enum_size_unit us;
 351
 352         ud = format_count_value(conf.count_unit_arg, num_dirs, 0, d);
 353         uf = format_count_value(conf.count_unit_arg, num_files, 0, f);
 354         us = format_size_value(conf.size_unit_arg, num_bytes, 0, s);
 355
 356         printf("Global summary "
 357                 "(dirs(%c)/files(%c)/size(%c))\n"
 358                 "\t%s\t%s\t%s\n\n",
 359                 count_unit_abbrevs[ud],
 360                 count_unit_abbrevs[uf],
 361                 size_unit_abbrevs[us],
 362                 d, f, s
 363         );
 364
 365 }
 366
 367 static int print_user_summary_line(struct user_info *ui, __a_unused void *data)
 368 {
 369         char formated_dir_count[FORMATED_VALUE_SIZE],
 370                 formated_file_count[FORMATED_VALUE_SIZE],
 371                 formated_bytes[FORMATED_VALUE_SIZE ];
 372
 373         format_count_value(conf.count_unit_arg, ui->dirs,
 374                 conf.count_unit_arg == count_unit_arg_h,
 375                 formated_dir_count);
 376         format_count_value(conf.count_unit_arg, ui->files,
 377                 conf.count_unit_arg == count_unit_arg_h,
 378                 formated_file_count);
 379         format_size_value(conf.size_unit_arg, ui->bytes,
 380                 conf.size_unit_arg == size_unit_arg_h,
 381                 formated_bytes);
 382         printf("\t%s\t%u\t%s\t%s\t%s\n",
 383                 ui->pw_name? ui->pw_name : "?",
 384                 (unsigned)ui->uid,
 385                 formated_dir_count,
 386                 formated_file_count,
 387                 formated_bytes
 388         );
 389         return 1;
 390 }
 391
 392 static void print_user_summary(void)
 393 {
 394         printf("User summary "
 395                 "(pw_name/uid/dirs%s/files%s/size%s):\n",
 396                 count_unit_buf, count_unit_buf, size_unit_buf);
 397         for_each_admissible_user(print_user_summary_line, NULL);
 398 }
 399
 400 static int print_user_stat(struct user_info *ui, __a_unused void *data)
 401 {
 402         int ret;
 403         struct user_stats_info usi = {
 404                 .count = conf.limit_arg,
 405                 .ui = ui
 406         };
 407
 408         usi.flags = USF_PRINT_DIRNAME | USF_PRINT_BYTES | USF_COMPUTE_SUMMARY;
 409         printf("%s (uid %u), by size%s:\n",
 410                 ui->pw_name? ui->pw_name : "?", (unsigned)ui->uid,
 411                 size_unit_buf);
 412         ret = adu_loop_reverse(ui->table, UT_BYTES, &usi, user_stats_loop_function,
 413                 &usi.ret, &usi.osl_errno);
 414         if (ret < 0)
 415                 return ret;
 416         printf("\n%s (uid %u), by file count%s:\n",
 417                 ui->pw_name? ui->pw_name : "?", (unsigned)ui->uid,
 418                 count_unit_buf);
 419         usi.count = conf.limit_arg,
 420         usi.flags = USF_PRINT_DIRNAME | USF_PRINT_FILES;
 421         ret = adu_loop_reverse(ui->table, UT_FILES, &usi, user_stats_loop_function,
 422                 &usi.ret, &usi.osl_errno);
 423         if (ret < 0)
 424                 return ret;
 425         printf("\n");
 426         return 1;
 427 }
 428
 429 static int print_user_stats(void)
 430 {
 431         return for_each_admissible_user(print_user_stat, NULL);
 432 }
 433
 434 static int print_statistics(void)
 435 {
 436         int ret;
 437         struct global_stats_info gsi = {
 438                 .count = conf.limit_arg,
 439                 .flags = GSF_PRINT_DIRNAME | GSF_PRINT_BYTES | GSF_COMPUTE_SUMMARY
 440         };
 441
 442         printf("By size%s:\n",
 443                 size_unit_buf);
 444         ret = adu_loop_reverse(dir_table, DT_BYTES, &gsi,
 445                 global_stats_loop_function, &gsi.ret, &gsi.osl_errno);
 446         if (ret < 0)
 447                 return ret;
 448         printf("\n");
 449
 450         gsi.count = conf.limit_arg;
 451         gsi.flags = GSF_PRINT_DIRNAME | GSF_PRINT_FILES;
 452         printf("By file count%s:\n",
 453                 count_unit_buf);
 454         ret = adu_loop_reverse(dir_table, DT_FILES, &gsi,
 455                 global_stats_loop_function, &gsi.ret, &gsi.osl_errno);
 456         if (ret < 0)
 457                 return ret;
 458         printf("\n");
 459         print_global_summary();
 460         print_user_stats();
 461         print_user_summary();
 462         return 1;
 463 }
 464
 465 static int read_uid_file(void)
 466 {
 467         size_t size;
 468         uint32_t n;
 469         char *filename = get_uid_list_name(), *map;
 470         int ret = mmap_full_file(filename, O_RDONLY, (void **)&map, &size, NULL);
 471         unsigned bits;
 472
 473         if (ret < 0) {
 474                 INFO_LOG("failed to map %s\n", filename);
 475                 free(filename);
 476                 return ret;
 477         }
 478         num_uids = size / 4;
 479         INFO_LOG("found %u uids in %s\n", (unsigned)num_uids, filename);
 480         free(filename);
 481         /*
 482          * Compute number of hash table bits. The hash table size must be a
 483          * power of two and larger than the number of uids.
 484          */
 485         bits = 2;
 486         while (1 << bits < num_uids)
 487                 bits++;
 488         create_hash_table(bits);
 489         for (n = 0; n < num_uids; n++) {
 490                 uint32_t uid = read_u32(map + n * sizeof(uid));
 491                 ret = search_uid(uid, OPEN_USER_TABLE, NULL);
 492                 if (ret < 0)
 493                         goto out;
 494         }
 495 out:
 496         adu_munmap(map, size);
 497         return ret;
 498 }
 499
 500 int com_select(void)
 501 {
 502         int ret;
 503
 504         if (conf.count_unit_arg != count_unit_arg_h)
 505                 count_unit_buf[1] = count_unit_abbrevs[conf.count_unit_arg];
 506         else
 507                 count_unit_buf[0] = '\0';
 508         if (conf.size_unit_arg != size_unit_arg_h)
 509                 size_unit_buf[1] = size_unit_abbrevs[conf.size_unit_arg];
 510         else
 511                 size_unit_buf[0] = '\0';
 512
 513         ret = open_dir_table(0);
 514         if (ret < 0)
 515                 return ret;
 516         check_signals();
 517         ret = read_uid_file();
 518         if (ret < 0)
 519                 return ret;
 520         check_signals();
 521         ret = print_statistics();
 522         close_all_tables();
 523         return ret;
 524 }