misc-utils/fincore.c

   1 /*
   2  * fincore - count pages of file contents in core
   3  *
   4  * Copyright (C) 2017 Red Hat, Inc. All rights reserved.
   5  * Written by Masatake YAMATO <yamato@redhat.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it would be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include <sys/mman.h>
  23 #include <sys/stat.h>
  24 #include <unistd.h>
  25 #include <getopt.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28
  29 #include "c.h"
  30 #include "nls.h"
  31 #include "closestream.h"
  32 #include "xalloc.h"
  33 #include "strutils.h"
  34
  35 #include "libsmartcols.h"
  36
  37 /* For large files, mmap is called in iterative way.
  38    Window is the unit of vma prepared in each mmap
  39    calling.
  40
  41    Window size depends on page size.
  42    e.g. 128MB on x86_64. ( = N_PAGES_IN_WINDOW * 4096 ). */
  43 #define N_PAGES_IN_WINDOW ((size_t)(32 * 1024))
  44
  45
  46 struct colinfo {
  47         const char *name;
  48         double whint;
  49         int flags;
  50         const char *help;
  51 };
  52
  53 enum {
  54         COL_PAGES,
  55         COL_SIZE,
  56         COL_FILE,
  57         COL_RES
  58 };
  59
  60 static struct colinfo infos[] = {
  61         [COL_PAGES]  = { "PAGES",    1, SCOLS_FL_RIGHT, N_("file data resident in memory in pages")},
  62         [COL_RES]    = { "RES",      5, SCOLS_FL_RIGHT, N_("file data resident in memory in bytes")},
  63         [COL_SIZE]   = { "SIZE",     5, SCOLS_FL_RIGHT, N_("size of the file")},
  64         [COL_FILE]   = { "FILE",     4, 0, N_("file name")},
  65 };
  66
  67 static int columns[ARRAY_SIZE(infos) * 2] = {-1};
  68 static size_t ncolumns;
  69
  70 struct fincore_control {
  71         const size_t pagesize;
  72
  73         struct libscols_table *tb;              /* output */
  74
  75         unsigned int bytes : 1,
  76                      noheadings : 1,
  77                      raw : 1,
  78                      json : 1;
  79 };
  80
  81
  82 static int column_name_to_id(const char *name, size_t namesz)
  83 {
  84         size_t i;
  85
  86         for (i = 0; i < ARRAY_SIZE(infos); i++) {
  87                 const char *cn = infos[i].name;
  88
  89                 if (!strncasecmp(name, cn, namesz) && !*(cn + namesz))
  90                         return i;
  91         }
  92         warnx(_("unknown column: %s"), name);
  93         return -1;
  94 }
  95
  96 static int get_column_id(int num)
  97 {
  98         assert(num >= 0);
  99         assert((size_t) num < ncolumns);
 100         assert(columns[num] < (int) ARRAY_SIZE(infos));
 101         return columns[num];
 102 }
 103
 104 static const struct colinfo *get_column_info(int num)
 105 {
 106         return &infos[ get_column_id(num) ];
 107 }
 108
 109 static int add_output_data(struct fincore_control *ctl,
 110                            const char *name,
 111                            off_t file_size,
 112                            off_t count_incore)
 113 {
 114         size_t i;
 115         char *tmp;
 116         struct libscols_line *ln;
 117
 118         assert(ctl);
 119         assert(ctl->tb);
 120
 121         ln = scols_table_new_line(ctl->tb, NULL);
 122         if (!ln)
 123                 err(EXIT_FAILURE, _("failed to allocate output line"));
 124
 125         for (i = 0; i < ncolumns; i++) {
 126                 int rc = 0;
 127
 128                 switch(get_column_id(i)) {
 129                 case COL_FILE:
 130                         rc = scols_line_set_data(ln, i, name);
 131                         break;
 132                 case COL_PAGES:
 133                         xasprintf(&tmp, "%jd",  (intmax_t) count_incore);
 134                         rc = scols_line_refer_data(ln, i, tmp);
 135                         break;
 136                 case COL_RES:
 137                 {
 138                         uintmax_t res = (uintmax_t) count_incore * ctl->pagesize;
 139
 140                         if (ctl->bytes)
 141                                 xasprintf(&tmp, "%ju", res);
 142                         else
 143                                 tmp = size_to_human_string(SIZE_SUFFIX_1LETTER, res);
 144                         rc = scols_line_refer_data(ln, i, tmp);
 145                         break;
 146                 }
 147                 case COL_SIZE:
 148                         if (ctl->bytes)
 149                                 xasprintf(&tmp, "%jd", (intmax_t) file_size);
 150                         else
 151                                 tmp = size_to_human_string(SIZE_SUFFIX_1LETTER, file_size);
 152                         rc = scols_line_refer_data(ln, i, tmp);
 153                         break;
 154                 default:
 155                         return -EINVAL;
 156                 }
 157
 158                 if (rc)
 159                         err(EXIT_FAILURE, _("failed to add output data"));
 160         }
 161
 162         return 0;
 163 }
 164
 165 static int do_mincore(struct fincore_control *ctl,
 166                       void *window, const size_t len,
 167                       const char *name,
 168                       off_t *count_incore)
 169 {
 170         static unsigned char vec[N_PAGES_IN_WINDOW];
 171         int n = (len / ctl->pagesize) + ((len % ctl->pagesize)? 1: 0);
 172
 173         if (mincore (window, len, vec) < 0) {
 174                 warn(_("failed to do mincore: %s"), name);
 175                 return -errno;
 176         }
 177
 178         while (n > 0)
 179         {
 180                 if (vec[--n] & 0x1)
 181                 {
 182                         vec[n] = 0;
 183                         (*count_incore)++;
 184                 }
 185         }
 186
 187         return 0;
 188 }
 189
 190 static int fincore_fd (struct fincore_control *ctl,
 191                        int fd,
 192                        const char *name,
 193                        off_t file_size,
 194                        off_t *count_incore)
 195 {
 196         size_t window_size = N_PAGES_IN_WINDOW * ctl->pagesize;
 197         off_t file_offset, len;
 198         int rc = 0;
 199
 200         for (file_offset = 0; file_offset < file_size; file_offset += len) {
 201                 void  *window = NULL;
 202
 203                 len = file_size - file_offset;
 204                 if (len >= (off_t) window_size)
 205                         len = window_size;
 206
 207                 /* PROT_NONE is enough for Linux, but qemu-user wants PROT_READ */
 208                 window = mmap(window, len, PROT_READ, MAP_PRIVATE, fd, file_offset);
 209                 if (window == MAP_FAILED) {
 210                         rc = -EINVAL;
 211                         warn(_("failed to do mmap: %s"), name);
 212                         break;
 213                 }
 214
 215                 rc = do_mincore(ctl, window, len, name, count_incore);
 216                 if (rc)
 217                         break;
 218
 219                 munmap (window, len);
 220         }
 221
 222         return rc;
 223 }
 224
 225 /*
 226  * Returns: <0 on error, 0 success, 1 ignore.
 227  */
 228 static int fincore_name(struct fincore_control *ctl,
 229                         const char *name,
 230                         struct stat *sb,
 231                         off_t *count_incore)
 232 {
 233         int fd;
 234         int rc = 0;
 235
 236         if ((fd = open (name, O_RDONLY)) < 0) {
 237                 warn(_("failed to open: %s"), name);
 238                 return -errno;
 239         }
 240
 241         if (fstat (fd, sb) < 0) {
 242                 warn(_("failed to do fstat: %s"), name);
 243                 close (fd);
 244                 return -errno;
 245         }
 246
 247         if (S_ISDIR(sb->st_mode))
 248                 rc = 1;                 /* ignore */
 249
 250         else if (sb->st_size)
 251                 rc = fincore_fd(ctl, fd, name, sb->st_size, count_incore);
 252
 253         close (fd);
 254         return rc;
 255 }
 256
 257 static void __attribute__((__noreturn__)) usage(void)
 258 {
 259         FILE *out = stdout;
 260         size_t i;
 261
 262         fputs(USAGE_HEADER, out);
 263         fprintf(out, _(" %s [options] file...\n"), program_invocation_short_name);
 264
 265         fputs(USAGE_OPTIONS, out);
 266         fputs(_(" -J, --json            use JSON output format\n"), out);
 267         fputs(_(" -b, --bytes           print sizes in bytes rather than in human readable format\n"), out);
 268         fputs(_(" -n, --noheadings      don't print headings\n"), out);
 269         fputs(_(" -o, --output <list>   output columns\n"), out);
 270         fputs(_(" -r, --raw             use raw output format\n"), out);
 271
 272         fputs(USAGE_SEPARATOR, out);
 273         printf(USAGE_HELP_OPTIONS(23));
 274
 275         fprintf(out, USAGE_COLUMNS);
 276
 277         for (i = 0; i < ARRAY_SIZE(infos); i++)
 278                 fprintf(out, " %11s  %s\n", infos[i].name, _(infos[i].help));
 279
 280         printf(USAGE_MAN_TAIL("fincore(1)"));
 281
 282         exit(EXIT_SUCCESS);
 283 }
 284
 285 int main(int argc, char ** argv)
 286 {
 287         int c;
 288         size_t i;
 289         int rc = EXIT_SUCCESS;
 290         char *outarg = NULL;
 291
 292         struct fincore_control ctl = {
 293                 .pagesize = getpagesize()
 294         };
 295
 296         static const struct option longopts[] = {
 297                 { "bytes",      no_argument, NULL, 'b' },
 298                 { "noheadings", no_argument, NULL, 'n' },
 299                 { "output",     required_argument, NULL, 'o' },
 300                 { "version",    no_argument, NULL, 'V' },
 301                 { "help",       no_argument, NULL, 'h' },
 302                 { "json",       no_argument, NULL, 'J' },
 303                 { "raw",        no_argument, NULL, 'r' },
 304                 { NULL, 0, NULL, 0 },
 305         };
 306
 307         setlocale(LC_ALL, "");
 308         bindtextdomain(PACKAGE, LOCALEDIR);
 309         textdomain(PACKAGE);
 310         close_stdout_atexit();
 311
 312         while ((c = getopt_long (argc, argv, "bno:JrVh", longopts, NULL)) != -1) {
 313                 switch (c) {
 314                 case 'b':
 315                         ctl.bytes = 1;
 316                         break;
 317                 case 'n':
 318                         ctl.noheadings = 1;
 319                         break;
 320                 case 'o':
 321                         outarg = optarg;
 322                         break;
 323                 case 'J':
 324                         ctl.json = 1;
 325                         break;
 326                 case 'r':
 327                         ctl.raw = 1;
 328                         break;
 329                 case 'V':
 330                         print_version(EXIT_SUCCESS);
 331                 case 'h':
 332                         usage();
 333                 default:
 334                         errtryhelp(EXIT_FAILURE);
 335                 }
 336         }
 337
 338         if (optind == argc) {
 339                 warnx(_("no file specified"));
 340                 errtryhelp(EXIT_FAILURE);
 341         }
 342
 343         if (!ncolumns) {
 344                 columns[ncolumns++] = COL_RES;
 345                 columns[ncolumns++] = COL_PAGES;
 346                 columns[ncolumns++] = COL_SIZE;
 347                 columns[ncolumns++] = COL_FILE;
 348         }
 349
 350         if (outarg && string_add_to_idarray(outarg, columns, ARRAY_SIZE(columns),
 351                                          &ncolumns, column_name_to_id) < 0)
 352                 return EXIT_FAILURE;
 353
 354         scols_init_debug(0);
 355         ctl.tb = scols_new_table();
 356         if (!ctl.tb)
 357                 err(EXIT_FAILURE, _("failed to allocate output table"));
 358
 359         scols_table_enable_noheadings(ctl.tb, ctl.noheadings);
 360         scols_table_enable_raw(ctl.tb, ctl.raw);
 361         scols_table_enable_json(ctl.tb, ctl.json);
 362         if (ctl.json)
 363                 scols_table_set_name(ctl.tb, "fincore");
 364
 365         for (i = 0; i < ncolumns; i++) {
 366                 const struct colinfo *col = get_column_info(i);
 367                 struct libscols_column *cl;
 368
 369                 cl = scols_table_new_column(ctl.tb, col->name, col->whint, col->flags);
 370                 if (!cl)
 371                         err(EXIT_FAILURE, _("failed to allocate output column"));
 372
 373                 if (ctl.json) {
 374                         int id = get_column_id(i);
 375
 376                         switch (id) {
 377                         case COL_FILE:
 378                                 scols_column_set_json_type(cl, SCOLS_JSON_STRING);
 379                                 break;
 380                         case COL_SIZE:
 381                         case COL_RES:
 382                                 if (!ctl.bytes)
 383                                         break;
 384                                 /* fallthrough */
 385                         default:
 386                                 scols_column_set_json_type(cl, SCOLS_JSON_NUMBER);
 387                                 break;
 388                         }
 389                 }
 390         }
 391
 392         for(; optind < argc; optind++) {
 393                 char *name = argv[optind];
 394                 struct stat sb;
 395                 off_t count_incore = 0;
 396
 397                 switch (fincore_name(&ctl, name, &sb, &count_incore)) {
 398                 case 0:
 399                         add_output_data(&ctl, name, sb.st_size, count_incore);
 400                         break;
 401                 case 1:
 402                         break; /* ignore */
 403                 default:
 404                         rc = EXIT_FAILURE;
 405                         break;
 406                 }
 407         }
 408
 409         scols_print_table(ctl.tb);
 410         scols_unref_table(ctl.tb);
 411
 412         return rc;
 413 }